// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.6
// 	protoc        v5.29.2
// source: node.proto

package avsproto

import (
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	timestamppb "google.golang.org/protobuf/types/known/timestamppb"
	wrapperspb "google.golang.org/protobuf/types/known/wrapperspb"
	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 MessageOp int32

const (
	MessageOp_Unset              MessageOp = 0
	MessageOp_MonitorTaskTrigger MessageOp = 1
	MessageOp_CancelTask         MessageOp = 2
	MessageOp_DeleteTask         MessageOp = 3
	MessageOp_CompletedTask      MessageOp = 4
	MessageOp_ImmediateTrigger   MessageOp = 5
)

// Enum value maps for MessageOp.
var (
	MessageOp_name = map[int32]string{
		0: "Unset",
		1: "MonitorTaskTrigger",
		2: "CancelTask",
		3: "DeleteTask",
		4: "CompletedTask",
		5: "ImmediateTrigger",
	}
	MessageOp_value = map[string]int32{
		"Unset":              0,
		"MonitorTaskTrigger": 1,
		"CancelTask":         2,
		"DeleteTask":         3,
		"CompletedTask":      4,
		"ImmediateTrigger":   5,
	}
)

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

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

func (MessageOp) Descriptor() protoreflect.EnumDescriptor {
	return file_node_proto_enumTypes[0].Descriptor()
}

func (MessageOp) Type() protoreflect.EnumType {
	return &file_node_proto_enumTypes[0]
}

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

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

type Checkin struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Id            string                 `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Address       string                 `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
	Signature     string                 `protobuf:"bytes,3,opt,name=signature,proto3" json:"signature,omitempty"`
	Status        *Checkin_Status        `protobuf:"bytes,4,opt,name=status,proto3" json:"status,omitempty"`
	Version       string                 `protobuf:"bytes,5,opt,name=version,proto3" json:"version,omitempty"`
	MetricsPort   int32                  `protobuf:"varint,6,opt,name=metricsPort,proto3" json:"metricsPort,omitempty"`
	RemoteIP      string                 `protobuf:"bytes,7,opt,name=remoteIP,proto3" json:"remoteIP,omitempty"`
	BlockNumber   int64                  `protobuf:"varint,8,opt,name=block_number,json=blockNumber,proto3" json:"block_number,omitempty"`
	EventCount    int64                  `protobuf:"varint,9,opt,name=event_count,json=eventCount,proto3" json:"event_count,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Checkin) ProtoMessage() {}

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

func (x *Checkin) GetId() string {
	if x != nil {
		return x.Id
	}
	return ""
}

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

func (x *Checkin) GetSignature() string {
	if x != nil {
		return x.Signature
	}
	return ""
}

func (x *Checkin) GetStatus() *Checkin_Status {
	if x != nil {
		return x.Status
	}
	return nil
}

func (x *Checkin) GetVersion() string {
	if x != nil {
		return x.Version
	}
	return ""
}

func (x *Checkin) GetMetricsPort() int32 {
	if x != nil {
		return x.MetricsPort
	}
	return 0
}

func (x *Checkin) GetRemoteIP() string {
	if x != nil {
		return x.RemoteIP
	}
	return ""
}

func (x *Checkin) GetBlockNumber() int64 {
	if x != nil {
		return x.BlockNumber
	}
	return 0
}

func (x *Checkin) GetEventCount() int64 {
	if x != nil {
		return x.EventCount
	}
	return 0
}

type CheckinResp struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	UpdatedAt     *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=updated_at,json=updatedAt,proto3" json:"updated_at,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*CheckinResp) ProtoMessage() {}

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

func (x *CheckinResp) GetUpdatedAt() *timestamppb.Timestamp {
	if x != nil {
		return x.UpdatedAt
	}
	return nil
}

type SyncMessagesReq struct {
	state          protoimpl.MessageState        `protogen:"open.v1"`
	Id             string                        `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Address        string                        `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
	Signature      []byte                        `protobuf:"bytes,3,opt,name=signature,proto3" json:"signature,omitempty"`
	MonotonicClock int64                         `protobuf:"varint,4,opt,name=monotonic_clock,json=monotonicClock,proto3" json:"monotonic_clock,omitempty"`
	Capabilities   *SyncMessagesReq_Capabilities `protobuf:"bytes,5,opt,name=capabilities,proto3" json:"capabilities,omitempty"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

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

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

func (*SyncMessagesReq) ProtoMessage() {}

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

func (x *SyncMessagesReq) GetId() string {
	if x != nil {
		return x.Id
	}
	return ""
}

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

func (x *SyncMessagesReq) GetSignature() []byte {
	if x != nil {
		return x.Signature
	}
	return nil
}

func (x *SyncMessagesReq) GetMonotonicClock() int64 {
	if x != nil {
		return x.MonotonicClock
	}
	return 0
}

func (x *SyncMessagesReq) GetCapabilities() *SyncMessagesReq_Capabilities {
	if x != nil {
		return x.Capabilities
	}
	return nil
}

type SyncMessagesResp struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// message id is used to support dedup
	Id            string                         `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Op            MessageOp                      `protobuf:"varint,2,opt,name=op,proto3,enum=aggregator.MessageOp" json:"op,omitempty"`
	TaskMetadata  *SyncMessagesResp_TaskMetadata `protobuf:"bytes,3,opt,name=task_metadata,json=taskMetadata,proto3" json:"task_metadata,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*SyncMessagesResp) ProtoMessage() {}

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

func (x *SyncMessagesResp) GetId() string {
	if x != nil {
		return x.Id
	}
	return ""
}

func (x *SyncMessagesResp) GetOp() MessageOp {
	if x != nil {
		return x.Op
	}
	return MessageOp_Unset
}

func (x *SyncMessagesResp) GetTaskMetadata() *SyncMessagesResp_TaskMetadata {
	if x != nil {
		return x.TaskMetadata
	}
	return nil
}

type AckMessageReq struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Id            string                 `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*AckMessageReq) ProtoMessage() {}

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

func (x *AckMessageReq) GetId() string {
	if x != nil {
		return x.Id
	}
	return ""
}

type NotifyTriggersReq struct {
	state     protoimpl.MessageState `protogen:"open.v1"`
	Address   string                 `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
	Signature string                 `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
	TaskId    string                 `protobuf:"bytes,3,opt,name=task_id,json=taskId,proto3" json:"task_id,omitempty"`
	// Flattened from TriggerReason: Use the top-level TriggerType enum for consistency
	TriggerType TriggerType `protobuf:"varint,4,opt,name=trigger_type,json=triggerType,proto3,enum=aggregator.TriggerType" json:"trigger_type,omitempty"`
	// Flattened from TriggerReason: trigger output data based on type
	//
	// Types that are valid to be assigned to TriggerOutput:
	//
	//	*NotifyTriggersReq_BlockTrigger
	//	*NotifyTriggersReq_FixedTimeTrigger
	//	*NotifyTriggersReq_CronTrigger
	//	*NotifyTriggersReq_EventTrigger
	//	*NotifyTriggersReq_ManualTrigger
	TriggerOutput isNotifyTriggersReq_TriggerOutput `protobuf_oneof:"trigger_output"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*NotifyTriggersReq) ProtoMessage() {}

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

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

func (x *NotifyTriggersReq) GetSignature() string {
	if x != nil {
		return x.Signature
	}
	return ""
}

func (x *NotifyTriggersReq) GetTaskId() string {
	if x != nil {
		return x.TaskId
	}
	return ""
}

func (x *NotifyTriggersReq) GetTriggerType() TriggerType {
	if x != nil {
		return x.TriggerType
	}
	return TriggerType_TRIGGER_TYPE_UNSPECIFIED
}

func (x *NotifyTriggersReq) GetTriggerOutput() isNotifyTriggersReq_TriggerOutput {
	if x != nil {
		return x.TriggerOutput
	}
	return nil
}

func (x *NotifyTriggersReq) GetBlockTrigger() *BlockTrigger_Output {
	if x != nil {
		if x, ok := x.TriggerOutput.(*NotifyTriggersReq_BlockTrigger); ok {
			return x.BlockTrigger
		}
	}
	return nil
}

func (x *NotifyTriggersReq) GetFixedTimeTrigger() *FixedTimeTrigger_Output {
	if x != nil {
		if x, ok := x.TriggerOutput.(*NotifyTriggersReq_FixedTimeTrigger); ok {
			return x.FixedTimeTrigger
		}
	}
	return nil
}

func (x *NotifyTriggersReq) GetCronTrigger() *CronTrigger_Output {
	if x != nil {
		if x, ok := x.TriggerOutput.(*NotifyTriggersReq_CronTrigger); ok {
			return x.CronTrigger
		}
	}
	return nil
}

func (x *NotifyTriggersReq) GetEventTrigger() *EventTrigger_Output {
	if x != nil {
		if x, ok := x.TriggerOutput.(*NotifyTriggersReq_EventTrigger); ok {
			return x.EventTrigger
		}
	}
	return nil
}

func (x *NotifyTriggersReq) GetManualTrigger() *ManualTrigger_Output {
	if x != nil {
		if x, ok := x.TriggerOutput.(*NotifyTriggersReq_ManualTrigger); ok {
			return x.ManualTrigger
		}
	}
	return nil
}

type isNotifyTriggersReq_TriggerOutput interface {
	isNotifyTriggersReq_TriggerOutput()
}

type NotifyTriggersReq_BlockTrigger struct {
	BlockTrigger *BlockTrigger_Output `protobuf:"bytes,5,opt,name=block_trigger,json=blockTrigger,proto3,oneof"`
}

type NotifyTriggersReq_FixedTimeTrigger struct {
	FixedTimeTrigger *FixedTimeTrigger_Output `protobuf:"bytes,6,opt,name=fixed_time_trigger,json=fixedTimeTrigger,proto3,oneof"`
}

type NotifyTriggersReq_CronTrigger struct {
	CronTrigger *CronTrigger_Output `protobuf:"bytes,7,opt,name=cron_trigger,json=cronTrigger,proto3,oneof"`
}

type NotifyTriggersReq_EventTrigger struct {
	EventTrigger *EventTrigger_Output `protobuf:"bytes,8,opt,name=event_trigger,json=eventTrigger,proto3,oneof"`
}

type NotifyTriggersReq_ManualTrigger struct {
	ManualTrigger *ManualTrigger_Output `protobuf:"bytes,9,opt,name=manual_trigger,json=manualTrigger,proto3,oneof"`
}

func (*NotifyTriggersReq_BlockTrigger) isNotifyTriggersReq_TriggerOutput() {}

func (*NotifyTriggersReq_FixedTimeTrigger) isNotifyTriggersReq_TriggerOutput() {}

func (*NotifyTriggersReq_CronTrigger) isNotifyTriggersReq_TriggerOutput() {}

func (*NotifyTriggersReq_EventTrigger) isNotifyTriggersReq_TriggerOutput() {}

func (*NotifyTriggersReq_ManualTrigger) isNotifyTriggersReq_TriggerOutput() {}

type NotifyTriggersResp struct {
	state     protoimpl.MessageState `protogen:"open.v1"`
	UpdatedAt *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=updated_at,json=updatedAt,proto3" json:"updated_at,omitempty"`
	// Task execution state information
	RemainingExecutions int64  `protobuf:"varint,2,opt,name=remaining_executions,json=remainingExecutions,proto3" json:"remaining_executions,omitempty"` // How many executions are left for this task
	TaskStillActive     bool   `protobuf:"varint,3,opt,name=task_still_active,json=taskStillActive,proto3" json:"task_still_active,omitempty"`           // Whether the task is still active and should be monitored
	Status              string `protobuf:"bytes,4,opt,name=status,proto3" json:"status,omitempty"`                                                       // Task status: "active", "exhausted", "cancelled", "expired", etc.
	Message             string `protobuf:"bytes,5,opt,name=message,proto3" json:"message,omitempty"`                                                     // Optional message for debugging/logging
	unknownFields       protoimpl.UnknownFields
	sizeCache           protoimpl.SizeCache
}

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

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

func (*NotifyTriggersResp) ProtoMessage() {}

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

func (x *NotifyTriggersResp) GetUpdatedAt() *timestamppb.Timestamp {
	if x != nil {
		return x.UpdatedAt
	}
	return nil
}

func (x *NotifyTriggersResp) GetRemainingExecutions() int64 {
	if x != nil {
		return x.RemainingExecutions
	}
	return 0
}

func (x *NotifyTriggersResp) GetTaskStillActive() bool {
	if x != nil {
		return x.TaskStillActive
	}
	return false
}

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

func (x *NotifyTriggersResp) GetMessage() string {
	if x != nil {
		return x.Message
	}
	return ""
}

// EventOverloadAlert is sent by operators to aggregator when event query processing
// exceeds safety limits, triggering task cancellation and Sentry alerts
type EventOverloadAlert struct {
	state           protoimpl.MessageState `protogen:"open.v1"`
	TaskId          string                 `protobuf:"bytes,1,opt,name=task_id,json=taskId,proto3" json:"task_id,omitempty"`                            // Task ID that triggered the overload
	OperatorAddress string                 `protobuf:"bytes,2,opt,name=operator_address,json=operatorAddress,proto3" json:"operator_address,omitempty"` // Address of the operator reporting the overload
	BlockNumber     uint64                 `protobuf:"varint,3,opt,name=block_number,json=blockNumber,proto3" json:"block_number,omitempty"`            // Block number where overload was detected
	EventsDetected  uint32                 `protobuf:"varint,4,opt,name=events_detected,json=eventsDetected,proto3" json:"events_detected,omitempty"`   // Number of events that triggered the alert
	SafetyLimit     uint32                 `protobuf:"varint,5,opt,name=safety_limit,json=safetyLimit,proto3" json:"safety_limit,omitempty"`            // The safety limit that was exceeded
	QueryIndex      string                 `protobuf:"bytes,6,opt,name=query_index,json=queryIndex,proto3" json:"query_index,omitempty"`                // Index/identifier of the specific query that overloaded
	Timestamp       uint64                 `protobuf:"varint,7,opt,name=timestamp,proto3" json:"timestamp,omitempty"`                                   // Timestamp when overload was detected (milliseconds)
	Details         string                 `protobuf:"bytes,8,opt,name=details,proto3" json:"details,omitempty"`                                        // Additional context about the overload
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

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

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

func (*EventOverloadAlert) ProtoMessage() {}

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

func (x *EventOverloadAlert) GetTaskId() string {
	if x != nil {
		return x.TaskId
	}
	return ""
}

func (x *EventOverloadAlert) GetOperatorAddress() string {
	if x != nil {
		return x.OperatorAddress
	}
	return ""
}

func (x *EventOverloadAlert) GetBlockNumber() uint64 {
	if x != nil {
		return x.BlockNumber
	}
	return 0
}

func (x *EventOverloadAlert) GetEventsDetected() uint32 {
	if x != nil {
		return x.EventsDetected
	}
	return 0
}

func (x *EventOverloadAlert) GetSafetyLimit() uint32 {
	if x != nil {
		return x.SafetyLimit
	}
	return 0
}

func (x *EventOverloadAlert) GetQueryIndex() string {
	if x != nil {
		return x.QueryIndex
	}
	return ""
}

func (x *EventOverloadAlert) GetTimestamp() uint64 {
	if x != nil {
		return x.Timestamp
	}
	return 0
}

func (x *EventOverloadAlert) GetDetails() string {
	if x != nil {
		return x.Details
	}
	return ""
}

// EventOverloadResponse is the aggregator's response to an overload alert
type EventOverloadResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	TaskCancelled bool                   `protobuf:"varint,1,opt,name=task_cancelled,json=taskCancelled,proto3" json:"task_cancelled,omitempty"` // Whether the task was cancelled due to overload
	Message       string                 `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`                                   // Response message/reason
	Timestamp     uint64                 `protobuf:"varint,3,opt,name=timestamp,proto3" json:"timestamp,omitempty"`                              // Response timestamp (milliseconds)
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*EventOverloadResponse) ProtoMessage() {}

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

func (x *EventOverloadResponse) GetTaskCancelled() bool {
	if x != nil {
		return x.TaskCancelled
	}
	return false
}

func (x *EventOverloadResponse) GetMessage() string {
	if x != nil {
		return x.Message
	}
	return ""
}

func (x *EventOverloadResponse) GetTimestamp() uint64 {
	if x != nil {
		return x.Timestamp
	}
	return 0
}

// HealthCheck messages for connection testing
type HealthCheckRequest struct {
	state           protoimpl.MessageState `protogen:"open.v1"`
	OperatorAddress string                 `protobuf:"bytes,1,opt,name=operator_address,json=operatorAddress,proto3" json:"operator_address,omitempty"` // Optional: operator address for logging
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

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

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

func (*HealthCheckRequest) ProtoMessage() {}

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

func (x *HealthCheckRequest) GetOperatorAddress() string {
	if x != nil {
		return x.OperatorAddress
	}
	return ""
}

type HealthCheckResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Status        string                 `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`        // Status: "OK", "STARTING", etc.
	Message       string                 `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`      // Optional message
	Timestamp     uint64                 `protobuf:"varint,3,opt,name=timestamp,proto3" json:"timestamp,omitempty"` // Response timestamp (milliseconds)
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*HealthCheckResponse) ProtoMessage() {}

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

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

func (x *HealthCheckResponse) GetMessage() string {
	if x != nil {
		return x.Message
	}
	return ""
}

func (x *HealthCheckResponse) GetTimestamp() uint64 {
	if x != nil {
		return x.Timestamp
	}
	return 0
}

type Checkin_Status struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Uptime        int64                  `protobuf:"varint,1,opt,name=uptime,proto3" json:"uptime,omitempty"`
	QueueDepth    int64                  `protobuf:"varint,2,opt,name=queueDepth,proto3" json:"queueDepth,omitempty"`
	LastHeartbeat *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=last_heartbeat,json=lastHeartbeat,proto3" json:"last_heartbeat,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Checkin_Status) ProtoMessage() {}

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

func (x *Checkin_Status) GetUptime() int64 {
	if x != nil {
		return x.Uptime
	}
	return 0
}

func (x *Checkin_Status) GetQueueDepth() int64 {
	if x != nil {
		return x.QueueDepth
	}
	return 0
}

func (x *Checkin_Status) GetLastHeartbeat() *timestamppb.Timestamp {
	if x != nil {
		return x.LastHeartbeat
	}
	return nil
}

// Operator capabilities - what trigger types this operator supports
type SyncMessagesReq_Capabilities struct {
	state           protoimpl.MessageState `protogen:"open.v1"`
	EventMonitoring bool                   `protobuf:"varint,1,opt,name=event_monitoring,json=eventMonitoring,proto3" json:"event_monitoring,omitempty"` // Supports event trigger monitoring
	BlockMonitoring bool                   `protobuf:"varint,2,opt,name=block_monitoring,json=blockMonitoring,proto3" json:"block_monitoring,omitempty"` // Supports block trigger monitoring
	TimeMonitoring  bool                   `protobuf:"varint,3,opt,name=time_monitoring,json=timeMonitoring,proto3" json:"time_monitoring,omitempty"`    // Supports time/cron trigger monitoring
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

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

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

func (*SyncMessagesReq_Capabilities) ProtoMessage() {}

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

func (x *SyncMessagesReq_Capabilities) GetEventMonitoring() bool {
	if x != nil {
		return x.EventMonitoring
	}
	return false
}

func (x *SyncMessagesReq_Capabilities) GetBlockMonitoring() bool {
	if x != nil {
		return x.BlockMonitoring
	}
	return false
}

func (x *SyncMessagesReq_Capabilities) GetTimeMonitoring() bool {
	if x != nil {
		return x.TimeMonitoring
	}
	return false
}

type SyncMessagesResp_TaskMetadata struct {
	state  protoimpl.MessageState `protogen:"open.v1"`
	TaskId string                 `protobuf:"bytes,1,opt,name=task_id,json=taskId,proto3" json:"task_id,omitempty"`
	// how many time this task can run
	Remain    int64        `protobuf:"varint,2,opt,name=remain,proto3" json:"remain,omitempty"`
	ExpiredAt int64        `protobuf:"varint,3,opt,name=expired_at,json=expiredAt,proto3" json:"expired_at,omitempty"`
	Trigger   *TaskTrigger `protobuf:"bytes,4,opt,name=trigger,proto3" json:"trigger,omitempty"`
	// task won't be checked before this (timestamp in milliseconds)
	StartAt       int64 `protobuf:"varint,5,opt,name=start_at,json=startAt,proto3" json:"start_at,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*SyncMessagesResp_TaskMetadata) ProtoMessage() {}

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

func (x *SyncMessagesResp_TaskMetadata) GetTaskId() string {
	if x != nil {
		return x.TaskId
	}
	return ""
}

func (x *SyncMessagesResp_TaskMetadata) GetRemain() int64 {
	if x != nil {
		return x.Remain
	}
	return 0
}

func (x *SyncMessagesResp_TaskMetadata) GetExpiredAt() int64 {
	if x != nil {
		return x.ExpiredAt
	}
	return 0
}

func (x *SyncMessagesResp_TaskMetadata) GetTrigger() *TaskTrigger {
	if x != nil {
		return x.Trigger
	}
	return nil
}

func (x *SyncMessagesResp_TaskMetadata) GetStartAt() int64 {
	if x != nil {
		return x.StartAt
	}
	return 0
}

var File_node_proto protoreflect.FileDescriptor

const file_node_proto_rawDesc = "" +
	"\n" +
	"\n" +
	"node.proto\x12\n" +
	"aggregator\x1a\x1fgoogle/protobuf/timestamp.proto\x1a\x1egoogle/protobuf/wrappers.proto\x1a\tavs.proto\"\xa7\x03\n" +
	"\aCheckin\x12\x0e\n" +
	"\x02id\x18\x01 \x01(\tR\x02id\x12\x18\n" +
	"\aaddress\x18\x02 \x01(\tR\aaddress\x12\x1c\n" +
	"\tsignature\x18\x03 \x01(\tR\tsignature\x122\n" +
	"\x06status\x18\x04 \x01(\v2\x1a.aggregator.Checkin.StatusR\x06status\x12\x18\n" +
	"\aversion\x18\x05 \x01(\tR\aversion\x12 \n" +
	"\vmetricsPort\x18\x06 \x01(\x05R\vmetricsPort\x12\x1a\n" +
	"\bremoteIP\x18\a \x01(\tR\bremoteIP\x12!\n" +
	"\fblock_number\x18\b \x01(\x03R\vblockNumber\x12\x1f\n" +
	"\vevent_count\x18\t \x01(\x03R\n" +
	"eventCount\x1a\x83\x01\n" +
	"\x06Status\x12\x16\n" +
	"\x06uptime\x18\x01 \x01(\x03R\x06uptime\x12\x1e\n" +
	"\n" +
	"queueDepth\x18\x02 \x01(\x03R\n" +
	"queueDepth\x12A\n" +
	"\x0elast_heartbeat\x18\x03 \x01(\v2\x1a.google.protobuf.TimestampR\rlastHeartbeat\"H\n" +
	"\vCheckinResp\x129\n" +
	"\n" +
	"updated_at\x18\x01 \x01(\v2\x1a.google.protobuf.TimestampR\tupdatedAt\"\xe0\x02\n" +
	"\x0fSyncMessagesReq\x12\x0e\n" +
	"\x02id\x18\x01 \x01(\tR\x02id\x12\x18\n" +
	"\aaddress\x18\x02 \x01(\tR\aaddress\x12\x1c\n" +
	"\tsignature\x18\x03 \x01(\fR\tsignature\x12'\n" +
	"\x0fmonotonic_clock\x18\x04 \x01(\x03R\x0emonotonicClock\x12L\n" +
	"\fcapabilities\x18\x05 \x01(\v2(.aggregator.SyncMessagesReq.CapabilitiesR\fcapabilities\x1a\x8d\x01\n" +
	"\fCapabilities\x12)\n" +
	"\x10event_monitoring\x18\x01 \x01(\bR\x0feventMonitoring\x12)\n" +
	"\x10block_monitoring\x18\x02 \x01(\bR\x0fblockMonitoring\x12'\n" +
	"\x0ftime_monitoring\x18\x03 \x01(\bR\x0etimeMonitoring\"\xc8\x02\n" +
	"\x10SyncMessagesResp\x12\x0e\n" +
	"\x02id\x18\x01 \x01(\tR\x02id\x12%\n" +
	"\x02op\x18\x02 \x01(\x0e2\x15.aggregator.MessageOpR\x02op\x12N\n" +
	"\rtask_metadata\x18\x03 \x01(\v2).aggregator.SyncMessagesResp.TaskMetadataR\ftaskMetadata\x1a\xac\x01\n" +
	"\fTaskMetadata\x12\x17\n" +
	"\atask_id\x18\x01 \x01(\tR\x06taskId\x12\x16\n" +
	"\x06remain\x18\x02 \x01(\x03R\x06remain\x12\x1d\n" +
	"\n" +
	"expired_at\x18\x03 \x01(\x03R\texpiredAt\x121\n" +
	"\atrigger\x18\x04 \x01(\v2\x17.aggregator.TaskTriggerR\atrigger\x12\x19\n" +
	"\bstart_at\x18\x05 \x01(\x03R\astartAt\"\x1f\n" +
	"\rAckMessageReq\x12\x0e\n" +
	"\x02id\x18\x01 \x01(\tR\x02id\"\xa7\x04\n" +
	"\x11NotifyTriggersReq\x12\x18\n" +
	"\aaddress\x18\x01 \x01(\tR\aaddress\x12\x1c\n" +
	"\tsignature\x18\x02 \x01(\tR\tsignature\x12\x17\n" +
	"\atask_id\x18\x03 \x01(\tR\x06taskId\x12:\n" +
	"\ftrigger_type\x18\x04 \x01(\x0e2\x17.aggregator.TriggerTypeR\vtriggerType\x12F\n" +
	"\rblock_trigger\x18\x05 \x01(\v2\x1f.aggregator.BlockTrigger.OutputH\x00R\fblockTrigger\x12S\n" +
	"\x12fixed_time_trigger\x18\x06 \x01(\v2#.aggregator.FixedTimeTrigger.OutputH\x00R\x10fixedTimeTrigger\x12C\n" +
	"\fcron_trigger\x18\a \x01(\v2\x1e.aggregator.CronTrigger.OutputH\x00R\vcronTrigger\x12F\n" +
	"\revent_trigger\x18\b \x01(\v2\x1f.aggregator.EventTrigger.OutputH\x00R\feventTrigger\x12I\n" +
	"\x0emanual_trigger\x18\t \x01(\v2 .aggregator.ManualTrigger.OutputH\x00R\rmanualTriggerB\x10\n" +
	"\x0etrigger_output\"\xe0\x01\n" +
	"\x12NotifyTriggersResp\x129\n" +
	"\n" +
	"updated_at\x18\x01 \x01(\v2\x1a.google.protobuf.TimestampR\tupdatedAt\x121\n" +
	"\x14remaining_executions\x18\x02 \x01(\x03R\x13remainingExecutions\x12*\n" +
	"\x11task_still_active\x18\x03 \x01(\bR\x0ftaskStillActive\x12\x16\n" +
	"\x06status\x18\x04 \x01(\tR\x06status\x12\x18\n" +
	"\amessage\x18\x05 \x01(\tR\amessage\"\xa0\x02\n" +
	"\x12EventOverloadAlert\x12\x17\n" +
	"\atask_id\x18\x01 \x01(\tR\x06taskId\x12)\n" +
	"\x10operator_address\x18\x02 \x01(\tR\x0foperatorAddress\x12!\n" +
	"\fblock_number\x18\x03 \x01(\x04R\vblockNumber\x12'\n" +
	"\x0fevents_detected\x18\x04 \x01(\rR\x0eeventsDetected\x12!\n" +
	"\fsafety_limit\x18\x05 \x01(\rR\vsafetyLimit\x12\x1f\n" +
	"\vquery_index\x18\x06 \x01(\tR\n" +
	"queryIndex\x12\x1c\n" +
	"\ttimestamp\x18\a \x01(\x04R\ttimestamp\x12\x18\n" +
	"\adetails\x18\b \x01(\tR\adetails\"v\n" +
	"\x15EventOverloadResponse\x12%\n" +
	"\x0etask_cancelled\x18\x01 \x01(\bR\rtaskCancelled\x12\x18\n" +
	"\amessage\x18\x02 \x01(\tR\amessage\x12\x1c\n" +
	"\ttimestamp\x18\x03 \x01(\x04R\ttimestamp\"?\n" +
	"\x12HealthCheckRequest\x12)\n" +
	"\x10operator_address\x18\x01 \x01(\tR\x0foperatorAddress\"e\n" +
	"\x13HealthCheckResponse\x12\x16\n" +
	"\x06status\x18\x01 \x01(\tR\x06status\x12\x18\n" +
	"\amessage\x18\x02 \x01(\tR\amessage\x12\x1c\n" +
	"\ttimestamp\x18\x03 \x01(\x04R\ttimestamp*w\n" +
	"\tMessageOp\x12\t\n" +
	"\x05Unset\x10\x00\x12\x16\n" +
	"\x12MonitorTaskTrigger\x10\x01\x12\x0e\n" +
	"\n" +
	"CancelTask\x10\x02\x12\x0e\n" +
	"\n" +
	"DeleteTask\x10\x03\x12\x11\n" +
	"\rCompletedTask\x10\x04\x12\x14\n" +
	"\x10ImmediateTrigger\x10\x052\xcc\x03\n" +
	"\x04Node\x12P\n" +
	"\vHealthCheck\x12\x1e.aggregator.HealthCheckRequest\x1a\x1f.aggregator.HealthCheckResponse\"\x00\x126\n" +
	"\x04Ping\x12\x13.aggregator.Checkin\x1a\x17.aggregator.CheckinResp\"\x00\x12M\n" +
	"\fSyncMessages\x12\x1b.aggregator.SyncMessagesReq\x1a\x1c.aggregator.SyncMessagesResp\"\x000\x01\x12>\n" +
	"\x03Ack\x12\x19.aggregator.AckMessageReq\x1a\x1a.google.protobuf.BoolValue\"\x00\x12Q\n" +
	"\x0eNotifyTriggers\x12\x1d.aggregator.NotifyTriggersReq\x1a\x1e.aggregator.NotifyTriggersResp\"\x00\x12X\n" +
	"\x13ReportEventOverload\x12\x1e.aggregator.EventOverloadAlert\x1a!.aggregator.EventOverloadResponseB\fZ\n" +
	"./avsprotob\x06proto3"

var (
	file_node_proto_rawDescOnce sync.Once
	file_node_proto_rawDescData []byte
)

func file_node_proto_rawDescGZIP() []byte {
	file_node_proto_rawDescOnce.Do(func() {
		file_node_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_node_proto_rawDesc), len(file_node_proto_rawDesc)))
	})
	return file_node_proto_rawDescData
}

var file_node_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
var file_node_proto_msgTypes = make([]protoimpl.MessageInfo, 14)
var file_node_proto_goTypes = []any{
	(MessageOp)(0),                        // 0: aggregator.MessageOp
	(*Checkin)(nil),                       // 1: aggregator.Checkin
	(*CheckinResp)(nil),                   // 2: aggregator.CheckinResp
	(*SyncMessagesReq)(nil),               // 3: aggregator.SyncMessagesReq
	(*SyncMessagesResp)(nil),              // 4: aggregator.SyncMessagesResp
	(*AckMessageReq)(nil),                 // 5: aggregator.AckMessageReq
	(*NotifyTriggersReq)(nil),             // 6: aggregator.NotifyTriggersReq
	(*NotifyTriggersResp)(nil),            // 7: aggregator.NotifyTriggersResp
	(*EventOverloadAlert)(nil),            // 8: aggregator.EventOverloadAlert
	(*EventOverloadResponse)(nil),         // 9: aggregator.EventOverloadResponse
	(*HealthCheckRequest)(nil),            // 10: aggregator.HealthCheckRequest
	(*HealthCheckResponse)(nil),           // 11: aggregator.HealthCheckResponse
	(*Checkin_Status)(nil),                // 12: aggregator.Checkin.Status
	(*SyncMessagesReq_Capabilities)(nil),  // 13: aggregator.SyncMessagesReq.Capabilities
	(*SyncMessagesResp_TaskMetadata)(nil), // 14: aggregator.SyncMessagesResp.TaskMetadata
	(*timestamppb.Timestamp)(nil),         // 15: google.protobuf.Timestamp
	(TriggerType)(0),                      // 16: aggregator.TriggerType
	(*BlockTrigger_Output)(nil),           // 17: aggregator.BlockTrigger.Output
	(*FixedTimeTrigger_Output)(nil),       // 18: aggregator.FixedTimeTrigger.Output
	(*CronTrigger_Output)(nil),            // 19: aggregator.CronTrigger.Output
	(*EventTrigger_Output)(nil),           // 20: aggregator.EventTrigger.Output
	(*ManualTrigger_Output)(nil),          // 21: aggregator.ManualTrigger.Output
	(*TaskTrigger)(nil),                   // 22: aggregator.TaskTrigger
	(*wrapperspb.BoolValue)(nil),          // 23: google.protobuf.BoolValue
}
var file_node_proto_depIdxs = []int32{
	12, // 0: aggregator.Checkin.status:type_name -> aggregator.Checkin.Status
	15, // 1: aggregator.CheckinResp.updated_at:type_name -> google.protobuf.Timestamp
	13, // 2: aggregator.SyncMessagesReq.capabilities:type_name -> aggregator.SyncMessagesReq.Capabilities
	0,  // 3: aggregator.SyncMessagesResp.op:type_name -> aggregator.MessageOp
	14, // 4: aggregator.SyncMessagesResp.task_metadata:type_name -> aggregator.SyncMessagesResp.TaskMetadata
	16, // 5: aggregator.NotifyTriggersReq.trigger_type:type_name -> aggregator.TriggerType
	17, // 6: aggregator.NotifyTriggersReq.block_trigger:type_name -> aggregator.BlockTrigger.Output
	18, // 7: aggregator.NotifyTriggersReq.fixed_time_trigger:type_name -> aggregator.FixedTimeTrigger.Output
	19, // 8: aggregator.NotifyTriggersReq.cron_trigger:type_name -> aggregator.CronTrigger.Output
	20, // 9: aggregator.NotifyTriggersReq.event_trigger:type_name -> aggregator.EventTrigger.Output
	21, // 10: aggregator.NotifyTriggersReq.manual_trigger:type_name -> aggregator.ManualTrigger.Output
	15, // 11: aggregator.NotifyTriggersResp.updated_at:type_name -> google.protobuf.Timestamp
	15, // 12: aggregator.Checkin.Status.last_heartbeat:type_name -> google.protobuf.Timestamp
	22, // 13: aggregator.SyncMessagesResp.TaskMetadata.trigger:type_name -> aggregator.TaskTrigger
	10, // 14: aggregator.Node.HealthCheck:input_type -> aggregator.HealthCheckRequest
	1,  // 15: aggregator.Node.Ping:input_type -> aggregator.Checkin
	3,  // 16: aggregator.Node.SyncMessages:input_type -> aggregator.SyncMessagesReq
	5,  // 17: aggregator.Node.Ack:input_type -> aggregator.AckMessageReq
	6,  // 18: aggregator.Node.NotifyTriggers:input_type -> aggregator.NotifyTriggersReq
	8,  // 19: aggregator.Node.ReportEventOverload:input_type -> aggregator.EventOverloadAlert
	11, // 20: aggregator.Node.HealthCheck:output_type -> aggregator.HealthCheckResponse
	2,  // 21: aggregator.Node.Ping:output_type -> aggregator.CheckinResp
	4,  // 22: aggregator.Node.SyncMessages:output_type -> aggregator.SyncMessagesResp
	23, // 23: aggregator.Node.Ack:output_type -> google.protobuf.BoolValue
	7,  // 24: aggregator.Node.NotifyTriggers:output_type -> aggregator.NotifyTriggersResp
	9,  // 25: aggregator.Node.ReportEventOverload:output_type -> aggregator.EventOverloadResponse
	20, // [20:26] is the sub-list for method output_type
	14, // [14:20] 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_node_proto_init() }
func file_node_proto_init() {
	if File_node_proto != nil {
		return
	}
	file_avs_proto_init()
	file_node_proto_msgTypes[5].OneofWrappers = []any{
		(*NotifyTriggersReq_BlockTrigger)(nil),
		(*NotifyTriggersReq_FixedTimeTrigger)(nil),
		(*NotifyTriggersReq_CronTrigger)(nil),
		(*NotifyTriggersReq_EventTrigger)(nil),
		(*NotifyTriggersReq_ManualTrigger)(nil),
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_node_proto_rawDesc), len(file_node_proto_rawDesc)),
			NumEnums:      1,
			NumMessages:   14,
			NumExtensions: 0,
			NumServices:   1,
		},
		GoTypes:           file_node_proto_goTypes,
		DependencyIndexes: file_node_proto_depIdxs,
		EnumInfos:         file_node_proto_enumTypes,
		MessageInfos:      file_node_proto_msgTypes,
	}.Build()
	File_node_proto = out.File
	file_node_proto_goTypes = nil
	file_node_proto_depIdxs = nil
}
