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

package eventrecorderpb

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

// NotifyReason describes why a notification was sent for an aggregation
// group.
type NotifyReason int32

const (
	// Default / unknown reason.
	NotifyReason_NOTIFY_REASON_UNSPECIFIED NotifyReason = 0
	// The group has never been notified before and contains at least one
	// firing alert.
	NotifyReason_NOTIFY_REASON_FIRST_NOTIFICATION NotifyReason = 1
	// New firing alerts have been added to the group since the last
	// notification.
	NotifyReason_NOTIFY_REASON_NEW_ALERTS_IN_GROUP NotifyReason = 2
	// Some alerts in the group have resolved since the last notification.
	NotifyReason_NOTIFY_REASON_NEW_RESOLVED_ALERTS NotifyReason = 3
	// All alerts in the group have resolved.
	NotifyReason_NOTIFY_REASON_ALL_ALERTS_RESOLVED NotifyReason = 4
	// The configured repeat interval has elapsed since the last
	// notification.
	NotifyReason_NOTIFY_REASON_REPEAT_INTERVAL_ELAPSED NotifyReason = 5
)

// Enum value maps for NotifyReason.
var (
	NotifyReason_name = map[int32]string{
		0: "NOTIFY_REASON_UNSPECIFIED",
		1: "NOTIFY_REASON_FIRST_NOTIFICATION",
		2: "NOTIFY_REASON_NEW_ALERTS_IN_GROUP",
		3: "NOTIFY_REASON_NEW_RESOLVED_ALERTS",
		4: "NOTIFY_REASON_ALL_ALERTS_RESOLVED",
		5: "NOTIFY_REASON_REPEAT_INTERVAL_ELAPSED",
	}
	NotifyReason_value = map[string]int32{
		"NOTIFY_REASON_UNSPECIFIED":             0,
		"NOTIFY_REASON_FIRST_NOTIFICATION":      1,
		"NOTIFY_REASON_NEW_ALERTS_IN_GROUP":     2,
		"NOTIFY_REASON_NEW_RESOLVED_ALERTS":     3,
		"NOTIFY_REASON_ALL_ALERTS_RESOLVED":     4,
		"NOTIFY_REASON_REPEAT_INTERVAL_ELAPSED": 5,
	}
)

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

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

func (NotifyReason) Descriptor() protoreflect.EnumDescriptor {
	return file_eventrecorder_proto_enumTypes[0].Descriptor()
}

func (NotifyReason) Type() protoreflect.EnumType {
	return &file_eventrecorder_proto_enumTypes[0]
}

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

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

// Type enumerates the supported matching operators.
type Matcher_Type int32

const (
	// Unspecified / unknown match type.
	Matcher_TYPE_UNSPECIFIED Matcher_Type = 0
	// Exact string equality (=).
	Matcher_TYPE_EQUAL Matcher_Type = 1
	// Regular expression match (=~).
	Matcher_TYPE_REGEXP Matcher_Type = 2
	// Negated exact string equality (!=).
	Matcher_TYPE_NOT_EQUAL Matcher_Type = 3
	// Negated regular expression match (!~).
	Matcher_TYPE_NOT_REGEXP Matcher_Type = 4
)

// Enum value maps for Matcher_Type.
var (
	Matcher_Type_name = map[int32]string{
		0: "TYPE_UNSPECIFIED",
		1: "TYPE_EQUAL",
		2: "TYPE_REGEXP",
		3: "TYPE_NOT_EQUAL",
		4: "TYPE_NOT_REGEXP",
	}
	Matcher_Type_value = map[string]int32{
		"TYPE_UNSPECIFIED": 0,
		"TYPE_EQUAL":       1,
		"TYPE_REGEXP":      2,
		"TYPE_NOT_EQUAL":   3,
		"TYPE_NOT_REGEXP":  4,
	}
)

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

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

func (Matcher_Type) Descriptor() protoreflect.EnumDescriptor {
	return file_eventrecorder_proto_enumTypes[1].Descriptor()
}

func (Matcher_Type) Type() protoreflect.EnumType {
	return &file_eventrecorder_proto_enumTypes[1]
}

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

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

// Event is the top-level envelope written to each event recorder output.
// It wraps the specific event data with metadata about when and where
// the event was produced.
type Event struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The wall-clock time at which the event was recorded.
	Timestamp *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=timestamp,json=@timestamp,proto3" json:"timestamp,omitempty"`
	// The hostname or address of the Alertmanager instance that produced
	// the event.
	Instance string `protobuf:"bytes,2,opt,name=instance,proto3" json:"instance,omitempty"`
	// The event payload.  Exactly one of the oneof fields inside EventData
	// will be set.
	Data *EventData `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"`
	// The ordinal position of this instance among its HA cluster peers.
	// Zero when clustering is disabled.
	ClusterPosition uint32 `protobuf:"varint,4,opt,name=cluster_position,json=clusterPosition,proto3" json:"cluster_position,omitempty"`
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

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

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

func (*Event) ProtoMessage() {}

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

func (x *Event) GetTimestamp() *timestamppb.Timestamp {
	if x != nil {
		return x.Timestamp
	}
	return nil
}

func (x *Event) GetInstance() string {
	if x != nil {
		return x.Instance
	}
	return ""
}

func (x *Event) GetData() *EventData {
	if x != nil {
		return x.Data
	}
	return nil
}

func (x *Event) GetClusterPosition() uint32 {
	if x != nil {
		return x.ClusterPosition
	}
	return 0
}

// EventData carries the payload for a single event recorder entry.
// Exactly one of the oneof fields will be populated.
type EventData struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to EventType:
	//
	//	*EventData_AlertmanagerStartupEvent
	//	*EventData_AlertmanagerShutdownEvent
	//	*EventData_AlertCreated
	//	*EventData_AlertResolved
	//	*EventData_AlertGrouped
	//	*EventData_Notification
	//	*EventData_SilenceCreated
	//	*EventData_SilenceUpdated
	//	*EventData_SilenceMutedAlert
	//	*EventData_InhibitionMutedAlert
	EventType     isEventData_EventType `protobuf_oneof:"event_type"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*EventData) ProtoMessage() {}

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

func (x *EventData) GetEventType() isEventData_EventType {
	if x != nil {
		return x.EventType
	}
	return nil
}

func (x *EventData) GetAlertmanagerStartupEvent() *AlertmanagerStartupEvent {
	if x != nil {
		if x, ok := x.EventType.(*EventData_AlertmanagerStartupEvent); ok {
			return x.AlertmanagerStartupEvent
		}
	}
	return nil
}

func (x *EventData) GetAlertmanagerShutdownEvent() *AlertmanagerShutdownEvent {
	if x != nil {
		if x, ok := x.EventType.(*EventData_AlertmanagerShutdownEvent); ok {
			return x.AlertmanagerShutdownEvent
		}
	}
	return nil
}

func (x *EventData) GetAlertCreated() *AlertCreatedEvent {
	if x != nil {
		if x, ok := x.EventType.(*EventData_AlertCreated); ok {
			return x.AlertCreated
		}
	}
	return nil
}

func (x *EventData) GetAlertResolved() *AlertResolvedEvent {
	if x != nil {
		if x, ok := x.EventType.(*EventData_AlertResolved); ok {
			return x.AlertResolved
		}
	}
	return nil
}

func (x *EventData) GetAlertGrouped() *AlertGroupedEvent {
	if x != nil {
		if x, ok := x.EventType.(*EventData_AlertGrouped); ok {
			return x.AlertGrouped
		}
	}
	return nil
}

func (x *EventData) GetNotification() *NotificationEvent {
	if x != nil {
		if x, ok := x.EventType.(*EventData_Notification); ok {
			return x.Notification
		}
	}
	return nil
}

func (x *EventData) GetSilenceCreated() *SilenceCreatedEvent {
	if x != nil {
		if x, ok := x.EventType.(*EventData_SilenceCreated); ok {
			return x.SilenceCreated
		}
	}
	return nil
}

func (x *EventData) GetSilenceUpdated() *SilenceUpdatedEvent {
	if x != nil {
		if x, ok := x.EventType.(*EventData_SilenceUpdated); ok {
			return x.SilenceUpdated
		}
	}
	return nil
}

func (x *EventData) GetSilenceMutedAlert() *SilenceMutedAlertEvent {
	if x != nil {
		if x, ok := x.EventType.(*EventData_SilenceMutedAlert); ok {
			return x.SilenceMutedAlert
		}
	}
	return nil
}

func (x *EventData) GetInhibitionMutedAlert() *InhibitionMutedAlertEvent {
	if x != nil {
		if x, ok := x.EventType.(*EventData_InhibitionMutedAlert); ok {
			return x.InhibitionMutedAlert
		}
	}
	return nil
}

type isEventData_EventType interface {
	isEventData_EventType()
}

type EventData_AlertmanagerStartupEvent struct {
	// Recorded when the Alertmanager process starts.
	AlertmanagerStartupEvent *AlertmanagerStartupEvent `protobuf:"bytes,1,opt,name=alertmanager_startup_event,json=alertmanagerStartupEvent,proto3,oneof"`
}

type EventData_AlertmanagerShutdownEvent struct {
	// Recorded when the Alertmanager process shuts down gracefully.
	AlertmanagerShutdownEvent *AlertmanagerShutdownEvent `protobuf:"bytes,2,opt,name=alertmanager_shutdown_event,json=alertmanagerShutdownEvent,proto3,oneof"`
}

type EventData_AlertCreated struct {
	// Recorded when a new alert is first inserted into the alert store.
	AlertCreated *AlertCreatedEvent `protobuf:"bytes,3,opt,name=alert_created,json=alertCreated,proto3,oneof"`
}

type EventData_AlertResolved struct {
	// Recorded when an alert transitions to the resolved state and is
	// removed from its aggregation group after successful notification.
	AlertResolved *AlertResolvedEvent `protobuf:"bytes,4,opt,name=alert_resolved,json=alertResolved,proto3,oneof"`
}

type EventData_AlertGrouped struct {
	// Recorded when an alert is inserted into an aggregation group for
	// the first time.
	AlertGrouped *AlertGroupedEvent `protobuf:"bytes,5,opt,name=alert_grouped,json=alertGrouped,proto3,oneof"`
}

type EventData_Notification struct {
	// Recorded after a notification is successfully delivered to an
	// integration (e.g., webhook, email, PagerDuty).
	Notification *NotificationEvent `protobuf:"bytes,6,opt,name=notification,proto3,oneof"`
}

type EventData_SilenceCreated struct {
	// Recorded when a new silence is created.
	SilenceCreated *SilenceCreatedEvent `protobuf:"bytes,7,opt,name=silence_created,json=silenceCreated,proto3,oneof"`
}

type EventData_SilenceUpdated struct {
	// Recorded when an existing silence is updated (e.g., extended or
	// re-commented).
	SilenceUpdated *SilenceUpdatedEvent `protobuf:"bytes,8,opt,name=silence_updated,json=silenceUpdated,proto3,oneof"`
}

type EventData_SilenceMutedAlert struct {
	// Recorded each time a silence actively suppresses an alert during
	// the muting evaluation pass.
	SilenceMutedAlert *SilenceMutedAlertEvent `protobuf:"bytes,9,opt,name=silence_muted_alert,json=silenceMutedAlert,proto3,oneof"`
}

type EventData_InhibitionMutedAlert struct {
	// Recorded each time one or more inhibition rules suppress an alert
	// during the muting evaluation pass.
	InhibitionMutedAlert *InhibitionMutedAlertEvent `protobuf:"bytes,10,opt,name=inhibition_muted_alert,json=inhibitionMutedAlert,proto3,oneof"`
}

func (*EventData_AlertmanagerStartupEvent) isEventData_EventType() {}

func (*EventData_AlertmanagerShutdownEvent) isEventData_EventType() {}

func (*EventData_AlertCreated) isEventData_EventType() {}

func (*EventData_AlertResolved) isEventData_EventType() {}

func (*EventData_AlertGrouped) isEventData_EventType() {}

func (*EventData_Notification) isEventData_EventType() {}

func (*EventData_SilenceCreated) isEventData_EventType() {}

func (*EventData_SilenceUpdated) isEventData_EventType() {}

func (*EventData_SilenceMutedAlert) isEventData_EventType() {}

func (*EventData_InhibitionMutedAlert) isEventData_EventType() {}

// AlertmanagerStartupEvent is emitted once when the process starts.
type AlertmanagerStartupEvent struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The semantic version of the Alertmanager binary (e.g., "0.28.0").
	Version string `protobuf:"bytes,1,opt,name=version,proto3" json:"version,omitempty"`
	// Free-form build metadata such as Go version, branch, and revision.
	BuildContext  string `protobuf:"bytes,2,opt,name=build_context,json=buildContext,proto3" json:"build_context,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*AlertmanagerStartupEvent) ProtoMessage() {}

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

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

func (x *AlertmanagerStartupEvent) GetBuildContext() string {
	if x != nil {
		return x.BuildContext
	}
	return ""
}

// AlertmanagerShutdownEvent is emitted when the process shuts down
// gracefully.  It carries no additional data.
type AlertmanagerShutdownEvent struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*AlertmanagerShutdownEvent) ProtoMessage() {}

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

// LabelPair is a single key-value label.
type LabelPair struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The label name (e.g., "alertname").
	Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	// The label value (e.g., "HighMemoryUsage").
	Value         string `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*LabelPair) ProtoMessage() {}

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

func (x *LabelPair) GetKey() string {
	if x != nil {
		return x.Key
	}
	return ""
}

func (x *LabelPair) GetValue() string {
	if x != nil {
		return x.Value
	}
	return ""
}

// LabelSet is an ordered collection of label pairs.
type LabelSet struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The label pairs that make up this set.
	Labels        []*LabelPair `protobuf:"bytes,1,rep,name=labels,proto3" json:"labels,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*LabelSet) ProtoMessage() {}

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

func (x *LabelSet) GetLabels() []*LabelPair {
	if x != nil {
		return x.Labels
	}
	return nil
}

// Alert represents a snapshot of an alert at the time the event was
// recorded.
type Alert struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The unique fingerprint derived from the alert's label set.
	Fingerprint uint64 `protobuf:"varint,1,opt,name=fingerprint,proto3" json:"fingerprint,omitempty"`
	// The value of the "alertname" label, provided for convenience.
	Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	// The full label set that identifies this alert.
	Labels *LabelSet `protobuf:"bytes,3,opt,name=labels,proto3" json:"labels,omitempty"`
	// Informational annotations attached to the alert (e.g., summary,
	// description).
	Annotations *LabelSet `protobuf:"bytes,4,opt,name=annotations,proto3" json:"annotations,omitempty"`
	// The time at which the alert started firing.
	StartsAt *timestamppb.Timestamp `protobuf:"bytes,5,opt,name=starts_at,json=startsAt,proto3" json:"starts_at,omitempty"`
	// The time at which the alert is considered resolved.  For firing
	// alerts this is typically set to a time in the future.
	EndsAt *timestamppb.Timestamp `protobuf:"bytes,6,opt,name=ends_at,json=endsAt,proto3" json:"ends_at,omitempty"`
	// Whether the alert was resolved at the time the event was recorded.
	Resolved      bool `protobuf:"varint,7,opt,name=resolved,proto3" json:"resolved,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Alert) ProtoMessage() {}

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

func (x *Alert) GetFingerprint() uint64 {
	if x != nil {
		return x.Fingerprint
	}
	return 0
}

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

func (x *Alert) GetLabels() *LabelSet {
	if x != nil {
		return x.Labels
	}
	return nil
}

func (x *Alert) GetAnnotations() *LabelSet {
	if x != nil {
		return x.Annotations
	}
	return nil
}

func (x *Alert) GetStartsAt() *timestamppb.Timestamp {
	if x != nil {
		return x.StartsAt
	}
	return nil
}

func (x *Alert) GetEndsAt() *timestamppb.Timestamp {
	if x != nil {
		return x.EndsAt
	}
	return nil
}

func (x *Alert) GetResolved() bool {
	if x != nil {
		return x.Resolved
	}
	return false
}

// GroupedAlert is a reference to an alert within an aggregation group.
// It always carries the content hash; the full alert details are
// included when available.
type GroupedAlert struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// A hash of the alert's label set, used for deduplication within the
	// notification pipeline.
	Hash uint64 `protobuf:"varint,1,opt,name=hash,proto3" json:"hash,omitempty"`
	// The full alert details.  May be absent when only the hash is needed
	// (e.g., in firing/resolved lists on NotificationEvent).
	Details       *Alert `protobuf:"bytes,2,opt,name=details,proto3,oneof" json:"details,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*GroupedAlert) ProtoMessage() {}

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

func (x *GroupedAlert) GetHash() uint64 {
	if x != nil {
		return x.Hash
	}
	return 0
}

func (x *GroupedAlert) GetDetails() *Alert {
	if x != nil {
		return x.Details
	}
	return nil
}

// AlertGroupInfo describes the aggregation group context in which an
// alert is being processed.
type AlertGroupInfo struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The composite key that uniquely identifies this aggregation group
	// (encodes route and group label values).
	GroupKey string `protobuf:"bytes,1,opt,name=group_key,json=groupKey,proto3" json:"group_key,omitempty"`
	// The label set used to group alerts together within this route.
	GroupLabels *LabelSet `protobuf:"bytes,2,opt,name=group_labels,json=groupLabels,proto3" json:"group_labels,omitempty"`
	// A stable, shortened identifier derived from the group key (SHA-256
	// hex).
	GroupId string `protobuf:"bytes,3,opt,name=group_id,json=groupId,proto3" json:"group_id,omitempty"`
	// The name of the receiver that this group routes to.
	ReceiverName string `protobuf:"bytes,4,opt,name=receiver_name,json=receiverName,proto3" json:"receiver_name,omitempty"`
	// The set of matchers defined on the route that matched these alerts.
	Matchers []*Matcher `protobuf:"bytes,5,rep,name=matchers,proto3" json:"matchers,omitempty"`
	// A UUID that uniquely identifies this aggregation group instance.
	GroupUuid     string `protobuf:"bytes,6,opt,name=group_uuid,json=groupUuid,proto3" json:"group_uuid,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*AlertGroupInfo) ProtoMessage() {}

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

func (x *AlertGroupInfo) GetGroupKey() string {
	if x != nil {
		return x.GroupKey
	}
	return ""
}

func (x *AlertGroupInfo) GetGroupLabels() *LabelSet {
	if x != nil {
		return x.GroupLabels
	}
	return nil
}

func (x *AlertGroupInfo) GetGroupId() string {
	if x != nil {
		return x.GroupId
	}
	return ""
}

func (x *AlertGroupInfo) GetReceiverName() string {
	if x != nil {
		return x.ReceiverName
	}
	return ""
}

func (x *AlertGroupInfo) GetMatchers() []*Matcher {
	if x != nil {
		return x.Matchers
	}
	return nil
}

func (x *AlertGroupInfo) GetGroupUuid() string {
	if x != nil {
		return x.GroupUuid
	}
	return ""
}

// AlertCreatedEvent is emitted when a brand-new alert is inserted into
// the in-memory alert store.
type AlertCreatedEvent struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The newly created alert.
	Alert         *Alert `protobuf:"bytes,1,opt,name=alert,proto3" json:"alert,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*AlertCreatedEvent) ProtoMessage() {}

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

func (x *AlertCreatedEvent) GetAlert() *Alert {
	if x != nil {
		return x.Alert
	}
	return nil
}

// AlertResolvedEvent is emitted when an alert is removed from its
// aggregation group after a successful notification that included the
// resolution.
type AlertResolvedEvent struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The resolved alert, including its hash and full details.
	Alert *GroupedAlert `protobuf:"bytes,1,opt,name=alert,proto3" json:"alert,omitempty"`
	// The aggregation group from which the alert was resolved.
	GroupInfo     *AlertGroupInfo `protobuf:"bytes,2,opt,name=group_info,json=groupInfo,proto3" json:"group_info,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*AlertResolvedEvent) ProtoMessage() {}

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

func (x *AlertResolvedEvent) GetAlert() *GroupedAlert {
	if x != nil {
		return x.Alert
	}
	return nil
}

func (x *AlertResolvedEvent) GetGroupInfo() *AlertGroupInfo {
	if x != nil {
		return x.GroupInfo
	}
	return nil
}

// AlertGroupedEvent is emitted the first time an alert is inserted into
// an aggregation group.
type AlertGroupedEvent struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The alert being grouped, including its hash and full details.
	Alert *GroupedAlert `protobuf:"bytes,1,opt,name=alert,proto3" json:"alert,omitempty"`
	// The aggregation group the alert was added to.
	GroupInfo     *AlertGroupInfo `protobuf:"bytes,2,opt,name=group_info,json=groupInfo,proto3" json:"group_info,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*AlertGroupedEvent) ProtoMessage() {}

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

func (x *AlertGroupedEvent) GetAlert() *GroupedAlert {
	if x != nil {
		return x.Alert
	}
	return nil
}

func (x *AlertGroupedEvent) GetGroupInfo() *AlertGroupInfo {
	if x != nil {
		return x.GroupInfo
	}
	return nil
}

// Integration identifies a specific notification integration (e.g.,
// the second PagerDuty receiver in a receiver definition).
type Integration struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The type of the integration (e.g., "webhook", "pagerduty").
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// The zero-based index of this integration within its receiver.
	Index         int64 `protobuf:"varint,2,opt,name=index,proto3" json:"index,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Integration) ProtoMessage() {}

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

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

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

// NotificationEvent is emitted after a notification is successfully
// delivered to an integration.
type NotificationEvent struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// All alerts that were included in the notification.
	Alerts []*GroupedAlert `protobuf:"bytes,1,rep,name=alerts,proto3" json:"alerts,omitempty"`
	// The subset of alerts that are currently firing.
	FiringAlerts []*GroupedAlert `protobuf:"bytes,2,rep,name=firing_alerts,json=firingAlerts,proto3" json:"firing_alerts,omitempty"`
	// The subset of alerts that are resolved.
	ResolvedAlerts []*GroupedAlert `protobuf:"bytes,3,rep,name=resolved_alerts,json=resolvedAlerts,proto3" json:"resolved_alerts,omitempty"`
	// Alerts that were muted (silenced or inhibited) during this flush
	// cycle.
	MutedAlerts []*GroupedAlert `protobuf:"bytes,4,rep,name=muted_alerts,json=mutedAlerts,proto3" json:"muted_alerts,omitempty"`
	// The aggregation group context for this notification.
	GroupInfo *AlertGroupInfo `protobuf:"bytes,5,opt,name=group_info,json=groupInfo,proto3" json:"group_info,omitempty"`
	// The configured repeat interval for the aggregation group's route.
	RepeatInterval *durationpb.Duration `protobuf:"bytes,6,opt,name=repeat_interval,json=repeatInterval,proto3" json:"repeat_interval,omitempty"`
	// The reason the notification was triggered.
	Reason NotifyReason `protobuf:"varint,7,opt,name=reason,proto3,enum=eventrecorderpb.NotifyReason" json:"reason,omitempty"`
	// A monotonically increasing identifier for each flush cycle of the
	// aggregation group.
	FlushId uint64 `protobuf:"varint,8,opt,name=flush_id,json=flushId,proto3" json:"flush_id,omitempty"`
	// The integration that delivered the notification.
	Integration   *Integration `protobuf:"bytes,9,opt,name=integration,proto3" json:"integration,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*NotificationEvent) ProtoMessage() {}

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

func (x *NotificationEvent) GetAlerts() []*GroupedAlert {
	if x != nil {
		return x.Alerts
	}
	return nil
}

func (x *NotificationEvent) GetFiringAlerts() []*GroupedAlert {
	if x != nil {
		return x.FiringAlerts
	}
	return nil
}

func (x *NotificationEvent) GetResolvedAlerts() []*GroupedAlert {
	if x != nil {
		return x.ResolvedAlerts
	}
	return nil
}

func (x *NotificationEvent) GetMutedAlerts() []*GroupedAlert {
	if x != nil {
		return x.MutedAlerts
	}
	return nil
}

func (x *NotificationEvent) GetGroupInfo() *AlertGroupInfo {
	if x != nil {
		return x.GroupInfo
	}
	return nil
}

func (x *NotificationEvent) GetRepeatInterval() *durationpb.Duration {
	if x != nil {
		return x.RepeatInterval
	}
	return nil
}

func (x *NotificationEvent) GetReason() NotifyReason {
	if x != nil {
		return x.Reason
	}
	return NotifyReason_NOTIFY_REASON_UNSPECIFIED
}

func (x *NotificationEvent) GetFlushId() uint64 {
	if x != nil {
		return x.FlushId
	}
	return 0
}

func (x *NotificationEvent) GetIntegration() *Integration {
	if x != nil {
		return x.Integration
	}
	return nil
}

// Silence is a snapshot of a silence definition at the time the event
// was recorded.
type Silence struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The globally unique silence identifier (UUID).
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// The matchers that define which alerts this silence suppresses.
	// For silences with multiple matcher sets, this is the first set.
	Matchers []*Matcher `protobuf:"bytes,2,rep,name=matchers,proto3" json:"matchers,omitempty"`
	// Optional structured annotations on the silence (key-value pairs).
	Annotations *LabelSet `protobuf:"bytes,3,opt,name=annotations,proto3" json:"annotations,omitempty"`
	// The time at which the silence becomes active.
	StartsAt *timestamppb.Timestamp `protobuf:"bytes,4,opt,name=starts_at,json=startsAt,proto3" json:"starts_at,omitempty"`
	// The time at which the silence expires.
	EndsAt *timestamppb.Timestamp `protobuf:"bytes,5,opt,name=ends_at,json=endsAt,proto3" json:"ends_at,omitempty"`
	// The last time the silence was created or updated.
	UpdatedAt *timestamppb.Timestamp `protobuf:"bytes,6,opt,name=updated_at,json=updatedAt,proto3" json:"updated_at,omitempty"`
	// The author who created the silence.
	CreatedBy string `protobuf:"bytes,7,opt,name=created_by,json=createdBy,proto3" json:"created_by,omitempty"`
	// A human-readable comment explaining the silence.
	Comment string `protobuf:"bytes,8,opt,name=comment,proto3" json:"comment,omitempty"`
	// Additional matcher sets evaluated with OR logic.  At least one
	// matcher set must match for the silence to apply.
	MatcherSets   []*MatcherSet `protobuf:"bytes,9,rep,name=matcher_sets,json=matcherSets,proto3" json:"matcher_sets,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Silence) ProtoMessage() {}

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

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

func (x *Silence) GetMatchers() []*Matcher {
	if x != nil {
		return x.Matchers
	}
	return nil
}

func (x *Silence) GetAnnotations() *LabelSet {
	if x != nil {
		return x.Annotations
	}
	return nil
}

func (x *Silence) GetStartsAt() *timestamppb.Timestamp {
	if x != nil {
		return x.StartsAt
	}
	return nil
}

func (x *Silence) GetEndsAt() *timestamppb.Timestamp {
	if x != nil {
		return x.EndsAt
	}
	return nil
}

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

func (x *Silence) GetCreatedBy() string {
	if x != nil {
		return x.CreatedBy
	}
	return ""
}

func (x *Silence) GetComment() string {
	if x != nil {
		return x.Comment
	}
	return ""
}

func (x *Silence) GetMatcherSets() []*MatcherSet {
	if x != nil {
		return x.MatcherSets
	}
	return nil
}

// Matcher defines a single label matching rule.
type Matcher struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The matching operator to apply.
	Type Matcher_Type `protobuf:"varint,1,opt,name=type,proto3,enum=eventrecorderpb.Matcher_Type" json:"type,omitempty"`
	// The label name to match against.
	Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	// The value or pattern to match, interpreted according to type.
	Pattern string `protobuf:"bytes,3,opt,name=pattern,proto3" json:"pattern,omitempty"`
	// Human-readable string representation (e.g., "env=~prod.*").
	Rendered      string `protobuf:"bytes,4,opt,name=rendered,proto3" json:"rendered,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Matcher) ProtoMessage() {}

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

func (x *Matcher) GetType() Matcher_Type {
	if x != nil {
		return x.Type
	}
	return Matcher_TYPE_UNSPECIFIED
}

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

func (x *Matcher) GetPattern() string {
	if x != nil {
		return x.Pattern
	}
	return ""
}

func (x *Matcher) GetRendered() string {
	if x != nil {
		return x.Rendered
	}
	return ""
}

// MatcherSet is a conjunction of matchers: all matchers in the set must
// match for the set to match.
type MatcherSet struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The matchers that make up this set (evaluated with AND logic).
	Matchers      []*Matcher `protobuf:"bytes,1,rep,name=matchers,proto3" json:"matchers,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*MatcherSet) ProtoMessage() {}

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

func (x *MatcherSet) GetMatchers() []*Matcher {
	if x != nil {
		return x.Matchers
	}
	return nil
}

// SilenceCreatedEvent is emitted when a new silence is created.
type SilenceCreatedEvent struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The newly created silence.
	Silence       *Silence `protobuf:"bytes,1,opt,name=silence,proto3" json:"silence,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*SilenceCreatedEvent) ProtoMessage() {}

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

func (x *SilenceCreatedEvent) GetSilence() *Silence {
	if x != nil {
		return x.Silence
	}
	return nil
}

// SilenceUpdatedEvent is emitted when an existing silence is modified.
type SilenceUpdatedEvent struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The silence after the update.
	Silence       *Silence `protobuf:"bytes,1,opt,name=silence,proto3" json:"silence,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SilenceUpdatedEvent) Reset() {
	*x = SilenceUpdatedEvent{}
	mi := &file_eventrecorder_proto_msgTypes[18]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*SilenceUpdatedEvent) ProtoMessage() {}

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

func (x *SilenceUpdatedEvent) GetSilence() *Silence {
	if x != nil {
		return x.Silence
	}
	return nil
}

// MutedAlert identifies an alert that was suppressed by a silence or
// inhibition rule.
type MutedAlert struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The label set of the muted alert.
	Labels *LabelSet `protobuf:"bytes,1,opt,name=labels,proto3" json:"labels,omitempty"`
	// The fingerprint of the muted alert.
	Fingerprint   uint64 `protobuf:"varint,2,opt,name=fingerprint,proto3" json:"fingerprint,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *MutedAlert) Reset() {
	*x = MutedAlert{}
	mi := &file_eventrecorder_proto_msgTypes[19]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*MutedAlert) ProtoMessage() {}

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

func (x *MutedAlert) GetLabels() *LabelSet {
	if x != nil {
		return x.Labels
	}
	return nil
}

func (x *MutedAlert) GetFingerprint() uint64 {
	if x != nil {
		return x.Fingerprint
	}
	return 0
}

// SilenceMutedAlertEvent is emitted each time a silence suppresses an
// alert during the muting evaluation pass.
type SilenceMutedAlertEvent struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The silence that suppressed the alert.
	Silence *Silence `protobuf:"bytes,1,opt,name=silence,proto3" json:"silence,omitempty"`
	// The alert that was suppressed.
	MutedAlert    *MutedAlert `protobuf:"bytes,2,opt,name=muted_alert,json=mutedAlert,proto3" json:"muted_alert,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SilenceMutedAlertEvent) Reset() {
	*x = SilenceMutedAlertEvent{}
	mi := &file_eventrecorder_proto_msgTypes[20]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*SilenceMutedAlertEvent) ProtoMessage() {}

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

func (x *SilenceMutedAlertEvent) GetSilence() *Silence {
	if x != nil {
		return x.Silence
	}
	return nil
}

func (x *SilenceMutedAlertEvent) GetMutedAlert() *MutedAlert {
	if x != nil {
		return x.MutedAlert
	}
	return nil
}

// InhibitRule is a snapshot of an inhibition rule definition.
type InhibitRule struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Matchers that identify source alerts (those that do the inhibiting).
	SourceMatchers []*Matcher `protobuf:"bytes,1,rep,name=source_matchers,json=sourceMatchers,proto3" json:"source_matchers,omitempty"`
	// Matchers that identify target alerts (those that get inhibited).
	TargetMatchers []*Matcher `protobuf:"bytes,2,rep,name=target_matchers,json=targetMatchers,proto3" json:"target_matchers,omitempty"`
	// Label names whose values must be equal between source and target
	// alerts for the inhibition to take effect.
	EqualLabels   []string `protobuf:"bytes,3,rep,name=equal_labels,json=equalLabels,proto3" json:"equal_labels,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *InhibitRule) Reset() {
	*x = InhibitRule{}
	mi := &file_eventrecorder_proto_msgTypes[21]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*InhibitRule) ProtoMessage() {}

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

func (x *InhibitRule) GetSourceMatchers() []*Matcher {
	if x != nil {
		return x.SourceMatchers
	}
	return nil
}

func (x *InhibitRule) GetTargetMatchers() []*Matcher {
	if x != nil {
		return x.TargetMatchers
	}
	return nil
}

func (x *InhibitRule) GetEqualLabels() []string {
	if x != nil {
		return x.EqualLabels
	}
	return nil
}

// InhibitionMutedAlertEvent is emitted when one or more inhibition
// rules suppress an alert.
type InhibitionMutedAlertEvent struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The inhibition rules that matched.
	InhibitRules []*InhibitRule `protobuf:"bytes,1,rep,name=inhibit_rules,json=inhibitRules,proto3" json:"inhibit_rules,omitempty"`
	// The alert that was suppressed.
	MutedAlert *MutedAlert `protobuf:"bytes,2,opt,name=muted_alert,json=mutedAlert,proto3" json:"muted_alert,omitempty"`
	// The fingerprints of the source alerts that caused the inhibition.
	InhibitingFingerprints []uint64 `protobuf:"varint,3,rep,packed,name=inhibiting_fingerprints,json=inhibitingFingerprints,proto3" json:"inhibiting_fingerprints,omitempty"`
	unknownFields          protoimpl.UnknownFields
	sizeCache              protoimpl.SizeCache
}

func (x *InhibitionMutedAlertEvent) Reset() {
	*x = InhibitionMutedAlertEvent{}
	mi := &file_eventrecorder_proto_msgTypes[22]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*InhibitionMutedAlertEvent) ProtoMessage() {}

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

func (x *InhibitionMutedAlertEvent) GetInhibitRules() []*InhibitRule {
	if x != nil {
		return x.InhibitRules
	}
	return nil
}

func (x *InhibitionMutedAlertEvent) GetMutedAlert() *MutedAlert {
	if x != nil {
		return x.MutedAlert
	}
	return nil
}

func (x *InhibitionMutedAlertEvent) GetInhibitingFingerprints() []uint64 {
	if x != nil {
		return x.InhibitingFingerprints
	}
	return nil
}

var File_eventrecorder_proto protoreflect.FileDescriptor

const file_eventrecorder_proto_rawDesc = "" +
	"\n" +
	"\x13eventrecorder.proto\x12\x0feventrecorderpb\x1a\x1egoogle/protobuf/duration.proto\x1a\x1fgoogle/protobuf/timestamp.proto\"\xb9\x01\n" +
	"\x05Event\x129\n" +
	"\ttimestamp\x18\x01 \x01(\v2\x1a.google.protobuf.TimestampR\n" +
	"@timestamp\x12\x1a\n" +
	"\binstance\x18\x02 \x01(\tR\binstance\x12.\n" +
	"\x04data\x18\x03 \x01(\v2\x1a.eventrecorderpb.EventDataR\x04data\x12)\n" +
	"\x10cluster_position\x18\x04 \x01(\rR\x0fclusterPosition\"\x81\a\n" +
	"\tEventData\x12i\n" +
	"\x1aalertmanager_startup_event\x18\x01 \x01(\v2).eventrecorderpb.AlertmanagerStartupEventH\x00R\x18alertmanagerStartupEvent\x12l\n" +
	"\x1balertmanager_shutdown_event\x18\x02 \x01(\v2*.eventrecorderpb.AlertmanagerShutdownEventH\x00R\x19alertmanagerShutdownEvent\x12I\n" +
	"\ralert_created\x18\x03 \x01(\v2\".eventrecorderpb.AlertCreatedEventH\x00R\falertCreated\x12L\n" +
	"\x0ealert_resolved\x18\x04 \x01(\v2#.eventrecorderpb.AlertResolvedEventH\x00R\ralertResolved\x12I\n" +
	"\ralert_grouped\x18\x05 \x01(\v2\".eventrecorderpb.AlertGroupedEventH\x00R\falertGrouped\x12H\n" +
	"\fnotification\x18\x06 \x01(\v2\".eventrecorderpb.NotificationEventH\x00R\fnotification\x12O\n" +
	"\x0fsilence_created\x18\a \x01(\v2$.eventrecorderpb.SilenceCreatedEventH\x00R\x0esilenceCreated\x12O\n" +
	"\x0fsilence_updated\x18\b \x01(\v2$.eventrecorderpb.SilenceUpdatedEventH\x00R\x0esilenceUpdated\x12Y\n" +
	"\x13silence_muted_alert\x18\t \x01(\v2'.eventrecorderpb.SilenceMutedAlertEventH\x00R\x11silenceMutedAlert\x12b\n" +
	"\x16inhibition_muted_alert\x18\n" +
	" \x01(\v2*.eventrecorderpb.InhibitionMutedAlertEventH\x00R\x14inhibitionMutedAlertB\f\n" +
	"\n" +
	"event_type\"Y\n" +
	"\x18AlertmanagerStartupEvent\x12\x18\n" +
	"\aversion\x18\x01 \x01(\tR\aversion\x12#\n" +
	"\rbuild_context\x18\x02 \x01(\tR\fbuildContext\"\x1b\n" +
	"\x19AlertmanagerShutdownEvent\"3\n" +
	"\tLabelPair\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\tR\x05value\">\n" +
	"\bLabelSet\x122\n" +
	"\x06labels\x18\x01 \x03(\v2\x1a.eventrecorderpb.LabelPairR\x06labels\"\xb7\x02\n" +
	"\x05Alert\x12 \n" +
	"\vfingerprint\x18\x01 \x01(\x04R\vfingerprint\x12\x12\n" +
	"\x04name\x18\x02 \x01(\tR\x04name\x121\n" +
	"\x06labels\x18\x03 \x01(\v2\x19.eventrecorderpb.LabelSetR\x06labels\x12;\n" +
	"\vannotations\x18\x04 \x01(\v2\x19.eventrecorderpb.LabelSetR\vannotations\x127\n" +
	"\tstarts_at\x18\x05 \x01(\v2\x1a.google.protobuf.TimestampR\bstartsAt\x123\n" +
	"\aends_at\x18\x06 \x01(\v2\x1a.google.protobuf.TimestampR\x06endsAt\x12\x1a\n" +
	"\bresolved\x18\a \x01(\bR\bresolved\"e\n" +
	"\fGroupedAlert\x12\x12\n" +
	"\x04hash\x18\x01 \x01(\x04R\x04hash\x125\n" +
	"\adetails\x18\x02 \x01(\v2\x16.eventrecorderpb.AlertH\x00R\adetails\x88\x01\x01B\n" +
	"\n" +
	"\b_details\"\x80\x02\n" +
	"\x0eAlertGroupInfo\x12\x1b\n" +
	"\tgroup_key\x18\x01 \x01(\tR\bgroupKey\x12<\n" +
	"\fgroup_labels\x18\x02 \x01(\v2\x19.eventrecorderpb.LabelSetR\vgroupLabels\x12\x19\n" +
	"\bgroup_id\x18\x03 \x01(\tR\agroupId\x12#\n" +
	"\rreceiver_name\x18\x04 \x01(\tR\freceiverName\x124\n" +
	"\bmatchers\x18\x05 \x03(\v2\x18.eventrecorderpb.MatcherR\bmatchers\x12\x1d\n" +
	"\n" +
	"group_uuid\x18\x06 \x01(\tR\tgroupUuid\"A\n" +
	"\x11AlertCreatedEvent\x12,\n" +
	"\x05alert\x18\x01 \x01(\v2\x16.eventrecorderpb.AlertR\x05alert\"\x89\x01\n" +
	"\x12AlertResolvedEvent\x123\n" +
	"\x05alert\x18\x01 \x01(\v2\x1d.eventrecorderpb.GroupedAlertR\x05alert\x12>\n" +
	"\n" +
	"group_info\x18\x02 \x01(\v2\x1f.eventrecorderpb.AlertGroupInfoR\tgroupInfo\"\x88\x01\n" +
	"\x11AlertGroupedEvent\x123\n" +
	"\x05alert\x18\x01 \x01(\v2\x1d.eventrecorderpb.GroupedAlertR\x05alert\x12>\n" +
	"\n" +
	"group_info\x18\x02 \x01(\v2\x1f.eventrecorderpb.AlertGroupInfoR\tgroupInfo\"7\n" +
	"\vIntegration\x12\x12\n" +
	"\x04name\x18\x01 \x01(\tR\x04name\x12\x14\n" +
	"\x05index\x18\x02 \x01(\x03R\x05index\"\xae\x04\n" +
	"\x11NotificationEvent\x125\n" +
	"\x06alerts\x18\x01 \x03(\v2\x1d.eventrecorderpb.GroupedAlertR\x06alerts\x12B\n" +
	"\rfiring_alerts\x18\x02 \x03(\v2\x1d.eventrecorderpb.GroupedAlertR\ffiringAlerts\x12F\n" +
	"\x0fresolved_alerts\x18\x03 \x03(\v2\x1d.eventrecorderpb.GroupedAlertR\x0eresolvedAlerts\x12@\n" +
	"\fmuted_alerts\x18\x04 \x03(\v2\x1d.eventrecorderpb.GroupedAlertR\vmutedAlerts\x12>\n" +
	"\n" +
	"group_info\x18\x05 \x01(\v2\x1f.eventrecorderpb.AlertGroupInfoR\tgroupInfo\x12B\n" +
	"\x0frepeat_interval\x18\x06 \x01(\v2\x19.google.protobuf.DurationR\x0erepeatInterval\x125\n" +
	"\x06reason\x18\a \x01(\x0e2\x1d.eventrecorderpb.NotifyReasonR\x06reason\x12\x19\n" +
	"\bflush_id\x18\b \x01(\x04R\aflushId\x12>\n" +
	"\vintegration\x18\t \x01(\v2\x1c.eventrecorderpb.IntegrationR\vintegration\"\xae\x03\n" +
	"\aSilence\x12\x0e\n" +
	"\x02id\x18\x01 \x01(\tR\x02id\x124\n" +
	"\bmatchers\x18\x02 \x03(\v2\x18.eventrecorderpb.MatcherR\bmatchers\x12;\n" +
	"\vannotations\x18\x03 \x01(\v2\x19.eventrecorderpb.LabelSetR\vannotations\x127\n" +
	"\tstarts_at\x18\x04 \x01(\v2\x1a.google.protobuf.TimestampR\bstartsAt\x123\n" +
	"\aends_at\x18\x05 \x01(\v2\x1a.google.protobuf.TimestampR\x06endsAt\x129\n" +
	"\n" +
	"updated_at\x18\x06 \x01(\v2\x1a.google.protobuf.TimestampR\tupdatedAt\x12\x1d\n" +
	"\n" +
	"created_by\x18\a \x01(\tR\tcreatedBy\x12\x18\n" +
	"\acomment\x18\b \x01(\tR\acomment\x12>\n" +
	"\fmatcher_sets\x18\t \x03(\v2\x1b.eventrecorderpb.MatcherSetR\vmatcherSets\"\xee\x01\n" +
	"\aMatcher\x121\n" +
	"\x04type\x18\x01 \x01(\x0e2\x1d.eventrecorderpb.Matcher.TypeR\x04type\x12\x12\n" +
	"\x04name\x18\x02 \x01(\tR\x04name\x12\x18\n" +
	"\apattern\x18\x03 \x01(\tR\apattern\x12\x1a\n" +
	"\brendered\x18\x04 \x01(\tR\brendered\"f\n" +
	"\x04Type\x12\x14\n" +
	"\x10TYPE_UNSPECIFIED\x10\x00\x12\x0e\n" +
	"\n" +
	"TYPE_EQUAL\x10\x01\x12\x0f\n" +
	"\vTYPE_REGEXP\x10\x02\x12\x12\n" +
	"\x0eTYPE_NOT_EQUAL\x10\x03\x12\x13\n" +
	"\x0fTYPE_NOT_REGEXP\x10\x04\"B\n" +
	"\n" +
	"MatcherSet\x124\n" +
	"\bmatchers\x18\x01 \x03(\v2\x18.eventrecorderpb.MatcherR\bmatchers\"I\n" +
	"\x13SilenceCreatedEvent\x122\n" +
	"\asilence\x18\x01 \x01(\v2\x18.eventrecorderpb.SilenceR\asilence\"I\n" +
	"\x13SilenceUpdatedEvent\x122\n" +
	"\asilence\x18\x01 \x01(\v2\x18.eventrecorderpb.SilenceR\asilence\"a\n" +
	"\n" +
	"MutedAlert\x121\n" +
	"\x06labels\x18\x01 \x01(\v2\x19.eventrecorderpb.LabelSetR\x06labels\x12 \n" +
	"\vfingerprint\x18\x02 \x01(\x04R\vfingerprint\"\x8a\x01\n" +
	"\x16SilenceMutedAlertEvent\x122\n" +
	"\asilence\x18\x01 \x01(\v2\x18.eventrecorderpb.SilenceR\asilence\x12<\n" +
	"\vmuted_alert\x18\x02 \x01(\v2\x1b.eventrecorderpb.MutedAlertR\n" +
	"mutedAlert\"\xb6\x01\n" +
	"\vInhibitRule\x12A\n" +
	"\x0fsource_matchers\x18\x01 \x03(\v2\x18.eventrecorderpb.MatcherR\x0esourceMatchers\x12A\n" +
	"\x0ftarget_matchers\x18\x02 \x03(\v2\x18.eventrecorderpb.MatcherR\x0etargetMatchers\x12!\n" +
	"\fequal_labels\x18\x03 \x03(\tR\vequalLabels\"\xd5\x01\n" +
	"\x19InhibitionMutedAlertEvent\x12A\n" +
	"\rinhibit_rules\x18\x01 \x03(\v2\x1c.eventrecorderpb.InhibitRuleR\finhibitRules\x12<\n" +
	"\vmuted_alert\x18\x02 \x01(\v2\x1b.eventrecorderpb.MutedAlertR\n" +
	"mutedAlert\x127\n" +
	"\x17inhibiting_fingerprints\x18\x03 \x03(\x04R\x16inhibitingFingerprints*\xf3\x01\n" +
	"\fNotifyReason\x12\x1d\n" +
	"\x19NOTIFY_REASON_UNSPECIFIED\x10\x00\x12$\n" +
	" NOTIFY_REASON_FIRST_NOTIFICATION\x10\x01\x12%\n" +
	"!NOTIFY_REASON_NEW_ALERTS_IN_GROUP\x10\x02\x12%\n" +
	"!NOTIFY_REASON_NEW_RESOLVED_ALERTS\x10\x03\x12%\n" +
	"!NOTIFY_REASON_ALL_ALERTS_RESOLVED\x10\x04\x12)\n" +
	"%NOTIFY_REASON_REPEAT_INTERVAL_ELAPSED\x10\x05BBZ@github.com/prometheus/alertmanager/eventrecorder/eventrecorderpbb\x06proto3"

var (
	file_eventrecorder_proto_rawDescOnce sync.Once
	file_eventrecorder_proto_rawDescData []byte
)

func file_eventrecorder_proto_rawDescGZIP() []byte {
	file_eventrecorder_proto_rawDescOnce.Do(func() {
		file_eventrecorder_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_eventrecorder_proto_rawDesc), len(file_eventrecorder_proto_rawDesc)))
	})
	return file_eventrecorder_proto_rawDescData
}

var file_eventrecorder_proto_enumTypes = make([]protoimpl.EnumInfo, 2)
var file_eventrecorder_proto_msgTypes = make([]protoimpl.MessageInfo, 23)
var file_eventrecorder_proto_goTypes = []any{
	(NotifyReason)(0),                 // 0: eventrecorderpb.NotifyReason
	(Matcher_Type)(0),                 // 1: eventrecorderpb.Matcher.Type
	(*Event)(nil),                     // 2: eventrecorderpb.Event
	(*EventData)(nil),                 // 3: eventrecorderpb.EventData
	(*AlertmanagerStartupEvent)(nil),  // 4: eventrecorderpb.AlertmanagerStartupEvent
	(*AlertmanagerShutdownEvent)(nil), // 5: eventrecorderpb.AlertmanagerShutdownEvent
	(*LabelPair)(nil),                 // 6: eventrecorderpb.LabelPair
	(*LabelSet)(nil),                  // 7: eventrecorderpb.LabelSet
	(*Alert)(nil),                     // 8: eventrecorderpb.Alert
	(*GroupedAlert)(nil),              // 9: eventrecorderpb.GroupedAlert
	(*AlertGroupInfo)(nil),            // 10: eventrecorderpb.AlertGroupInfo
	(*AlertCreatedEvent)(nil),         // 11: eventrecorderpb.AlertCreatedEvent
	(*AlertResolvedEvent)(nil),        // 12: eventrecorderpb.AlertResolvedEvent
	(*AlertGroupedEvent)(nil),         // 13: eventrecorderpb.AlertGroupedEvent
	(*Integration)(nil),               // 14: eventrecorderpb.Integration
	(*NotificationEvent)(nil),         // 15: eventrecorderpb.NotificationEvent
	(*Silence)(nil),                   // 16: eventrecorderpb.Silence
	(*Matcher)(nil),                   // 17: eventrecorderpb.Matcher
	(*MatcherSet)(nil),                // 18: eventrecorderpb.MatcherSet
	(*SilenceCreatedEvent)(nil),       // 19: eventrecorderpb.SilenceCreatedEvent
	(*SilenceUpdatedEvent)(nil),       // 20: eventrecorderpb.SilenceUpdatedEvent
	(*MutedAlert)(nil),                // 21: eventrecorderpb.MutedAlert
	(*SilenceMutedAlertEvent)(nil),    // 22: eventrecorderpb.SilenceMutedAlertEvent
	(*InhibitRule)(nil),               // 23: eventrecorderpb.InhibitRule
	(*InhibitionMutedAlertEvent)(nil), // 24: eventrecorderpb.InhibitionMutedAlertEvent
	(*timestamppb.Timestamp)(nil),     // 25: google.protobuf.Timestamp
	(*durationpb.Duration)(nil),       // 26: google.protobuf.Duration
}
var file_eventrecorder_proto_depIdxs = []int32{
	25, // 0: eventrecorderpb.Event.timestamp:type_name -> google.protobuf.Timestamp
	3,  // 1: eventrecorderpb.Event.data:type_name -> eventrecorderpb.EventData
	4,  // 2: eventrecorderpb.EventData.alertmanager_startup_event:type_name -> eventrecorderpb.AlertmanagerStartupEvent
	5,  // 3: eventrecorderpb.EventData.alertmanager_shutdown_event:type_name -> eventrecorderpb.AlertmanagerShutdownEvent
	11, // 4: eventrecorderpb.EventData.alert_created:type_name -> eventrecorderpb.AlertCreatedEvent
	12, // 5: eventrecorderpb.EventData.alert_resolved:type_name -> eventrecorderpb.AlertResolvedEvent
	13, // 6: eventrecorderpb.EventData.alert_grouped:type_name -> eventrecorderpb.AlertGroupedEvent
	15, // 7: eventrecorderpb.EventData.notification:type_name -> eventrecorderpb.NotificationEvent
	19, // 8: eventrecorderpb.EventData.silence_created:type_name -> eventrecorderpb.SilenceCreatedEvent
	20, // 9: eventrecorderpb.EventData.silence_updated:type_name -> eventrecorderpb.SilenceUpdatedEvent
	22, // 10: eventrecorderpb.EventData.silence_muted_alert:type_name -> eventrecorderpb.SilenceMutedAlertEvent
	24, // 11: eventrecorderpb.EventData.inhibition_muted_alert:type_name -> eventrecorderpb.InhibitionMutedAlertEvent
	6,  // 12: eventrecorderpb.LabelSet.labels:type_name -> eventrecorderpb.LabelPair
	7,  // 13: eventrecorderpb.Alert.labels:type_name -> eventrecorderpb.LabelSet
	7,  // 14: eventrecorderpb.Alert.annotations:type_name -> eventrecorderpb.LabelSet
	25, // 15: eventrecorderpb.Alert.starts_at:type_name -> google.protobuf.Timestamp
	25, // 16: eventrecorderpb.Alert.ends_at:type_name -> google.protobuf.Timestamp
	8,  // 17: eventrecorderpb.GroupedAlert.details:type_name -> eventrecorderpb.Alert
	7,  // 18: eventrecorderpb.AlertGroupInfo.group_labels:type_name -> eventrecorderpb.LabelSet
	17, // 19: eventrecorderpb.AlertGroupInfo.matchers:type_name -> eventrecorderpb.Matcher
	8,  // 20: eventrecorderpb.AlertCreatedEvent.alert:type_name -> eventrecorderpb.Alert
	9,  // 21: eventrecorderpb.AlertResolvedEvent.alert:type_name -> eventrecorderpb.GroupedAlert
	10, // 22: eventrecorderpb.AlertResolvedEvent.group_info:type_name -> eventrecorderpb.AlertGroupInfo
	9,  // 23: eventrecorderpb.AlertGroupedEvent.alert:type_name -> eventrecorderpb.GroupedAlert
	10, // 24: eventrecorderpb.AlertGroupedEvent.group_info:type_name -> eventrecorderpb.AlertGroupInfo
	9,  // 25: eventrecorderpb.NotificationEvent.alerts:type_name -> eventrecorderpb.GroupedAlert
	9,  // 26: eventrecorderpb.NotificationEvent.firing_alerts:type_name -> eventrecorderpb.GroupedAlert
	9,  // 27: eventrecorderpb.NotificationEvent.resolved_alerts:type_name -> eventrecorderpb.GroupedAlert
	9,  // 28: eventrecorderpb.NotificationEvent.muted_alerts:type_name -> eventrecorderpb.GroupedAlert
	10, // 29: eventrecorderpb.NotificationEvent.group_info:type_name -> eventrecorderpb.AlertGroupInfo
	26, // 30: eventrecorderpb.NotificationEvent.repeat_interval:type_name -> google.protobuf.Duration
	0,  // 31: eventrecorderpb.NotificationEvent.reason:type_name -> eventrecorderpb.NotifyReason
	14, // 32: eventrecorderpb.NotificationEvent.integration:type_name -> eventrecorderpb.Integration
	17, // 33: eventrecorderpb.Silence.matchers:type_name -> eventrecorderpb.Matcher
	7,  // 34: eventrecorderpb.Silence.annotations:type_name -> eventrecorderpb.LabelSet
	25, // 35: eventrecorderpb.Silence.starts_at:type_name -> google.protobuf.Timestamp
	25, // 36: eventrecorderpb.Silence.ends_at:type_name -> google.protobuf.Timestamp
	25, // 37: eventrecorderpb.Silence.updated_at:type_name -> google.protobuf.Timestamp
	18, // 38: eventrecorderpb.Silence.matcher_sets:type_name -> eventrecorderpb.MatcherSet
	1,  // 39: eventrecorderpb.Matcher.type:type_name -> eventrecorderpb.Matcher.Type
	17, // 40: eventrecorderpb.MatcherSet.matchers:type_name -> eventrecorderpb.Matcher
	16, // 41: eventrecorderpb.SilenceCreatedEvent.silence:type_name -> eventrecorderpb.Silence
	16, // 42: eventrecorderpb.SilenceUpdatedEvent.silence:type_name -> eventrecorderpb.Silence
	7,  // 43: eventrecorderpb.MutedAlert.labels:type_name -> eventrecorderpb.LabelSet
	16, // 44: eventrecorderpb.SilenceMutedAlertEvent.silence:type_name -> eventrecorderpb.Silence
	21, // 45: eventrecorderpb.SilenceMutedAlertEvent.muted_alert:type_name -> eventrecorderpb.MutedAlert
	17, // 46: eventrecorderpb.InhibitRule.source_matchers:type_name -> eventrecorderpb.Matcher
	17, // 47: eventrecorderpb.InhibitRule.target_matchers:type_name -> eventrecorderpb.Matcher
	23, // 48: eventrecorderpb.InhibitionMutedAlertEvent.inhibit_rules:type_name -> eventrecorderpb.InhibitRule
	21, // 49: eventrecorderpb.InhibitionMutedAlertEvent.muted_alert:type_name -> eventrecorderpb.MutedAlert
	50, // [50:50] is the sub-list for method output_type
	50, // [50:50] is the sub-list for method input_type
	50, // [50:50] is the sub-list for extension type_name
	50, // [50:50] is the sub-list for extension extendee
	0,  // [0:50] is the sub-list for field type_name
}

func init() { file_eventrecorder_proto_init() }
func file_eventrecorder_proto_init() {
	if File_eventrecorder_proto != nil {
		return
	}
	file_eventrecorder_proto_msgTypes[1].OneofWrappers = []any{
		(*EventData_AlertmanagerStartupEvent)(nil),
		(*EventData_AlertmanagerShutdownEvent)(nil),
		(*EventData_AlertCreated)(nil),
		(*EventData_AlertResolved)(nil),
		(*EventData_AlertGrouped)(nil),
		(*EventData_Notification)(nil),
		(*EventData_SilenceCreated)(nil),
		(*EventData_SilenceUpdated)(nil),
		(*EventData_SilenceMutedAlert)(nil),
		(*EventData_InhibitionMutedAlert)(nil),
	}
	file_eventrecorder_proto_msgTypes[7].OneofWrappers = []any{}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_eventrecorder_proto_rawDesc), len(file_eventrecorder_proto_rawDesc)),
			NumEnums:      2,
			NumMessages:   23,
			NumExtensions: 0,
			NumServices:   0,
		},
		GoTypes:           file_eventrecorder_proto_goTypes,
		DependencyIndexes: file_eventrecorder_proto_depIdxs,
		EnumInfos:         file_eventrecorder_proto_enumTypes,
		MessageInfos:      file_eventrecorder_proto_msgTypes,
	}.Build()
	File_eventrecorder_proto = out.File
	file_eventrecorder_proto_goTypes = nil
	file_eventrecorder_proto_depIdxs = nil
}
