go/voltha/events.pb.go

// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.11
// 	protoc        v4.25.8
// source: voltha_protos/events.proto

package voltha

import (
	common "github.com/opencord/voltha-protos/v5/go/common"
	_ "google.golang.org/genproto/googleapis/api/annotations"
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	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)
)

type EventFilterRuleKey_EventFilterRuleType int32

const (
	EventFilterRuleKey_filter_all        EventFilterRuleKey_EventFilterRuleType = 0
	EventFilterRuleKey_category          EventFilterRuleKey_EventFilterRuleType = 1
	EventFilterRuleKey_sub_category      EventFilterRuleKey_EventFilterRuleType = 2
	EventFilterRuleKey_kpi_event_type    EventFilterRuleKey_EventFilterRuleType = 3
	EventFilterRuleKey_config_event_type EventFilterRuleKey_EventFilterRuleType = 4
	EventFilterRuleKey_device_event_type EventFilterRuleKey_EventFilterRuleType = 5
)

// Enum value maps for EventFilterRuleKey_EventFilterRuleType.
var (
	EventFilterRuleKey_EventFilterRuleType_name = map[int32]string{
		0: "filter_all",
		1: "category",
		2: "sub_category",
		3: "kpi_event_type",
		4: "config_event_type",
		5: "device_event_type",
	}
	EventFilterRuleKey_EventFilterRuleType_value = map[string]int32{
		"filter_all":        0,
		"category":          1,
		"sub_category":      2,
		"kpi_event_type":    3,
		"config_event_type": 4,
		"device_event_type": 5,
	}
)

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

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

func (EventFilterRuleKey_EventFilterRuleType) Descriptor() protoreflect.EnumDescriptor {
	return file_voltha_protos_events_proto_enumTypes[0].Descriptor()
}

func (EventFilterRuleKey_EventFilterRuleType) Type() protoreflect.EnumType {
	return &file_voltha_protos_events_proto_enumTypes[0]
}

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

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

type ConfigEventType_Types int32

const (
	ConfigEventType_add    ConfigEventType_Types = 0 // A new config has been added
	ConfigEventType_remove ConfigEventType_Types = 1 // A config has been removed
	ConfigEventType_update ConfigEventType_Types = 2 // A config has been updated
)

// Enum value maps for ConfigEventType_Types.
var (
	ConfigEventType_Types_name = map[int32]string{
		0: "add",
		1: "remove",
		2: "update",
	}
	ConfigEventType_Types_value = map[string]int32{
		"add":    0,
		"remove": 1,
		"update": 2,
	}
)

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

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

func (ConfigEventType_Types) Descriptor() protoreflect.EnumDescriptor {
	return file_voltha_protos_events_proto_enumTypes[1].Descriptor()
}

func (ConfigEventType_Types) Type() protoreflect.EnumType {
	return &file_voltha_protos_events_proto_enumTypes[1]
}

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

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

type KpiEventType_Types int32

const (
	KpiEventType_slice KpiEventType_Types = 0 // slice: a set of path/metric data for same time-stamp
	KpiEventType_ts    KpiEventType_Types = 1 // time-series: array of data for same metric
)

// Enum value maps for KpiEventType_Types.
var (
	KpiEventType_Types_name = map[int32]string{
		0: "slice",
		1: "ts",
	}
	KpiEventType_Types_value = map[string]int32{
		"slice": 0,
		"ts":    1,
	}
)

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

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

func (KpiEventType_Types) Descriptor() protoreflect.EnumDescriptor {
	return file_voltha_protos_events_proto_enumTypes[2].Descriptor()
}

func (KpiEventType_Types) Type() protoreflect.EnumType {
	return &file_voltha_protos_events_proto_enumTypes[2]
}

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

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

type EventCategory_Types int32

const (
	EventCategory_COMMUNICATION EventCategory_Types = 0
	EventCategory_ENVIRONMENT   EventCategory_Types = 1
	EventCategory_EQUIPMENT     EventCategory_Types = 2
	EventCategory_SERVICE       EventCategory_Types = 3
	EventCategory_PROCESSING    EventCategory_Types = 4
	EventCategory_SECURITY      EventCategory_Types = 5 // Add new event areas here
)

// Enum value maps for EventCategory_Types.
var (
	EventCategory_Types_name = map[int32]string{
		0: "COMMUNICATION",
		1: "ENVIRONMENT",
		2: "EQUIPMENT",
		3: "SERVICE",
		4: "PROCESSING",
		5: "SECURITY",
	}
	EventCategory_Types_value = map[string]int32{
		"COMMUNICATION": 0,
		"ENVIRONMENT":   1,
		"EQUIPMENT":     2,
		"SERVICE":       3,
		"PROCESSING":    4,
		"SECURITY":      5,
	}
)

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

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

func (EventCategory_Types) Descriptor() protoreflect.EnumDescriptor {
	return file_voltha_protos_events_proto_enumTypes[3].Descriptor()
}

func (EventCategory_Types) Type() protoreflect.EnumType {
	return &file_voltha_protos_events_proto_enumTypes[3]
}

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

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

type EventSubCategory_Types int32

const (
	EventSubCategory_PON  EventSubCategory_Types = 0
	EventSubCategory_OLT  EventSubCategory_Types = 1
	EventSubCategory_ONT  EventSubCategory_Types = 2
	EventSubCategory_ONU  EventSubCategory_Types = 3
	EventSubCategory_NNI  EventSubCategory_Types = 4
	EventSubCategory_NONE EventSubCategory_Types = 5 //Adding None for RPC Events
)

// Enum value maps for EventSubCategory_Types.
var (
	EventSubCategory_Types_name = map[int32]string{
		0: "PON",
		1: "OLT",
		2: "ONT",
		3: "ONU",
		4: "NNI",
		5: "NONE",
	}
	EventSubCategory_Types_value = map[string]int32{
		"PON":  0,
		"OLT":  1,
		"ONT":  2,
		"ONU":  3,
		"NNI":  4,
		"NONE": 5,
	}
)

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

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

func (EventSubCategory_Types) Descriptor() protoreflect.EnumDescriptor {
	return file_voltha_protos_events_proto_enumTypes[4].Descriptor()
}

func (EventSubCategory_Types) Type() protoreflect.EnumType {
	return &file_voltha_protos_events_proto_enumTypes[4]
}

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

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

type EventType_Types int32

const (
	EventType_CONFIG_EVENT EventType_Types = 0
	EventType_KPI_EVENT    EventType_Types = 1
	EventType_KPI_EVENT2   EventType_Types = 2
	EventType_DEVICE_EVENT EventType_Types = 3
	EventType_RPC_EVENT    EventType_Types = 4
	EventType_KPI_EVENT3   EventType_Types = 5
)

// Enum value maps for EventType_Types.
var (
	EventType_Types_name = map[int32]string{
		0: "CONFIG_EVENT",
		1: "KPI_EVENT",
		2: "KPI_EVENT2",
		3: "DEVICE_EVENT",
		4: "RPC_EVENT",
		5: "KPI_EVENT3",
	}
	EventType_Types_value = map[string]int32{
		"CONFIG_EVENT": 0,
		"KPI_EVENT":    1,
		"KPI_EVENT2":   2,
		"DEVICE_EVENT": 3,
		"RPC_EVENT":    4,
		"KPI_EVENT3":   5,
	}
)

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

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

func (EventType_Types) Descriptor() protoreflect.EnumDescriptor {
	return file_voltha_protos_events_proto_enumTypes[5].Descriptor()
}

func (EventType_Types) Type() protoreflect.EnumType {
	return &file_voltha_protos_events_proto_enumTypes[5]
}

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

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

type EventFilterRuleKey struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*EventFilterRuleKey) ProtoMessage() {}

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

type EventFilterRule struct {
	state         protoimpl.MessageState                 `protogen:"open.v1"`
	Key           EventFilterRuleKey_EventFilterRuleType `protobuf:"varint,1,opt,name=key,proto3,enum=event.EventFilterRuleKey_EventFilterRuleType" json:"key,omitempty"`
	Value         string                                 `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*EventFilterRule) ProtoMessage() {}

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

func (x *EventFilterRule) GetKey() EventFilterRuleKey_EventFilterRuleType {
	if x != nil {
		return x.Key
	}
	return EventFilterRuleKey_filter_all
}

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

type EventFilter struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Id            string                 `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Enable        bool                   `protobuf:"varint,2,opt,name=enable,proto3" json:"enable,omitempty"`
	DeviceId      string                 `protobuf:"bytes,3,opt,name=device_id,json=deviceId,proto3" json:"device_id,omitempty"`
	EventType     string                 `protobuf:"bytes,4,opt,name=event_type,json=eventType,proto3" json:"event_type,omitempty"`
	Rules         []*EventFilterRule     `protobuf:"bytes,5,rep,name=rules,proto3" json:"rules,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*EventFilter) ProtoMessage() {}

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

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

func (x *EventFilter) GetEnable() bool {
	if x != nil {
		return x.Enable
	}
	return false
}

func (x *EventFilter) GetDeviceId() string {
	if x != nil {
		return x.DeviceId
	}
	return ""
}

func (x *EventFilter) GetEventType() string {
	if x != nil {
		return x.EventType
	}
	return ""
}

func (x *EventFilter) GetRules() []*EventFilterRule {
	if x != nil {
		return x.Rules
	}
	return nil
}

type EventFilters struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Filters       []*EventFilter         `protobuf:"bytes,1,rep,name=filters,proto3" json:"filters,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*EventFilters) ProtoMessage() {}

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

func (x *EventFilters) GetFilters() []*EventFilter {
	if x != nil {
		return x.Filters
	}
	return nil
}

type ConfigEventType struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ConfigEventType) ProtoMessage() {}

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

type ConfigEvent struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Type          ConfigEventType_Types  `protobuf:"varint,1,opt,name=type,proto3,enum=event.ConfigEventType_Types" json:"type,omitempty"`
	Hash          string                 `protobuf:"bytes,2,opt,name=hash,proto3" json:"hash,omitempty"` // hash for this change, can be used for quick lookup
	Data          string                 `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"` // the actual new data, in json format
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ConfigEvent) ProtoMessage() {}

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

func (x *ConfigEvent) GetType() ConfigEventType_Types {
	if x != nil {
		return x.Type
	}
	return ConfigEventType_add
}

func (x *ConfigEvent) GetHash() string {
	if x != nil {
		return x.Hash
	}
	return ""
}

func (x *ConfigEvent) GetData() string {
	if x != nil {
		return x.Data
	}
	return ""
}

type KpiEventType struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*KpiEventType) ProtoMessage() {}

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

// Struct to convey a dictionary of metric metadata.
type MetricMetaData struct {
	state           protoimpl.MessageState `protogen:"open.v1"`
	Title           string                 `protobuf:"bytes,1,opt,name=title,proto3" json:"title,omitempty"`                                              // Metric group or individual metric name
	Ts              float64                `protobuf:"fixed64,2,opt,name=ts,proto3" json:"ts,omitempty"`                                                  // UTC time-stamp of data (seconds since epoch) of
	LogicalDeviceId string                 `protobuf:"bytes,3,opt,name=logical_device_id,json=logicalDeviceId,proto3" json:"logical_device_id,omitempty"` // The logical device ID of the VOLTHA
	// (equivalent to the DPID that ONOS has
	// for the VOLTHA device without the
	//
	//	'of:' prefix
	SerialNo      string            `protobuf:"bytes,4,opt,name=serial_no,json=serialNo,proto3" json:"serial_no,omitempty"`                                                         // The OLT, ONU, ... device serial number
	DeviceId      string            `protobuf:"bytes,5,opt,name=device_id,json=deviceId,proto3" json:"device_id,omitempty"`                                                         // The OLT, ONU, ... physical device ID
	Context       map[string]string `protobuf:"bytes,6,rep,name=context,proto3" json:"context,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` // Name value pairs that provide additional
	Uuid          string            `protobuf:"bytes,7,opt,name=uuid,proto3" json:"uuid,omitempty"`                                                                                 // Transaction identifier used to match On
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*MetricMetaData) ProtoMessage() {}

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

func (x *MetricMetaData) GetTitle() string {
	if x != nil {
		return x.Title
	}
	return ""
}

func (x *MetricMetaData) GetTs() float64 {
	if x != nil {
		return x.Ts
	}
	return 0
}

func (x *MetricMetaData) GetLogicalDeviceId() string {
	if x != nil {
		return x.LogicalDeviceId
	}
	return ""
}

func (x *MetricMetaData) GetSerialNo() string {
	if x != nil {
		return x.SerialNo
	}
	return ""
}

func (x *MetricMetaData) GetDeviceId() string {
	if x != nil {
		return x.DeviceId
	}
	return ""
}

func (x *MetricMetaData) GetContext() map[string]string {
	if x != nil {
		return x.Context
	}
	return nil
}

func (x *MetricMetaData) GetUuid() string {
	if x != nil {
		return x.Uuid
	}
	return ""
}

// Struct to convey a dictionary of metric->value pairs. Typically used in
// pure shared-timestamp or shared-timestamp + shared object prefix situations.
type MetricValuePairs struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Metric / value pairs.
	Metrics       map[string]float32 `protobuf:"bytes,1,rep,name=metrics,proto3" json:"metrics,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"fixed32,2,opt,name=value"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*MetricValuePairs) ProtoMessage() {}

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

func (x *MetricValuePairs) GetMetrics() map[string]float32 {
	if x != nil {
		return x.Metrics
	}
	return nil
}

// Struct to group metadata for a metric (or group of metrics) with the key-value
// pairs of collected metrics
type MetricInformation struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Metadata      *MetricMetaData        `protobuf:"bytes,1,opt,name=metadata,proto3" json:"metadata,omitempty"`
	Metrics       map[string]float32     `protobuf:"bytes,2,rep,name=metrics,proto3" json:"metrics,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"fixed32,2,opt,name=value"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*MetricInformation) ProtoMessage() {}

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

func (x *MetricInformation) GetMetadata() *MetricMetaData {
	if x != nil {
		return x.Metadata
	}
	return nil
}

func (x *MetricInformation) GetMetrics() map[string]float32 {
	if x != nil {
		return x.Metrics
	}
	return nil
}

// Struct to group metadata for a metric (or group of metrics) with the key-value
// pairs of collected metrics using 64-bit double precision floating point.
// This supports both floating-point metrics and large integer counters up to 2^53
// (e.g., FEC counters, GEM counters, optical power levels).
type MetricInformation64 struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Metadata      *MetricMetaData        `protobuf:"bytes,1,opt,name=metadata,proto3" json:"metadata,omitempty"`
	Metrics       map[string]float64     `protobuf:"bytes,2,rep,name=metrics,proto3" json:"metrics,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"fixed64,2,opt,name=value"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*MetricInformation64) ProtoMessage() {}

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

func (x *MetricInformation64) GetMetadata() *MetricMetaData {
	if x != nil {
		return x.Metadata
	}
	return nil
}

func (x *MetricInformation64) GetMetrics() map[string]float64 {
	if x != nil {
		return x.Metrics
	}
	return nil
}

// Legacy KPI Event structured.  In mid-August, the KPI event format was updated
//
//	to a more easily parsable format. See VOL-1140
//	for more information.
type KpiEvent struct {
	state         protoimpl.MessageState       `protogen:"open.v1"`
	Type          KpiEventType_Types           `protobuf:"varint,1,opt,name=type,proto3,enum=event.KpiEventType_Types" json:"type,omitempty"`
	Ts            float32                      `protobuf:"fixed32,2,opt,name=ts,proto3" json:"ts,omitempty"` // UTC time-stamp of data in slice mode (seconds since epoc)
	Prefixes      map[string]*MetricValuePairs `protobuf:"bytes,3,rep,name=prefixes,proto3" json:"prefixes,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*KpiEvent) ProtoMessage() {}

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

func (x *KpiEvent) GetType() KpiEventType_Types {
	if x != nil {
		return x.Type
	}
	return KpiEventType_slice
}

func (x *KpiEvent) GetTs() float32 {
	if x != nil {
		return x.Ts
	}
	return 0
}

func (x *KpiEvent) GetPrefixes() map[string]*MetricValuePairs {
	if x != nil {
		return x.Prefixes
	}
	return nil
}

type KpiEvent2 struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Type of KPI Event
	Type KpiEventType_Types `protobuf:"varint,1,opt,name=type,proto3,enum=event.KpiEventType_Types" json:"type,omitempty"`
	// Fields used when for slice:
	Ts            float64              `protobuf:"fixed64,2,opt,name=ts,proto3" json:"ts,omitempty"` // UTC time-stamp of data in slice mode (seconds since epoch)
	SliceData     []*MetricInformation `protobuf:"bytes,3,rep,name=slice_data,json=sliceData,proto3" json:"slice_data,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*KpiEvent2) ProtoMessage() {}

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

func (x *KpiEvent2) GetType() KpiEventType_Types {
	if x != nil {
		return x.Type
	}
	return KpiEventType_slice
}

func (x *KpiEvent2) GetTs() float64 {
	if x != nil {
		return x.Ts
	}
	return 0
}

func (x *KpiEvent2) GetSliceData() []*MetricInformation {
	if x != nil {
		return x.SliceData
	}
	return nil
}

// KpiEvent3 with support for 64-bit unsigned integer counters.
// Use this for metrics that require full 64-bit precision (e.g., FEC counters, GEM counters).
type KpiEvent3 struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Type of KPI Event
	Type KpiEventType_Types `protobuf:"varint,1,opt,name=type,proto3,enum=event.KpiEventType_Types" json:"type,omitempty"`
	// Fields used when for slice:
	Ts            float64                `protobuf:"fixed64,2,opt,name=ts,proto3" json:"ts,omitempty"` // UTC time-stamp of data in slice mode (seconds since epoch)
	SliceData     []*MetricInformation64 `protobuf:"bytes,3,rep,name=slice_data,json=sliceData,proto3" json:"slice_data,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*KpiEvent3) ProtoMessage() {}

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

func (x *KpiEvent3) GetType() KpiEventType_Types {
	if x != nil {
		return x.Type
	}
	return KpiEventType_slice
}

func (x *KpiEvent3) GetTs() float64 {
	if x != nil {
		return x.Ts
	}
	return 0
}

func (x *KpiEvent3) GetSliceData() []*MetricInformation64 {
	if x != nil {
		return x.SliceData
	}
	return nil
}

// Describes the events specific to device
type DeviceEvent struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Identifier of the originating resource of the event, for ex: device_id
	ResourceId string `protobuf:"bytes,1,opt,name=resource_id,json=resourceId,proto3" json:"resource_id,omitempty"`
	// device_event_name indicates clearly the name of the device event
	DeviceEventName string `protobuf:"bytes,2,opt,name=device_event_name,json=deviceEventName,proto3" json:"device_event_name,omitempty"`
	// Textual explanation of the device event
	Description string `protobuf:"bytes,3,opt,name=description,proto3" json:"description,omitempty"`
	// Key/Value storage for extra information that may give context to the event
	Context       map[string]string `protobuf:"bytes,4,rep,name=context,proto3" json:"context,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*DeviceEvent) ProtoMessage() {}

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

func (x *DeviceEvent) GetResourceId() string {
	if x != nil {
		return x.ResourceId
	}
	return ""
}

func (x *DeviceEvent) GetDeviceEventName() string {
	if x != nil {
		return x.DeviceEventName
	}
	return ""
}

func (x *DeviceEvent) GetDescription() string {
	if x != nil {
		return x.Description
	}
	return ""
}

func (x *DeviceEvent) GetContext() map[string]string {
	if x != nil {
		return x.Context
	}
	return nil
}

// Describes the events specific to an RPC request
type RPCEvent struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// RPC name
	Rpc string `protobuf:"bytes,1,opt,name=rpc,proto3" json:"rpc,omitempty"`
	// The operation id of that request.  Can be a log correlation ID
	OperationId string `protobuf:"bytes,2,opt,name=operation_id,json=operationId,proto3" json:"operation_id,omitempty"`
	// Identifies the service name originating the event
	Service string `protobuf:"bytes,3,opt,name=service,proto3" json:"service,omitempty"`
	// Identifies the stack originating the event
	StackId string `protobuf:"bytes,4,opt,name=stack_id,json=stackId,proto3" json:"stack_id,omitempty"`
	// Identifies the resource upon which the action is taken, e.g. device_id
	ResourceId string `protobuf:"bytes,5,opt,name=resource_id,json=resourceId,proto3" json:"resource_id,omitempty"`
	// Textual explanation of the event
	Description string `protobuf:"bytes,6,opt,name=description,proto3" json:"description,omitempty"`
	// Key/Value storage for extra information that may give context to the event
	Context map[string]string `protobuf:"bytes,7,rep,name=context,proto3" json:"context,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	// Status of the RPC Event
	Status        *common.OperationResp `protobuf:"bytes,8,opt,name=status,proto3" json:"status,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*RPCEvent) ProtoMessage() {}

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

func (x *RPCEvent) GetRpc() string {
	if x != nil {
		return x.Rpc
	}
	return ""
}

func (x *RPCEvent) GetOperationId() string {
	if x != nil {
		return x.OperationId
	}
	return ""
}

func (x *RPCEvent) GetService() string {
	if x != nil {
		return x.Service
	}
	return ""
}

func (x *RPCEvent) GetStackId() string {
	if x != nil {
		return x.StackId
	}
	return ""
}

func (x *RPCEvent) GetResourceId() string {
	if x != nil {
		return x.ResourceId
	}
	return ""
}

func (x *RPCEvent) GetDescription() string {
	if x != nil {
		return x.Description
	}
	return ""
}

func (x *RPCEvent) GetContext() map[string]string {
	if x != nil {
		return x.Context
	}
	return nil
}

func (x *RPCEvent) GetStatus() *common.OperationResp {
	if x != nil {
		return x.Status
	}
	return nil
}

// Identify the area of the system impacted by the event.
type EventCategory struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*EventCategory) ProtoMessage() {}

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

// Identify the functional category originating the event
type EventSubCategory struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*EventSubCategory) ProtoMessage() {}

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

// Identify the type of event
type EventType struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*EventType) ProtoMessage() {}

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

// Identify the functional category originating the event
type EventHeader struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Unique ID for this event.  e.g. voltha.some_olt.1234
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// Refers to the functional area affect by the event
	Category EventCategory_Types `protobuf:"varint,2,opt,name=category,proto3,enum=event.EventCategory_Types" json:"category,omitempty"`
	// Refers to functional category of the event
	SubCategory EventSubCategory_Types `protobuf:"varint,3,opt,name=sub_category,json=subCategory,proto3,enum=event.EventSubCategory_Types" json:"sub_category,omitempty"`
	// Refers to the type of the event
	Type EventType_Types `protobuf:"varint,4,opt,name=type,proto3,enum=event.EventType_Types" json:"type,omitempty"`
	// The version identifier for this event type, thus allowing each
	// event type to evolve independently. The version should be in the
	// format “MAJOR.MINOR” format and minor changes must only be additive
	// and non-breaking.
	TypeVersion string `protobuf:"bytes,5,opt,name=type_version,json=typeVersion,proto3" json:"type_version,omitempty"`
	// Timestamp at which the event was first raised.
	// This represents the UTC time stamp since epoch (in seconds) when the
	// the event was first raised from the source entity.
	// If the source entity doesn't send the raised_ts, this shall be set
	// to timestamp when the event was received.
	RaisedTs *timestamppb.Timestamp `protobuf:"bytes,6,opt,name=raised_ts,json=raisedTs,proto3" json:"raised_ts,omitempty"`
	// Timestamp at which the event was reported.
	// This represents the UTC time stamp since epoch (in seconds) when the
	// the event was reported (this time stamp is >= raised_ts).
	// If the source entity that reported this event doesn't send the
	// reported_ts, this shall be set to the same value as raised_ts.
	ReportedTs    *timestamppb.Timestamp `protobuf:"bytes,7,opt,name=reported_ts,json=reportedTs,proto3" json:"reported_ts,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*EventHeader) ProtoMessage() {}

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

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

func (x *EventHeader) GetCategory() EventCategory_Types {
	if x != nil {
		return x.Category
	}
	return EventCategory_COMMUNICATION
}

func (x *EventHeader) GetSubCategory() EventSubCategory_Types {
	if x != nil {
		return x.SubCategory
	}
	return EventSubCategory_PON
}

func (x *EventHeader) GetType() EventType_Types {
	if x != nil {
		return x.Type
	}
	return EventType_CONFIG_EVENT
}

func (x *EventHeader) GetTypeVersion() string {
	if x != nil {
		return x.TypeVersion
	}
	return ""
}

func (x *EventHeader) GetRaisedTs() *timestamppb.Timestamp {
	if x != nil {
		return x.RaisedTs
	}
	return nil
}

func (x *EventHeader) GetReportedTs() *timestamppb.Timestamp {
	if x != nil {
		return x.ReportedTs
	}
	return nil
}

// Event Structure
type Event struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// event header
	Header *EventHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
	// oneof event types referred by EventType.
	//
	// Types that are valid to be assigned to EventType:
	//
	//	*Event_ConfigEvent
	//	*Event_KpiEvent
	//	*Event_KpiEvent2
	//	*Event_DeviceEvent
	//	*Event_RpcEvent
	//	*Event_KpiEvent3
	EventType     isEvent_EventType `protobuf_oneof:"event_type"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Event) Reset() {
	*x = Event{}
	mi := &file_voltha_protos_events_proto_msgTypes[20]
	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_voltha_protos_events_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 Event.ProtoReflect.Descriptor instead.
func (*Event) Descriptor() ([]byte, []int) {
	return file_voltha_protos_events_proto_rawDescGZIP(), []int{20}
}

func (x *Event) GetHeader() *EventHeader {
	if x != nil {
		return x.Header
	}
	return nil
}

func (x *Event) GetEventType() isEvent_EventType {
	if x != nil {
		return x.EventType
	}
	return nil
}

func (x *Event) GetConfigEvent() *ConfigEvent {
	if x != nil {
		if x, ok := x.EventType.(*Event_ConfigEvent); ok {
			return x.ConfigEvent
		}
	}
	return nil
}

func (x *Event) GetKpiEvent() *KpiEvent {
	if x != nil {
		if x, ok := x.EventType.(*Event_KpiEvent); ok {
			return x.KpiEvent
		}
	}
	return nil
}

func (x *Event) GetKpiEvent2() *KpiEvent2 {
	if x != nil {
		if x, ok := x.EventType.(*Event_KpiEvent2); ok {
			return x.KpiEvent2
		}
	}
	return nil
}

func (x *Event) GetDeviceEvent() *DeviceEvent {
	if x != nil {
		if x, ok := x.EventType.(*Event_DeviceEvent); ok {
			return x.DeviceEvent
		}
	}
	return nil
}

func (x *Event) GetRpcEvent() *RPCEvent {
	if x != nil {
		if x, ok := x.EventType.(*Event_RpcEvent); ok {
			return x.RpcEvent
		}
	}
	return nil
}

func (x *Event) GetKpiEvent3() *KpiEvent3 {
	if x != nil {
		if x, ok := x.EventType.(*Event_KpiEvent3); ok {
			return x.KpiEvent3
		}
	}
	return nil
}

type isEvent_EventType interface {
	isEvent_EventType()
}

type Event_ConfigEvent struct {
	// Refers to ConfigEvent
	ConfigEvent *ConfigEvent `protobuf:"bytes,2,opt,name=config_event,json=configEvent,proto3,oneof"`
}

type Event_KpiEvent struct {
	// Refers to KpiEvent
	KpiEvent *KpiEvent `protobuf:"bytes,3,opt,name=kpi_event,json=kpiEvent,proto3,oneof"`
}

type Event_KpiEvent2 struct {
	// Refers to KpiEvent2
	KpiEvent2 *KpiEvent2 `protobuf:"bytes,4,opt,name=kpi_event2,json=kpiEvent2,proto3,oneof"`
}

type Event_DeviceEvent struct {
	// Refers to DeviceEvent
	DeviceEvent *DeviceEvent `protobuf:"bytes,5,opt,name=device_event,json=deviceEvent,proto3,oneof"`
}

type Event_RpcEvent struct {
	// Refers to an RPC Event
	RpcEvent *RPCEvent `protobuf:"bytes,6,opt,name=rpc_event,json=rpcEvent,proto3,oneof"`
}

type Event_KpiEvent3 struct {
	// Refers to KpiEvent3 (64-bit counter support)
	KpiEvent3 *KpiEvent3 `protobuf:"bytes,7,opt,name=kpi_event3,json=kpiEvent3,proto3,oneof"`
}

func (*Event_ConfigEvent) isEvent_EventType() {}

func (*Event_KpiEvent) isEvent_EventType() {}

func (*Event_KpiEvent2) isEvent_EventType() {}

func (*Event_DeviceEvent) isEvent_EventType() {}

func (*Event_RpcEvent) isEvent_EventType() {}

func (*Event_KpiEvent3) isEvent_EventType() {}

var File_voltha_protos_events_proto protoreflect.FileDescriptor

const file_voltha_protos_events_proto_rawDesc = "" +
	"\n" +
	"\x1avoltha_protos/events.proto\x12\x05event\x1a\x1cgoogle/api/annotations.proto\x1a\x1fgoogle/protobuf/timestamp.proto\x1a\x1avoltha_protos/common.proto\"\x9e\x01\n" +
	"\x12EventFilterRuleKey\"\x87\x01\n" +
	"\x13EventFilterRuleType\x12\x0e\n" +
	"\n" +
	"filter_all\x10\x00\x12\f\n" +
	"\bcategory\x10\x01\x12\x10\n" +
	"\fsub_category\x10\x02\x12\x12\n" +
	"\x0ekpi_event_type\x10\x03\x12\x15\n" +
	"\x11config_event_type\x10\x04\x12\x15\n" +
	"\x11device_event_type\x10\x05\"h\n" +
	"\x0fEventFilterRule\x12?\n" +
	"\x03key\x18\x01 \x01(\x0e2-.event.EventFilterRuleKey.EventFilterRuleTypeR\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\tR\x05value\"\x9f\x01\n" +
	"\vEventFilter\x12\x0e\n" +
	"\x02id\x18\x01 \x01(\tR\x02id\x12\x16\n" +
	"\x06enable\x18\x02 \x01(\bR\x06enable\x12\x1b\n" +
	"\tdevice_id\x18\x03 \x01(\tR\bdeviceId\x12\x1d\n" +
	"\n" +
	"event_type\x18\x04 \x01(\tR\teventType\x12,\n" +
	"\x05rules\x18\x05 \x03(\v2\x16.event.EventFilterRuleR\x05rules\"<\n" +
	"\fEventFilters\x12,\n" +
	"\afilters\x18\x01 \x03(\v2\x12.event.EventFilterR\afilters\";\n" +
	"\x0fConfigEventType\"(\n" +
	"\x05Types\x12\a\n" +
	"\x03add\x10\x00\x12\n" +
	"\n" +
	"\x06remove\x10\x01\x12\n" +
	"\n" +
	"\x06update\x10\x02\"g\n" +
	"\vConfigEvent\x120\n" +
	"\x04type\x18\x01 \x01(\x0e2\x1c.event.ConfigEventType.TypesR\x04type\x12\x12\n" +
	"\x04hash\x18\x02 \x01(\tR\x04hash\x12\x12\n" +
	"\x04data\x18\x03 \x01(\tR\x04data\"*\n" +
	"\fKpiEventType\"\x1a\n" +
	"\x05Types\x12\t\n" +
	"\x05slice\x10\x00\x12\x06\n" +
	"\x02ts\x10\x01\"\xaa\x02\n" +
	"\x0eMetricMetaData\x12\x14\n" +
	"\x05title\x18\x01 \x01(\tR\x05title\x12\x0e\n" +
	"\x02ts\x18\x02 \x01(\x01R\x02ts\x12*\n" +
	"\x11logical_device_id\x18\x03 \x01(\tR\x0flogicalDeviceId\x12\x1b\n" +
	"\tserial_no\x18\x04 \x01(\tR\bserialNo\x12\x1b\n" +
	"\tdevice_id\x18\x05 \x01(\tR\bdeviceId\x12<\n" +
	"\acontext\x18\x06 \x03(\v2\".event.MetricMetaData.ContextEntryR\acontext\x12\x12\n" +
	"\x04uuid\x18\a \x01(\tR\x04uuid\x1a:\n" +
	"\fContextEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"\x8e\x01\n" +
	"\x10MetricValuePairs\x12>\n" +
	"\ametrics\x18\x01 \x03(\v2$.event.MetricValuePairs.MetricsEntryR\ametrics\x1a:\n" +
	"\fMetricsEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\x02R\x05value:\x028\x01\"\xc3\x01\n" +
	"\x11MetricInformation\x121\n" +
	"\bmetadata\x18\x01 \x01(\v2\x15.event.MetricMetaDataR\bmetadata\x12?\n" +
	"\ametrics\x18\x02 \x03(\v2%.event.MetricInformation.MetricsEntryR\ametrics\x1a:\n" +
	"\fMetricsEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\x02R\x05value:\x028\x01\"\xc7\x01\n" +
	"\x13MetricInformation64\x121\n" +
	"\bmetadata\x18\x01 \x01(\v2\x15.event.MetricMetaDataR\bmetadata\x12A\n" +
	"\ametrics\x18\x02 \x03(\v2'.event.MetricInformation64.MetricsEntryR\ametrics\x1a:\n" +
	"\fMetricsEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\x01R\x05value:\x028\x01\"\xda\x01\n" +
	"\bKpiEvent\x12-\n" +
	"\x04type\x18\x01 \x01(\x0e2\x19.event.KpiEventType.TypesR\x04type\x12\x0e\n" +
	"\x02ts\x18\x02 \x01(\x02R\x02ts\x129\n" +
	"\bprefixes\x18\x03 \x03(\v2\x1d.event.KpiEvent.PrefixesEntryR\bprefixes\x1aT\n" +
	"\rPrefixesEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12-\n" +
	"\x05value\x18\x02 \x01(\v2\x17.event.MetricValuePairsR\x05value:\x028\x01\"\x83\x01\n" +
	"\tKpiEvent2\x12-\n" +
	"\x04type\x18\x01 \x01(\x0e2\x19.event.KpiEventType.TypesR\x04type\x12\x0e\n" +
	"\x02ts\x18\x02 \x01(\x01R\x02ts\x127\n" +
	"\n" +
	"slice_data\x18\x03 \x03(\v2\x18.event.MetricInformationR\tsliceData\"\x85\x01\n" +
	"\tKpiEvent3\x12-\n" +
	"\x04type\x18\x01 \x01(\x0e2\x19.event.KpiEventType.TypesR\x04type\x12\x0e\n" +
	"\x02ts\x18\x02 \x01(\x01R\x02ts\x129\n" +
	"\n" +
	"slice_data\x18\x03 \x03(\v2\x1a.event.MetricInformation64R\tsliceData\"\xf3\x01\n" +
	"\vDeviceEvent\x12\x1f\n" +
	"\vresource_id\x18\x01 \x01(\tR\n" +
	"resourceId\x12*\n" +
	"\x11device_event_name\x18\x02 \x01(\tR\x0fdeviceEventName\x12 \n" +
	"\vdescription\x18\x03 \x01(\tR\vdescription\x129\n" +
	"\acontext\x18\x04 \x03(\v2\x1f.event.DeviceEvent.ContextEntryR\acontext\x1a:\n" +
	"\fContextEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"\xda\x02\n" +
	"\bRPCEvent\x12\x10\n" +
	"\x03rpc\x18\x01 \x01(\tR\x03rpc\x12!\n" +
	"\foperation_id\x18\x02 \x01(\tR\voperationId\x12\x18\n" +
	"\aservice\x18\x03 \x01(\tR\aservice\x12\x19\n" +
	"\bstack_id\x18\x04 \x01(\tR\astackId\x12\x1f\n" +
	"\vresource_id\x18\x05 \x01(\tR\n" +
	"resourceId\x12 \n" +
	"\vdescription\x18\x06 \x01(\tR\vdescription\x126\n" +
	"\acontext\x18\a \x03(\v2\x1c.event.RPCEvent.ContextEntryR\acontext\x12-\n" +
	"\x06status\x18\b \x01(\v2\x15.common.OperationRespR\x06status\x1a:\n" +
	"\fContextEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"v\n" +
	"\rEventCategory\"e\n" +
	"\x05Types\x12\x11\n" +
	"\rCOMMUNICATION\x10\x00\x12\x0f\n" +
	"\vENVIRONMENT\x10\x01\x12\r\n" +
	"\tEQUIPMENT\x10\x02\x12\v\n" +
	"\aSERVICE\x10\x03\x12\x0e\n" +
	"\n" +
	"PROCESSING\x10\x04\x12\f\n" +
	"\bSECURITY\x10\x05\"R\n" +
	"\x10EventSubCategory\">\n" +
	"\x05Types\x12\a\n" +
	"\x03PON\x10\x00\x12\a\n" +
	"\x03OLT\x10\x01\x12\a\n" +
	"\x03ONT\x10\x02\x12\a\n" +
	"\x03ONU\x10\x03\x12\a\n" +
	"\x03NNI\x10\x04\x12\b\n" +
	"\x04NONE\x10\x05\"v\n" +
	"\tEventType\"i\n" +
	"\x05Types\x12\x10\n" +
	"\fCONFIG_EVENT\x10\x00\x12\r\n" +
	"\tKPI_EVENT\x10\x01\x12\x0e\n" +
	"\n" +
	"KPI_EVENT2\x10\x02\x12\x10\n" +
	"\fDEVICE_EVENT\x10\x03\x12\r\n" +
	"\tRPC_EVENT\x10\x04\x12\x0e\n" +
	"\n" +
	"KPI_EVENT3\x10\x05\"\xdc\x02\n" +
	"\vEventHeader\x12\x0e\n" +
	"\x02id\x18\x01 \x01(\tR\x02id\x126\n" +
	"\bcategory\x18\x02 \x01(\x0e2\x1a.event.EventCategory.TypesR\bcategory\x12@\n" +
	"\fsub_category\x18\x03 \x01(\x0e2\x1d.event.EventSubCategory.TypesR\vsubCategory\x12*\n" +
	"\x04type\x18\x04 \x01(\x0e2\x16.event.EventType.TypesR\x04type\x12!\n" +
	"\ftype_version\x18\x05 \x01(\tR\vtypeVersion\x127\n" +
	"\traised_ts\x18\x06 \x01(\v2\x1a.google.protobuf.TimestampR\braisedTs\x12;\n" +
	"\vreported_ts\x18\a \x01(\v2\x1a.google.protobuf.TimestampR\n" +
	"reportedTs\"\xf9\x02\n" +
	"\x05Event\x12*\n" +
	"\x06header\x18\x01 \x01(\v2\x12.event.EventHeaderR\x06header\x127\n" +
	"\fconfig_event\x18\x02 \x01(\v2\x12.event.ConfigEventH\x00R\vconfigEvent\x12.\n" +
	"\tkpi_event\x18\x03 \x01(\v2\x0f.event.KpiEventH\x00R\bkpiEvent\x121\n" +
	"\n" +
	"kpi_event2\x18\x04 \x01(\v2\x10.event.KpiEvent2H\x00R\tkpiEvent2\x127\n" +
	"\fdevice_event\x18\x05 \x01(\v2\x12.event.DeviceEventH\x00R\vdeviceEvent\x12.\n" +
	"\trpc_event\x18\x06 \x01(\v2\x0f.event.RPCEventH\x00R\brpcEvent\x121\n" +
	"\n" +
	"kpi_event3\x18\a \x01(\v2\x10.event.KpiEvent3H\x00R\tkpiEvent3B\f\n" +
	"\n" +
	"event_typeBL\n" +
	"\x1aorg.opencord.voltha.eventsZ.github.com/opencord/voltha-protos/v5/go/volthab\x06proto3"

var (
	file_voltha_protos_events_proto_rawDescOnce sync.Once
	file_voltha_protos_events_proto_rawDescData []byte
)

func file_voltha_protos_events_proto_rawDescGZIP() []byte {
	file_voltha_protos_events_proto_rawDescOnce.Do(func() {
		file_voltha_protos_events_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_voltha_protos_events_proto_rawDesc), len(file_voltha_protos_events_proto_rawDesc)))
	})
	return file_voltha_protos_events_proto_rawDescData
}

var file_voltha_protos_events_proto_enumTypes = make([]protoimpl.EnumInfo, 6)
var file_voltha_protos_events_proto_msgTypes = make([]protoimpl.MessageInfo, 28)
var file_voltha_protos_events_proto_goTypes = []any{
	(EventFilterRuleKey_EventFilterRuleType)(0), // 0: event.EventFilterRuleKey.EventFilterRuleType
	(ConfigEventType_Types)(0),                  // 1: event.ConfigEventType.Types
	(KpiEventType_Types)(0),                     // 2: event.KpiEventType.Types
	(EventCategory_Types)(0),                    // 3: event.EventCategory.Types
	(EventSubCategory_Types)(0),                 // 4: event.EventSubCategory.Types
	(EventType_Types)(0),                        // 5: event.EventType.Types
	(*EventFilterRuleKey)(nil),                  // 6: event.EventFilterRuleKey
	(*EventFilterRule)(nil),                     // 7: event.EventFilterRule
	(*EventFilter)(nil),                         // 8: event.EventFilter
	(*EventFilters)(nil),                        // 9: event.EventFilters
	(*ConfigEventType)(nil),                     // 10: event.ConfigEventType
	(*ConfigEvent)(nil),                         // 11: event.ConfigEvent
	(*KpiEventType)(nil),                        // 12: event.KpiEventType
	(*MetricMetaData)(nil),                      // 13: event.MetricMetaData
	(*MetricValuePairs)(nil),                    // 14: event.MetricValuePairs
	(*MetricInformation)(nil),                   // 15: event.MetricInformation
	(*MetricInformation64)(nil),                 // 16: event.MetricInformation64
	(*KpiEvent)(nil),                            // 17: event.KpiEvent
	(*KpiEvent2)(nil),                           // 18: event.KpiEvent2
	(*KpiEvent3)(nil),                           // 19: event.KpiEvent3
	(*DeviceEvent)(nil),                         // 20: event.DeviceEvent
	(*RPCEvent)(nil),                            // 21: event.RPCEvent
	(*EventCategory)(nil),                       // 22: event.EventCategory
	(*EventSubCategory)(nil),                    // 23: event.EventSubCategory
	(*EventType)(nil),                           // 24: event.EventType
	(*EventHeader)(nil),                         // 25: event.EventHeader
	(*Event)(nil),                               // 26: event.Event
	nil,                                         // 27: event.MetricMetaData.ContextEntry
	nil,                                         // 28: event.MetricValuePairs.MetricsEntry
	nil,                                         // 29: event.MetricInformation.MetricsEntry
	nil,                                         // 30: event.MetricInformation64.MetricsEntry
	nil,                                         // 31: event.KpiEvent.PrefixesEntry
	nil,                                         // 32: event.DeviceEvent.ContextEntry
	nil,                                         // 33: event.RPCEvent.ContextEntry
	(*common.OperationResp)(nil),                // 34: common.OperationResp
	(*timestamppb.Timestamp)(nil),               // 35: google.protobuf.Timestamp
}
var file_voltha_protos_events_proto_depIdxs = []int32{
	0,  // 0: event.EventFilterRule.key:type_name -> event.EventFilterRuleKey.EventFilterRuleType
	7,  // 1: event.EventFilter.rules:type_name -> event.EventFilterRule
	8,  // 2: event.EventFilters.filters:type_name -> event.EventFilter
	1,  // 3: event.ConfigEvent.type:type_name -> event.ConfigEventType.Types
	27, // 4: event.MetricMetaData.context:type_name -> event.MetricMetaData.ContextEntry
	28, // 5: event.MetricValuePairs.metrics:type_name -> event.MetricValuePairs.MetricsEntry
	13, // 6: event.MetricInformation.metadata:type_name -> event.MetricMetaData
	29, // 7: event.MetricInformation.metrics:type_name -> event.MetricInformation.MetricsEntry
	13, // 8: event.MetricInformation64.metadata:type_name -> event.MetricMetaData
	30, // 9: event.MetricInformation64.metrics:type_name -> event.MetricInformation64.MetricsEntry
	2,  // 10: event.KpiEvent.type:type_name -> event.KpiEventType.Types
	31, // 11: event.KpiEvent.prefixes:type_name -> event.KpiEvent.PrefixesEntry
	2,  // 12: event.KpiEvent2.type:type_name -> event.KpiEventType.Types
	15, // 13: event.KpiEvent2.slice_data:type_name -> event.MetricInformation
	2,  // 14: event.KpiEvent3.type:type_name -> event.KpiEventType.Types
	16, // 15: event.KpiEvent3.slice_data:type_name -> event.MetricInformation64
	32, // 16: event.DeviceEvent.context:type_name -> event.DeviceEvent.ContextEntry
	33, // 17: event.RPCEvent.context:type_name -> event.RPCEvent.ContextEntry
	34, // 18: event.RPCEvent.status:type_name -> common.OperationResp
	3,  // 19: event.EventHeader.category:type_name -> event.EventCategory.Types
	4,  // 20: event.EventHeader.sub_category:type_name -> event.EventSubCategory.Types
	5,  // 21: event.EventHeader.type:type_name -> event.EventType.Types
	35, // 22: event.EventHeader.raised_ts:type_name -> google.protobuf.Timestamp
	35, // 23: event.EventHeader.reported_ts:type_name -> google.protobuf.Timestamp
	25, // 24: event.Event.header:type_name -> event.EventHeader
	11, // 25: event.Event.config_event:type_name -> event.ConfigEvent
	17, // 26: event.Event.kpi_event:type_name -> event.KpiEvent
	18, // 27: event.Event.kpi_event2:type_name -> event.KpiEvent2
	20, // 28: event.Event.device_event:type_name -> event.DeviceEvent
	21, // 29: event.Event.rpc_event:type_name -> event.RPCEvent
	19, // 30: event.Event.kpi_event3:type_name -> event.KpiEvent3
	14, // 31: event.KpiEvent.PrefixesEntry.value:type_name -> event.MetricValuePairs
	32, // [32:32] is the sub-list for method output_type
	32, // [32:32] is the sub-list for method input_type
	32, // [32:32] is the sub-list for extension type_name
	32, // [32:32] is the sub-list for extension extendee
	0,  // [0:32] is the sub-list for field type_name
}

func init() { file_voltha_protos_events_proto_init() }
func file_voltha_protos_events_proto_init() {
	if File_voltha_protos_events_proto != nil {
		return
	}
	file_voltha_protos_events_proto_msgTypes[20].OneofWrappers = []any{
		(*Event_ConfigEvent)(nil),
		(*Event_KpiEvent)(nil),
		(*Event_KpiEvent2)(nil),
		(*Event_DeviceEvent)(nil),
		(*Event_RpcEvent)(nil),
		(*Event_KpiEvent3)(nil),
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_voltha_protos_events_proto_rawDesc), len(file_voltha_protos_events_proto_rawDesc)),
			NumEnums:      6,
			NumMessages:   28,
			NumExtensions: 0,
			NumServices:   0,
		},
		GoTypes:           file_voltha_protos_events_proto_goTypes,
		DependencyIndexes: file_voltha_protos_events_proto_depIdxs,
		EnumInfos:         file_voltha_protos_events_proto_enumTypes,
		MessageInfos:      file_voltha_protos_events_proto_msgTypes,
	}.Build()
	File_voltha_protos_events_proto = out.File
	file_voltha_protos_events_proto_goTypes = nil
	file_voltha_protos_events_proto_depIdxs = nil
}