// Code generated by protoc-gen-go. DO NOT EDIT.
// source: voltha_protos/events.proto

package voltha

import (
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	timestamp "github.com/golang/protobuf/ptypes/timestamp"
	common "github.com/opencord/voltha-protos/v5/go/common"
	_ "google.golang.org/genproto/googleapis/api/annotations"
	math "math"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package

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
)

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",
}

var 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) String() string {
	return proto.EnumName(EventFilterRuleKey_EventFilterRuleType_name, int32(x))
}

func (EventFilterRuleKey_EventFilterRuleType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_e63e6c07044fd2c4, []int{0, 0}
}

type ConfigEventType_Types int32

const (
	ConfigEventType_add    ConfigEventType_Types = 0
	ConfigEventType_remove ConfigEventType_Types = 1
	ConfigEventType_update ConfigEventType_Types = 2
)

var ConfigEventType_Types_name = map[int32]string{
	0: "add",
	1: "remove",
	2: "update",
}

var ConfigEventType_Types_value = map[string]int32{
	"add":    0,
	"remove": 1,
	"update": 2,
}

func (x ConfigEventType_Types) String() string {
	return proto.EnumName(ConfigEventType_Types_name, int32(x))
}

func (ConfigEventType_Types) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_e63e6c07044fd2c4, []int{4, 0}
}

type KpiEventType_Types int32

const (
	KpiEventType_slice KpiEventType_Types = 0
	KpiEventType_ts    KpiEventType_Types = 1
)

var KpiEventType_Types_name = map[int32]string{
	0: "slice",
	1: "ts",
}

var KpiEventType_Types_value = map[string]int32{
	"slice": 0,
	"ts":    1,
}

func (x KpiEventType_Types) String() string {
	return proto.EnumName(KpiEventType_Types_name, int32(x))
}

func (KpiEventType_Types) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_e63e6c07044fd2c4, []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
)

var EventCategory_Types_name = map[int32]string{
	0: "COMMUNICATION",
	1: "ENVIRONMENT",
	2: "EQUIPMENT",
	3: "SERVICE",
	4: "PROCESSING",
	5: "SECURITY",
}

var EventCategory_Types_value = map[string]int32{
	"COMMUNICATION": 0,
	"ENVIRONMENT":   1,
	"EQUIPMENT":     2,
	"SERVICE":       3,
	"PROCESSING":    4,
	"SECURITY":      5,
}

func (x EventCategory_Types) String() string {
	return proto.EnumName(EventCategory_Types_name, int32(x))
}

func (EventCategory_Types) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_e63e6c07044fd2c4, []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
)

var EventSubCategory_Types_name = map[int32]string{
	0: "PON",
	1: "OLT",
	2: "ONT",
	3: "ONU",
	4: "NNI",
	5: "NONE",
}

var EventSubCategory_Types_value = map[string]int32{
	"PON":  0,
	"OLT":  1,
	"ONT":  2,
	"ONU":  3,
	"NNI":  4,
	"NONE": 5,
}

func (x EventSubCategory_Types) String() string {
	return proto.EnumName(EventSubCategory_Types_name, int32(x))
}

func (EventSubCategory_Types) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_e63e6c07044fd2c4, []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
)

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",
}

var 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) String() string {
	return proto.EnumName(EventType_Types_name, int32(x))
}

func (EventType_Types) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_e63e6c07044fd2c4, []int{18, 0}
}

type EventFilterRuleKey struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *EventFilterRuleKey) Reset()         { *m = EventFilterRuleKey{} }
func (m *EventFilterRuleKey) String() string { return proto.CompactTextString(m) }
func (*EventFilterRuleKey) ProtoMessage()    {}
func (*EventFilterRuleKey) Descriptor() ([]byte, []int) {
	return fileDescriptor_e63e6c07044fd2c4, []int{0}
}

func (m *EventFilterRuleKey) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_EventFilterRuleKey.Unmarshal(m, b)
}
func (m *EventFilterRuleKey) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_EventFilterRuleKey.Marshal(b, m, deterministic)
}
func (m *EventFilterRuleKey) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EventFilterRuleKey.Merge(m, src)
}
func (m *EventFilterRuleKey) XXX_Size() int {
	return xxx_messageInfo_EventFilterRuleKey.Size(m)
}
func (m *EventFilterRuleKey) XXX_DiscardUnknown() {
	xxx_messageInfo_EventFilterRuleKey.DiscardUnknown(m)
}

var xxx_messageInfo_EventFilterRuleKey proto.InternalMessageInfo

type EventFilterRule struct {
	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"`
	XXX_NoUnkeyedLiteral struct{}                               `json:"-"`
	XXX_unrecognized     []byte                                 `json:"-"`
	XXX_sizecache        int32                                  `json:"-"`
}

func (m *EventFilterRule) Reset()         { *m = EventFilterRule{} }
func (m *EventFilterRule) String() string { return proto.CompactTextString(m) }
func (*EventFilterRule) ProtoMessage()    {}
func (*EventFilterRule) Descriptor() ([]byte, []int) {
	return fileDescriptor_e63e6c07044fd2c4, []int{1}
}

func (m *EventFilterRule) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_EventFilterRule.Unmarshal(m, b)
}
func (m *EventFilterRule) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_EventFilterRule.Marshal(b, m, deterministic)
}
func (m *EventFilterRule) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EventFilterRule.Merge(m, src)
}
func (m *EventFilterRule) XXX_Size() int {
	return xxx_messageInfo_EventFilterRule.Size(m)
}
func (m *EventFilterRule) XXX_DiscardUnknown() {
	xxx_messageInfo_EventFilterRule.DiscardUnknown(m)
}

var xxx_messageInfo_EventFilterRule proto.InternalMessageInfo

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

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

type EventFilter struct {
	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"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

func (m *EventFilter) Reset()         { *m = EventFilter{} }
func (m *EventFilter) String() string { return proto.CompactTextString(m) }
func (*EventFilter) ProtoMessage()    {}
func (*EventFilter) Descriptor() ([]byte, []int) {
	return fileDescriptor_e63e6c07044fd2c4, []int{2}
}

func (m *EventFilter) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_EventFilter.Unmarshal(m, b)
}
func (m *EventFilter) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_EventFilter.Marshal(b, m, deterministic)
}
func (m *EventFilter) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EventFilter.Merge(m, src)
}
func (m *EventFilter) XXX_Size() int {
	return xxx_messageInfo_EventFilter.Size(m)
}
func (m *EventFilter) XXX_DiscardUnknown() {
	xxx_messageInfo_EventFilter.DiscardUnknown(m)
}

var xxx_messageInfo_EventFilter proto.InternalMessageInfo

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

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

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

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

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

type EventFilters struct {
	Filters              []*EventFilter `protobuf:"bytes,1,rep,name=filters,proto3" json:"filters,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

func (m *EventFilters) Reset()         { *m = EventFilters{} }
func (m *EventFilters) String() string { return proto.CompactTextString(m) }
func (*EventFilters) ProtoMessage()    {}
func (*EventFilters) Descriptor() ([]byte, []int) {
	return fileDescriptor_e63e6c07044fd2c4, []int{3}
}

func (m *EventFilters) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_EventFilters.Unmarshal(m, b)
}
func (m *EventFilters) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_EventFilters.Marshal(b, m, deterministic)
}
func (m *EventFilters) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EventFilters.Merge(m, src)
}
func (m *EventFilters) XXX_Size() int {
	return xxx_messageInfo_EventFilters.Size(m)
}
func (m *EventFilters) XXX_DiscardUnknown() {
	xxx_messageInfo_EventFilters.DiscardUnknown(m)
}

var xxx_messageInfo_EventFilters proto.InternalMessageInfo

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

type ConfigEventType struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ConfigEventType) Reset()         { *m = ConfigEventType{} }
func (m *ConfigEventType) String() string { return proto.CompactTextString(m) }
func (*ConfigEventType) ProtoMessage()    {}
func (*ConfigEventType) Descriptor() ([]byte, []int) {
	return fileDescriptor_e63e6c07044fd2c4, []int{4}
}

func (m *ConfigEventType) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ConfigEventType.Unmarshal(m, b)
}
func (m *ConfigEventType) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ConfigEventType.Marshal(b, m, deterministic)
}
func (m *ConfigEventType) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ConfigEventType.Merge(m, src)
}
func (m *ConfigEventType) XXX_Size() int {
	return xxx_messageInfo_ConfigEventType.Size(m)
}
func (m *ConfigEventType) XXX_DiscardUnknown() {
	xxx_messageInfo_ConfigEventType.DiscardUnknown(m)
}

var xxx_messageInfo_ConfigEventType proto.InternalMessageInfo

type ConfigEvent struct {
	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"`
	Data                 string                `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

func (m *ConfigEvent) Reset()         { *m = ConfigEvent{} }
func (m *ConfigEvent) String() string { return proto.CompactTextString(m) }
func (*ConfigEvent) ProtoMessage()    {}
func (*ConfigEvent) Descriptor() ([]byte, []int) {
	return fileDescriptor_e63e6c07044fd2c4, []int{5}
}

func (m *ConfigEvent) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ConfigEvent.Unmarshal(m, b)
}
func (m *ConfigEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ConfigEvent.Marshal(b, m, deterministic)
}
func (m *ConfigEvent) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ConfigEvent.Merge(m, src)
}
func (m *ConfigEvent) XXX_Size() int {
	return xxx_messageInfo_ConfigEvent.Size(m)
}
func (m *ConfigEvent) XXX_DiscardUnknown() {
	xxx_messageInfo_ConfigEvent.DiscardUnknown(m)
}

var xxx_messageInfo_ConfigEvent proto.InternalMessageInfo

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

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

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

type KpiEventType struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *KpiEventType) Reset()         { *m = KpiEventType{} }
func (m *KpiEventType) String() string { return proto.CompactTextString(m) }
func (*KpiEventType) ProtoMessage()    {}
func (*KpiEventType) Descriptor() ([]byte, []int) {
	return fileDescriptor_e63e6c07044fd2c4, []int{6}
}

func (m *KpiEventType) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_KpiEventType.Unmarshal(m, b)
}
func (m *KpiEventType) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_KpiEventType.Marshal(b, m, deterministic)
}
func (m *KpiEventType) XXX_Merge(src proto.Message) {
	xxx_messageInfo_KpiEventType.Merge(m, src)
}
func (m *KpiEventType) XXX_Size() int {
	return xxx_messageInfo_KpiEventType.Size(m)
}
func (m *KpiEventType) XXX_DiscardUnknown() {
	xxx_messageInfo_KpiEventType.DiscardUnknown(m)
}

var xxx_messageInfo_KpiEventType proto.InternalMessageInfo

//
// Struct to convey a dictionary of metric metadata.
type MetricMetaData struct {
	Title           string  `protobuf:"bytes,1,opt,name=title,proto3" json:"title,omitempty"`
	Ts              float64 `protobuf:"fixed64,2,opt,name=ts,proto3" json:"ts,omitempty"`
	LogicalDeviceId string  `protobuf:"bytes,3,opt,name=logical_device_id,json=logicalDeviceId,proto3" json:"logical_device_id,omitempty"`
	// (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"`
	DeviceId             string            `protobuf:"bytes,5,opt,name=device_id,json=deviceId,proto3" json:"device_id,omitempty"`
	Context              map[string]string `protobuf:"bytes,6,rep,name=context,proto3" json:"context,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	Uuid                 string            `protobuf:"bytes,7,opt,name=uuid,proto3" json:"uuid,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *MetricMetaData) Reset()         { *m = MetricMetaData{} }
func (m *MetricMetaData) String() string { return proto.CompactTextString(m) }
func (*MetricMetaData) ProtoMessage()    {}
func (*MetricMetaData) Descriptor() ([]byte, []int) {
	return fileDescriptor_e63e6c07044fd2c4, []int{7}
}

func (m *MetricMetaData) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MetricMetaData.Unmarshal(m, b)
}
func (m *MetricMetaData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MetricMetaData.Marshal(b, m, deterministic)
}
func (m *MetricMetaData) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MetricMetaData.Merge(m, src)
}
func (m *MetricMetaData) XXX_Size() int {
	return xxx_messageInfo_MetricMetaData.Size(m)
}
func (m *MetricMetaData) XXX_DiscardUnknown() {
	xxx_messageInfo_MetricMetaData.DiscardUnknown(m)
}

var xxx_messageInfo_MetricMetaData proto.InternalMessageInfo

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

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

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

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

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

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

func (m *MetricMetaData) GetUuid() string {
	if m != nil {
		return m.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 {
	// Metric / value pairs.
	Metrics              map[string]float32 `protobuf:"bytes,1,rep,name=metrics,proto3" json:"metrics,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"fixed32,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

func (m *MetricValuePairs) Reset()         { *m = MetricValuePairs{} }
func (m *MetricValuePairs) String() string { return proto.CompactTextString(m) }
func (*MetricValuePairs) ProtoMessage()    {}
func (*MetricValuePairs) Descriptor() ([]byte, []int) {
	return fileDescriptor_e63e6c07044fd2c4, []int{8}
}

func (m *MetricValuePairs) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MetricValuePairs.Unmarshal(m, b)
}
func (m *MetricValuePairs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MetricValuePairs.Marshal(b, m, deterministic)
}
func (m *MetricValuePairs) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MetricValuePairs.Merge(m, src)
}
func (m *MetricValuePairs) XXX_Size() int {
	return xxx_messageInfo_MetricValuePairs.Size(m)
}
func (m *MetricValuePairs) XXX_DiscardUnknown() {
	xxx_messageInfo_MetricValuePairs.DiscardUnknown(m)
}

var xxx_messageInfo_MetricValuePairs proto.InternalMessageInfo

func (m *MetricValuePairs) GetMetrics() map[string]float32 {
	if m != nil {
		return m.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 {
	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,proto3" protobuf_val:"fixed32,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

func (m *MetricInformation) Reset()         { *m = MetricInformation{} }
func (m *MetricInformation) String() string { return proto.CompactTextString(m) }
func (*MetricInformation) ProtoMessage()    {}
func (*MetricInformation) Descriptor() ([]byte, []int) {
	return fileDescriptor_e63e6c07044fd2c4, []int{9}
}

func (m *MetricInformation) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MetricInformation.Unmarshal(m, b)
}
func (m *MetricInformation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MetricInformation.Marshal(b, m, deterministic)
}
func (m *MetricInformation) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MetricInformation.Merge(m, src)
}
func (m *MetricInformation) XXX_Size() int {
	return xxx_messageInfo_MetricInformation.Size(m)
}
func (m *MetricInformation) XXX_DiscardUnknown() {
	xxx_messageInfo_MetricInformation.DiscardUnknown(m)
}

var xxx_messageInfo_MetricInformation proto.InternalMessageInfo

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

func (m *MetricInformation) GetMetrics() map[string]float32 {
	if m != nil {
		return m.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 unsigned integers.
// This is used for counters that can exceed the precision of float (e.g., FEC, GEM counters).
type MetricInformation64 struct {
	Metadata             *MetricMetaData   `protobuf:"bytes,1,opt,name=metadata,proto3" json:"metadata,omitempty"`
	Metrics              map[string]uint64 `protobuf:"bytes,2,rep,name=metrics,proto3" json:"metrics,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *MetricInformation64) Reset()         { *m = MetricInformation64{} }
func (m *MetricInformation64) String() string { return proto.CompactTextString(m) }
func (*MetricInformation64) ProtoMessage()    {}
func (*MetricInformation64) Descriptor() ([]byte, []int) {
	return fileDescriptor_e63e6c07044fd2c4, []int{10}
}

func (m *MetricInformation64) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MetricInformation64.Unmarshal(m, b)
}
func (m *MetricInformation64) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MetricInformation64.Marshal(b, m, deterministic)
}
func (m *MetricInformation64) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MetricInformation64.Merge(m, src)
}
func (m *MetricInformation64) XXX_Size() int {
	return xxx_messageInfo_MetricInformation64.Size(m)
}
func (m *MetricInformation64) XXX_DiscardUnknown() {
	xxx_messageInfo_MetricInformation64.DiscardUnknown(m)
}

var xxx_messageInfo_MetricInformation64 proto.InternalMessageInfo

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

func (m *MetricInformation64) GetMetrics() map[string]uint64 {
	if m != nil {
		return m.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 {
	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"`
	Prefixes             map[string]*MetricValuePairs `protobuf:"bytes,3,rep,name=prefixes,proto3" json:"prefixes,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}                     `json:"-"`
	XXX_unrecognized     []byte                       `json:"-"`
	XXX_sizecache        int32                        `json:"-"`
}

func (m *KpiEvent) Reset()         { *m = KpiEvent{} }
func (m *KpiEvent) String() string { return proto.CompactTextString(m) }
func (*KpiEvent) ProtoMessage()    {}
func (*KpiEvent) Descriptor() ([]byte, []int) {
	return fileDescriptor_e63e6c07044fd2c4, []int{11}
}

func (m *KpiEvent) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_KpiEvent.Unmarshal(m, b)
}
func (m *KpiEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_KpiEvent.Marshal(b, m, deterministic)
}
func (m *KpiEvent) XXX_Merge(src proto.Message) {
	xxx_messageInfo_KpiEvent.Merge(m, src)
}
func (m *KpiEvent) XXX_Size() int {
	return xxx_messageInfo_KpiEvent.Size(m)
}
func (m *KpiEvent) XXX_DiscardUnknown() {
	xxx_messageInfo_KpiEvent.DiscardUnknown(m)
}

var xxx_messageInfo_KpiEvent proto.InternalMessageInfo

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

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

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

type KpiEvent2 struct {
	// 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"`
	SliceData            []*MetricInformation `protobuf:"bytes,3,rep,name=slice_data,json=sliceData,proto3" json:"slice_data,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

func (m *KpiEvent2) Reset()         { *m = KpiEvent2{} }
func (m *KpiEvent2) String() string { return proto.CompactTextString(m) }
func (*KpiEvent2) ProtoMessage()    {}
func (*KpiEvent2) Descriptor() ([]byte, []int) {
	return fileDescriptor_e63e6c07044fd2c4, []int{12}
}

func (m *KpiEvent2) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_KpiEvent2.Unmarshal(m, b)
}
func (m *KpiEvent2) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_KpiEvent2.Marshal(b, m, deterministic)
}
func (m *KpiEvent2) XXX_Merge(src proto.Message) {
	xxx_messageInfo_KpiEvent2.Merge(m, src)
}
func (m *KpiEvent2) XXX_Size() int {
	return xxx_messageInfo_KpiEvent2.Size(m)
}
func (m *KpiEvent2) XXX_DiscardUnknown() {
	xxx_messageInfo_KpiEvent2.DiscardUnknown(m)
}

var xxx_messageInfo_KpiEvent2 proto.InternalMessageInfo

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

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

func (m *KpiEvent2) GetSliceData() []*MetricInformation {
	if m != nil {
		return m.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 {
	// 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"`
	SliceData            []*MetricInformation64 `protobuf:"bytes,3,rep,name=slice_data,json=sliceData,proto3" json:"slice_data,omitempty"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

func (m *KpiEvent3) Reset()         { *m = KpiEvent3{} }
func (m *KpiEvent3) String() string { return proto.CompactTextString(m) }
func (*KpiEvent3) ProtoMessage()    {}
func (*KpiEvent3) Descriptor() ([]byte, []int) {
	return fileDescriptor_e63e6c07044fd2c4, []int{13}
}

func (m *KpiEvent3) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_KpiEvent3.Unmarshal(m, b)
}
func (m *KpiEvent3) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_KpiEvent3.Marshal(b, m, deterministic)
}
func (m *KpiEvent3) XXX_Merge(src proto.Message) {
	xxx_messageInfo_KpiEvent3.Merge(m, src)
}
func (m *KpiEvent3) XXX_Size() int {
	return xxx_messageInfo_KpiEvent3.Size(m)
}
func (m *KpiEvent3) XXX_DiscardUnknown() {
	xxx_messageInfo_KpiEvent3.DiscardUnknown(m)
}

var xxx_messageInfo_KpiEvent3 proto.InternalMessageInfo

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

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

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

//
// Describes the events specific to device
type DeviceEvent struct {
	// 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,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *DeviceEvent) Reset()         { *m = DeviceEvent{} }
func (m *DeviceEvent) String() string { return proto.CompactTextString(m) }
func (*DeviceEvent) ProtoMessage()    {}
func (*DeviceEvent) Descriptor() ([]byte, []int) {
	return fileDescriptor_e63e6c07044fd2c4, []int{14}
}

func (m *DeviceEvent) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_DeviceEvent.Unmarshal(m, b)
}
func (m *DeviceEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_DeviceEvent.Marshal(b, m, deterministic)
}
func (m *DeviceEvent) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DeviceEvent.Merge(m, src)
}
func (m *DeviceEvent) XXX_Size() int {
	return xxx_messageInfo_DeviceEvent.Size(m)
}
func (m *DeviceEvent) XXX_DiscardUnknown() {
	xxx_messageInfo_DeviceEvent.DiscardUnknown(m)
}

var xxx_messageInfo_DeviceEvent proto.InternalMessageInfo

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

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

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

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

//
// Describes the events specific to an RPC request
type RPCEvent struct {
	// 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,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	// Status of the RPC Event
	Status               *common.OperationResp `protobuf:"bytes,8,opt,name=status,proto3" json:"status,omitempty"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

func (m *RPCEvent) Reset()         { *m = RPCEvent{} }
func (m *RPCEvent) String() string { return proto.CompactTextString(m) }
func (*RPCEvent) ProtoMessage()    {}
func (*RPCEvent) Descriptor() ([]byte, []int) {
	return fileDescriptor_e63e6c07044fd2c4, []int{15}
}

func (m *RPCEvent) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RPCEvent.Unmarshal(m, b)
}
func (m *RPCEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RPCEvent.Marshal(b, m, deterministic)
}
func (m *RPCEvent) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RPCEvent.Merge(m, src)
}
func (m *RPCEvent) XXX_Size() int {
	return xxx_messageInfo_RPCEvent.Size(m)
}
func (m *RPCEvent) XXX_DiscardUnknown() {
	xxx_messageInfo_RPCEvent.DiscardUnknown(m)
}

var xxx_messageInfo_RPCEvent proto.InternalMessageInfo

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

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

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

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

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

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

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

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

//
// Identify the area of the system impacted by the event.
type EventCategory struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *EventCategory) Reset()         { *m = EventCategory{} }
func (m *EventCategory) String() string { return proto.CompactTextString(m) }
func (*EventCategory) ProtoMessage()    {}
func (*EventCategory) Descriptor() ([]byte, []int) {
	return fileDescriptor_e63e6c07044fd2c4, []int{16}
}

func (m *EventCategory) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_EventCategory.Unmarshal(m, b)
}
func (m *EventCategory) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_EventCategory.Marshal(b, m, deterministic)
}
func (m *EventCategory) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EventCategory.Merge(m, src)
}
func (m *EventCategory) XXX_Size() int {
	return xxx_messageInfo_EventCategory.Size(m)
}
func (m *EventCategory) XXX_DiscardUnknown() {
	xxx_messageInfo_EventCategory.DiscardUnknown(m)
}

var xxx_messageInfo_EventCategory proto.InternalMessageInfo

//
// Identify the functional category originating the event
type EventSubCategory struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *EventSubCategory) Reset()         { *m = EventSubCategory{} }
func (m *EventSubCategory) String() string { return proto.CompactTextString(m) }
func (*EventSubCategory) ProtoMessage()    {}
func (*EventSubCategory) Descriptor() ([]byte, []int) {
	return fileDescriptor_e63e6c07044fd2c4, []int{17}
}

func (m *EventSubCategory) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_EventSubCategory.Unmarshal(m, b)
}
func (m *EventSubCategory) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_EventSubCategory.Marshal(b, m, deterministic)
}
func (m *EventSubCategory) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EventSubCategory.Merge(m, src)
}
func (m *EventSubCategory) XXX_Size() int {
	return xxx_messageInfo_EventSubCategory.Size(m)
}
func (m *EventSubCategory) XXX_DiscardUnknown() {
	xxx_messageInfo_EventSubCategory.DiscardUnknown(m)
}

var xxx_messageInfo_EventSubCategory proto.InternalMessageInfo

//
// Identify the type of event
type EventType struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *EventType) Reset()         { *m = EventType{} }
func (m *EventType) String() string { return proto.CompactTextString(m) }
func (*EventType) ProtoMessage()    {}
func (*EventType) Descriptor() ([]byte, []int) {
	return fileDescriptor_e63e6c07044fd2c4, []int{18}
}

func (m *EventType) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_EventType.Unmarshal(m, b)
}
func (m *EventType) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_EventType.Marshal(b, m, deterministic)
}
func (m *EventType) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EventType.Merge(m, src)
}
func (m *EventType) XXX_Size() int {
	return xxx_messageInfo_EventType.Size(m)
}
func (m *EventType) XXX_DiscardUnknown() {
	xxx_messageInfo_EventType.DiscardUnknown(m)
}

var xxx_messageInfo_EventType proto.InternalMessageInfo

//
// Identify the functional category originating the event
type EventHeader struct {
	// 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 *timestamp.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           *timestamp.Timestamp `protobuf:"bytes,7,opt,name=reported_ts,json=reportedTs,proto3" json:"reported_ts,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

func (m *EventHeader) Reset()         { *m = EventHeader{} }
func (m *EventHeader) String() string { return proto.CompactTextString(m) }
func (*EventHeader) ProtoMessage()    {}
func (*EventHeader) Descriptor() ([]byte, []int) {
	return fileDescriptor_e63e6c07044fd2c4, []int{19}
}

func (m *EventHeader) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_EventHeader.Unmarshal(m, b)
}
func (m *EventHeader) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_EventHeader.Marshal(b, m, deterministic)
}
func (m *EventHeader) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EventHeader.Merge(m, src)
}
func (m *EventHeader) XXX_Size() int {
	return xxx_messageInfo_EventHeader.Size(m)
}
func (m *EventHeader) XXX_DiscardUnknown() {
	xxx_messageInfo_EventHeader.DiscardUnknown(m)
}

var xxx_messageInfo_EventHeader proto.InternalMessageInfo

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

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

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

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

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

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

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

//
// Event Structure
type Event struct {
	// 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"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *Event) Reset()         { *m = Event{} }
func (m *Event) String() string { return proto.CompactTextString(m) }
func (*Event) ProtoMessage()    {}
func (*Event) Descriptor() ([]byte, []int) {
	return fileDescriptor_e63e6c07044fd2c4, []int{20}
}

func (m *Event) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Event.Unmarshal(m, b)
}
func (m *Event) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Event.Marshal(b, m, deterministic)
}
func (m *Event) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Event.Merge(m, src)
}
func (m *Event) XXX_Size() int {
	return xxx_messageInfo_Event.Size(m)
}
func (m *Event) XXX_DiscardUnknown() {
	xxx_messageInfo_Event.DiscardUnknown(m)
}

var xxx_messageInfo_Event proto.InternalMessageInfo

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

type isEvent_EventType interface {
	isEvent_EventType()
}

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

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

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

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

type Event_RpcEvent struct {
	RpcEvent *RPCEvent `protobuf:"bytes,6,opt,name=rpc_event,json=rpcEvent,proto3,oneof"`
}

type Event_KpiEvent3 struct {
	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() {}

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

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

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

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

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

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

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

// XXX_OneofWrappers is for the internal use of the proto package.
func (*Event) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*Event_ConfigEvent)(nil),
		(*Event_KpiEvent)(nil),
		(*Event_KpiEvent2)(nil),
		(*Event_DeviceEvent)(nil),
		(*Event_RpcEvent)(nil),
		(*Event_KpiEvent3)(nil),
	}
}

func init() {
	proto.RegisterEnum("event.EventFilterRuleKey_EventFilterRuleType", EventFilterRuleKey_EventFilterRuleType_name, EventFilterRuleKey_EventFilterRuleType_value)
	proto.RegisterEnum("event.ConfigEventType_Types", ConfigEventType_Types_name, ConfigEventType_Types_value)
	proto.RegisterEnum("event.KpiEventType_Types", KpiEventType_Types_name, KpiEventType_Types_value)
	proto.RegisterEnum("event.EventCategory_Types", EventCategory_Types_name, EventCategory_Types_value)
	proto.RegisterEnum("event.EventSubCategory_Types", EventSubCategory_Types_name, EventSubCategory_Types_value)
	proto.RegisterEnum("event.EventType_Types", EventType_Types_name, EventType_Types_value)
	proto.RegisterType((*EventFilterRuleKey)(nil), "event.EventFilterRuleKey")
	proto.RegisterType((*EventFilterRule)(nil), "event.EventFilterRule")
	proto.RegisterType((*EventFilter)(nil), "event.EventFilter")
	proto.RegisterType((*EventFilters)(nil), "event.EventFilters")
	proto.RegisterType((*ConfigEventType)(nil), "event.ConfigEventType")
	proto.RegisterType((*ConfigEvent)(nil), "event.ConfigEvent")
	proto.RegisterType((*KpiEventType)(nil), "event.KpiEventType")
	proto.RegisterType((*MetricMetaData)(nil), "event.MetricMetaData")
	proto.RegisterMapType((map[string]string)(nil), "event.MetricMetaData.ContextEntry")
	proto.RegisterType((*MetricValuePairs)(nil), "event.MetricValuePairs")
	proto.RegisterMapType((map[string]float32)(nil), "event.MetricValuePairs.MetricsEntry")
	proto.RegisterType((*MetricInformation)(nil), "event.MetricInformation")
	proto.RegisterMapType((map[string]float32)(nil), "event.MetricInformation.MetricsEntry")
	proto.RegisterType((*MetricInformation64)(nil), "event.MetricInformation64")
	proto.RegisterMapType((map[string]uint64)(nil), "event.MetricInformation64.MetricsEntry")
	proto.RegisterType((*KpiEvent)(nil), "event.KpiEvent")
	proto.RegisterMapType((map[string]*MetricValuePairs)(nil), "event.KpiEvent.PrefixesEntry")
	proto.RegisterType((*KpiEvent2)(nil), "event.KpiEvent2")
	proto.RegisterType((*KpiEvent3)(nil), "event.KpiEvent3")
	proto.RegisterType((*DeviceEvent)(nil), "event.DeviceEvent")
	proto.RegisterMapType((map[string]string)(nil), "event.DeviceEvent.ContextEntry")
	proto.RegisterType((*RPCEvent)(nil), "event.RPCEvent")
	proto.RegisterMapType((map[string]string)(nil), "event.RPCEvent.ContextEntry")
	proto.RegisterType((*EventCategory)(nil), "event.EventCategory")
	proto.RegisterType((*EventSubCategory)(nil), "event.EventSubCategory")
	proto.RegisterType((*EventType)(nil), "event.EventType")
	proto.RegisterType((*EventHeader)(nil), "event.EventHeader")
	proto.RegisterType((*Event)(nil), "event.Event")
}

func init() { proto.RegisterFile("voltha_protos/events.proto", fileDescriptor_e63e6c07044fd2c4) }

var fileDescriptor_e63e6c07044fd2c4 = []byte{
	// 1493 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x57, 0xcd, 0x6e, 0xdb, 0x46,
	0x10, 0x16, 0xa9, 0xff, 0xa1, 0x6c, 0xd3, 0x9b, 0x26, 0x55, 0x94, 0x04, 0x71, 0x88, 0x16, 0x35,
	0x8c, 0x58, 0x6e, 0xe4, 0xd4, 0x6e, 0x7e, 0x90, 0x34, 0x51, 0x94, 0x98, 0x48, 0x2c, 0xa9, 0xb4,
	0x6c, 0xa0, 0xbd, 0x08, 0x34, 0xb9, 0x96, 0x09, 0x4b, 0x22, 0xc1, 0x5d, 0x09, 0xf1, 0xb9, 0x28,
	0x7a, 0xeb, 0x23, 0xb4, 0xf7, 0xbe, 0x46, 0x0f, 0x7d, 0x87, 0xa0, 0x6f, 0xd1, 0x53, 0x6f, 0xc5,
	0xfe, 0x50, 0x22, 0x69, 0xb9, 0x01, 0x92, 0xf6, 0x44, 0xee, 0xec, 0xcc, 0xce, 0x37, 0xdf, 0xec,
	0xce, 0xce, 0x42, 0x6d, 0xea, 0x0f, 0xe9, 0xa9, 0xdd, 0x0f, 0x42, 0x9f, 0xfa, 0x64, 0x0b, 0x4f,
	0xf1, 0x98, 0x92, 0x3a, 0x1f, 0xa1, 0x3c, 0x1f, 0xd5, 0x6e, 0x0e, 0x7c, 0x7f, 0x30, 0xc4, 0x5b,
	0x76, 0xe0, 0x6d, 0xd9, 0xe3, 0xb1, 0x4f, 0x6d, 0xea, 0xf9, 0x63, 0xa9, 0x54, 0xbb, 0x2d, 0x67,
	0xf9, 0xe8, 0x78, 0x72, 0xb2, 0x45, 0xbd, 0x11, 0x26, 0xd4, 0x1e, 0x05, 0x52, 0x21, 0xe5, 0xc1,
	0xf1, 0x47, 0x23, 0x7f, 0x2c, 0xe6, 0x8c, 0x5f, 0x14, 0x40, 0x2d, 0xe6, 0xe4, 0xa5, 0x37, 0xa4,
	0x38, 0xb4, 0x26, 0x43, 0xfc, 0x1a, 0x9f, 0x1b, 0x3f, 0x29, 0x70, 0x25, 0x25, 0xee, 0x9d, 0x07,
	0x18, 0x2d, 0x03, 0x9c, 0x70, 0x49, 0xdf, 0x1e, 0x0e, 0xf5, 0x0c, 0xaa, 0x40, 0xc9, 0xb1, 0x29,
	0x1e, 0xf8, 0xe1, 0xb9, 0xae, 0x20, 0x1d, 0x2a, 0x64, 0x72, 0xdc, 0x9f, 0x49, 0x54, 0x84, 0x60,
	0xf9, 0x2c, 0xf0, 0xfa, 0x3c, 0x8c, 0x3e, 0x3d, 0x0f, 0xb0, 0x9e, 0x45, 0x57, 0x61, 0xd5, 0xf1,
	0xc7, 0x27, 0xde, 0x20, 0x2e, 0xce, 0x31, 0xb1, 0x8b, 0xa7, 0x9e, 0x83, 0xe3, 0xe2, 0xbc, 0x71,
	0x0a, 0x2b, 0x29, 0x20, 0xe8, 0x29, 0x64, 0xcf, 0xf0, 0x79, 0x55, 0x59, 0x53, 0xd6, 0x97, 0x1b,
	0x9b, 0x75, 0xae, 0x5e, 0xbf, 0x18, 0x44, 0x7d, 0x41, 0x00, 0x16, 0xb3, 0x44, 0x9f, 0x40, 0x7e,
	0x6a, 0x0f, 0x27, 0xb8, 0xaa, 0xae, 0x29, 0xeb, 0x65, 0x4b, 0x0c, 0x8c, 0x5f, 0x15, 0xd0, 0x62,
	0x26, 0x68, 0x19, 0x54, 0xcf, 0xe5, 0x5e, 0xca, 0x96, 0xea, 0xb9, 0xe8, 0x1a, 0x14, 0xf0, 0xd8,
	0x3e, 0x1e, 0x0a, 0xb3, 0x92, 0x25, 0x47, 0xe8, 0x06, 0x94, 0x25, 0x70, 0xcf, 0xad, 0x66, 0xb9,
	0x7a, 0x49, 0x08, 0x4c, 0x17, 0xdd, 0x02, 0x98, 0x87, 0x53, 0xcd, 0xf1, 0xd9, 0x32, 0x97, 0x70,
	0x3e, 0xef, 0x42, 0x3e, 0x9c, 0x0c, 0x31, 0xa9, 0xe6, 0xd7, 0xb2, 0xeb, 0x5a, 0xe3, 0xda, 0xe2,
	0x60, 0x2c, 0xa1, 0x64, 0x3c, 0x86, 0x4a, 0x6c, 0x86, 0xa0, 0xbb, 0x50, 0x14, 0xd9, 0x20, 0x55,
	0x85, 0xdb, 0xa3, 0x05, 0xf6, 0x91, 0x8a, 0xf1, 0x08, 0x56, 0x9a, 0x9c, 0xf7, 0x56, 0xe4, 0xde,
	0x58, 0x87, 0x3c, 0xfb, 0x12, 0x54, 0x84, 0xac, 0xed, 0xba, 0x7a, 0x06, 0x01, 0x14, 0x42, 0x3c,
	0xf2, 0xa7, 0x58, 0x57, 0xd8, 0xff, 0x24, 0x70, 0x6d, 0x8a, 0x75, 0xd5, 0x18, 0x80, 0x16, 0x33,
	0x46, 0x5f, 0x42, 0x8e, 0x07, 0x24, 0x72, 0x70, 0x53, 0xba, 0x4d, 0x2d, 0x5f, 0xe7, 0x6b, 0x5b,
	0x5c, 0x13, 0x21, 0xc8, 0x9d, 0xda, 0xe4, 0x54, 0x52, 0xce, 0xff, 0x99, 0xcc, 0xb5, 0xa9, 0x2d,
	0x49, 0xe3, 0xff, 0xc6, 0x06, 0x54, 0x5e, 0x07, 0xde, 0x1c, 0x62, 0x2d, 0x82, 0x58, 0x86, 0x3c,
	0x19, 0x7a, 0x0e, 0xd6, 0x33, 0xa8, 0x00, 0x2a, 0x25, 0xba, 0x62, 0xfc, 0xa6, 0xc2, 0xf2, 0x3e,
	0xa6, 0xa1, 0xe7, 0xec, 0x63, 0x6a, 0xbf, 0xb0, 0xa9, 0xcd, 0x52, 0x4b, 0x3d, 0x3a, 0xc4, 0x32,
	0x6f, 0x62, 0xc0, 0x52, 0x49, 0x09, 0x77, 0xad, 0x58, 0x2a, 0x25, 0x68, 0x03, 0x56, 0x87, 0xfe,
	0xc0, 0x73, 0xec, 0x61, 0x3f, 0x9d, 0xba, 0x15, 0x39, 0xf1, 0x22, 0xca, 0xe0, 0x0d, 0x28, 0x13,
	0x1c, 0x7a, 0xf6, 0xb0, 0x3f, 0xf6, 0x65, 0x02, 0x4b, 0x42, 0xd0, 0xf6, 0x93, 0xb9, 0xcf, 0xa7,
	0x72, 0xff, 0x18, 0x8a, 0x8e, 0x3f, 0xa6, 0xf8, 0x2d, 0xad, 0x16, 0x78, 0x7a, 0x0c, 0xc9, 0x53,
	0x12, 0x33, 0xa3, 0x8d, 0x29, 0xb5, 0xc6, 0x34, 0x3c, 0xb7, 0x22, 0x13, 0x46, 0xce, 0x64, 0xe2,
	0xb9, 0xd5, 0xa2, 0x20, 0x87, 0xfd, 0xd7, 0x1e, 0x42, 0x25, 0xae, 0x8c, 0xf4, 0xf9, 0x49, 0x28,
	0xff, 0xcb, 0xd6, 0x7e, 0xa8, 0x7e, 0xad, 0x18, 0x3f, 0x2b, 0xa0, 0x0b, 0xc7, 0x47, 0x4c, 0xd6,
	0xb5, 0xbd, 0x90, 0xa0, 0x27, 0x50, 0x1c, 0x71, 0x59, 0xb4, 0x83, 0x3e, 0x4b, 0x40, 0x9c, 0x6b,
	0x4a, 0x01, 0x91, 0x20, 0xa5, 0x11, 0x03, 0x14, 0x9f, 0x78, 0x1f, 0x20, 0x35, 0x0e, 0xe8, 0x77,
	0x05, 0x56, 0x85, 0xb1, 0x39, 0x3e, 0xf1, 0xc3, 0x11, 0x2f, 0x6a, 0xe8, 0x1e, 0x94, 0x46, 0x98,
	0xda, 0x7c, 0x5f, 0xb0, 0x65, 0xb4, 0xc6, 0xd5, 0x85, 0xac, 0x59, 0x33, 0x35, 0xf4, 0x74, 0x1e,
	0x84, 0xca, 0x83, 0xf8, 0x3c, 0x61, 0x11, 0x5b, 0xfd, 0x7f, 0x88, 0xe2, 0x0f, 0x05, 0xae, 0x5c,
	0xf0, 0xb3, 0x73, 0xff, 0x43, 0xe2, 0x78, 0x96, 0x8e, 0xe3, 0x8b, 0xcb, 0xe2, 0xd8, 0xb9, 0xff,
	0xdf, 0x44, 0x92, 0x8b, 0x47, 0xf2, 0x4e, 0x81, 0x52, 0x74, 0xf4, 0xd0, 0x66, 0xe2, 0x80, 0x5f,
	0x97, 0x40, 0xe2, 0x27, 0x33, 0x71, 0xba, 0xe7, 0x07, 0x4c, 0xe5, 0x07, 0xec, 0x01, 0x94, 0x82,
	0x10, 0x9f, 0x78, 0x6f, 0x31, 0xa9, 0x66, 0x79, 0x2c, 0xb7, 0x52, 0x4b, 0xd4, 0xbb, 0x72, 0x5e,
	0x44, 0x30, 0x53, 0xaf, 0xf5, 0x60, 0x29, 0x31, 0xb5, 0x20, 0x86, 0xcd, 0x78, 0x0c, 0x5a, 0xe3,
	0xd3, 0x4b, 0xf6, 0x6c, 0x3c, 0xb8, 0x1f, 0x14, 0x28, 0x47, 0xae, 0x1b, 0x1f, 0x1e, 0x9d, 0x28,
	0x1f, 0xbb, 0x00, 0xbc, 0x14, 0xf5, 0x65, 0xf5, 0x62, 0xf1, 0x55, 0x2f, 0xcb, 0x95, 0x55, 0xe6,
	0xba, 0x2c, 0xd7, 0xc6, 0x8f, 0x31, 0x14, 0xdb, 0x1f, 0x8b, 0xe2, 0xc1, 0x02, 0x14, 0xb5, 0xcb,
	0x77, 0x4c, 0x1c, 0xc7, 0x5f, 0x0a, 0x68, 0xa2, 0xc0, 0x89, 0x6c, 0xdf, 0x06, 0x2d, 0xc4, 0xc4,
	0x9f, 0x84, 0xa2, 0x90, 0x09, 0xaa, 0x21, 0x12, 0x99, 0x2e, 0x2b, 0x98, 0x89, 0xcb, 0x79, 0x6c,
	0x8f, 0xa2, 0x12, 0xb3, 0xe2, 0xce, 0x17, 0x6a, 0xdb, 0x23, 0x8c, 0xd6, 0x40, 0x73, 0x31, 0x71,
	0x42, 0x2f, 0x60, 0x8e, 0x65, 0x59, 0x8d, 0x8b, 0xd0, 0x83, 0x79, 0x61, 0xcc, 0x71, 0xd8, 0xb7,
	0x25, 0xec, 0x18, 0xa6, 0xc5, 0x55, 0xf1, 0xa3, 0x2a, 0xe0, 0x3b, 0x15, 0x4a, 0x56, 0xb7, 0x29,
	0x42, 0xd6, 0x21, 0x1b, 0x06, 0x4e, 0x64, 0x18, 0x06, 0x0e, 0xba, 0x03, 0x15, 0x3f, 0xc0, 0x21,
	0xa7, 0x8b, 0xb1, 0x20, 0xec, 0xb5, 0x99, 0xcc, 0x74, 0x51, 0x15, 0x8a, 0x04, 0x87, 0x0c, 0xa3,
	0x0c, 0x2b, 0x1a, 0xa2, 0xeb, 0x50, 0x22, 0xd4, 0x76, 0xce, 0x98, 0x61, 0x4e, 0x4e, 0xb1, 0xb1,
	0xe9, 0xa6, 0xc9, 0xcd, 0x5f, 0x20, 0x37, 0x45, 0x58, 0xe1, 0x22, 0x61, 0x3b, 0x73, 0xc2, 0x8a,
	0x9c, 0xb0, 0xe8, 0xc6, 0x8d, 0xc2, 0xb9, 0xe4, 0x0e, 0xd9, 0x84, 0x02, 0xa1, 0x36, 0x9d, 0x90,
	0x6a, 0x49, 0x96, 0x20, 0xd9, 0xfc, 0x75, 0xa2, 0xa0, 0x2c, 0x4c, 0x02, 0x4b, 0x2a, 0x7d, 0x14,
	0xb9, 0x53, 0x58, 0xe2, 0x48, 0x9a, 0xb2, 0xf9, 0x33, 0x70, 0x74, 0x71, 0xaf, 0xc2, 0x52, 0xb3,
	0xb3, 0xbf, 0x7f, 0xd8, 0x36, 0x9b, 0xcf, 0x7a, 0x66, 0xa7, 0xad, 0x67, 0xd0, 0x0a, 0x68, 0xad,
	0xf6, 0x91, 0x69, 0x75, 0xda, 0xfb, 0xad, 0x76, 0x4f, 0x57, 0xd0, 0x12, 0x94, 0x5b, 0xdf, 0x1e,
	0x9a, 0x5d, 0x3e, 0x54, 0x91, 0x06, 0xc5, 0x83, 0x96, 0x75, 0x64, 0x36, 0x5b, 0x7a, 0x96, 0xf5,
	0x9c, 0x5d, 0xab, 0xd3, 0x6c, 0x1d, 0x1c, 0x98, 0xed, 0x57, 0x7a, 0x8e, 0xf5, 0x9c, 0x07, 0xad,
	0xe6, 0xa1, 0x65, 0xf6, 0xbe, 0xd3, 0xf3, 0x86, 0x05, 0x3a, 0xf7, 0x7b, 0x30, 0x39, 0x9e, 0xb9,
	0x7e, 0x12, 0x6b, 0x6b, 0xba, 0xdc, 0x61, 0x11, 0xb2, 0x9d, 0x37, 0xcc, 0x11, 0xfb, 0xe1, 0x2e,
	0xf8, 0xcf, 0xa1, 0x9e, 0x65, 0x3f, 0xed, 0xb6, 0xa9, 0xe7, 0x50, 0x09, 0x72, 0xed, 0x4e, 0xbb,
	0xa5, 0xe7, 0x8d, 0x29, 0x94, 0xe7, 0x0d, 0x88, 0x17, 0x2d, 0xa6, 0x43, 0xa5, 0xd9, 0x69, 0xbf,
	0x34, 0x5f, 0xf5, 0x5b, 0x47, 0x0c, 0x66, 0x86, 0xa1, 0x7e, 0xdd, 0x35, 0xe5, 0x50, 0x61, 0x40,
	0x67, 0xc3, 0x86, 0xae, 0x32, 0x83, 0x17, 0x2d, 0x16, 0x84, 0xd4, 0xc8, 0x32, 0x03, 0xab, 0xdb,
	0x94, 0xc3, 0x5c, 0xc2, 0x60, 0x5b, 0xcf, 0x1b, 0x7f, 0xaa, 0xb2, 0x03, 0xdd, 0xc3, 0xb6, 0xbb,
	0xa0, 0x03, 0xdd, 0x99, 0x77, 0xdb, 0x3c, 0x01, 0xcb, 0xb3, 0xf3, 0x9e, 0xa0, 0x5e, 0x56, 0x8d,
	0x99, 0x2e, 0xfa, 0x26, 0xd9, 0x97, 0xf3, 0xbd, 0xbb, 0x3c, 0xab, 0xc8, 0x69, 0xfa, 0xa4, 0xb9,
	0x46, 0xe6, 0x22, 0xb4, 0x21, 0x4b, 0x55, 0x8e, 0x5b, 0x26, 0xda, 0xd4, 0x0b, 0x75, 0xea, 0x0e,
	0x54, 0xd8, 0xb7, 0x3f, 0xc5, 0x21, 0x61, 0xfb, 0x59, 0x6c, 0x78, 0x8d, 0xc9, 0x8e, 0x84, 0x08,
	0xed, 0x42, 0x39, 0xb4, 0x3d, 0x82, 0xdd, 0x3e, 0x25, 0x7c, 0xbf, 0xb3, 0xca, 0x25, 0x9e, 0x31,
	0xf5, 0xe8, 0x19, 0x53, 0xef, 0x45, 0xcf, 0x18, 0xab, 0x24, 0x94, 0x7b, 0x04, 0x3d, 0x62, 0x67,
	0x29, 0xf0, 0x43, 0x2a, 0x4c, 0x8b, 0xef, 0x35, 0x85, 0x48, 0xbd, 0x47, 0x8c, 0xbf, 0x55, 0xc8,
	0x8b, 0xc3, 0xbf, 0x01, 0x85, 0x53, 0x4e, 0xb1, 0xbc, 0x9a, 0x13, 0x7d, 0xb3, 0x20, 0xdf, 0x92,
	0x1a, 0x68, 0x17, 0x2a, 0xf1, 0xe7, 0x8a, 0xbc, 0x73, 0xd0, 0xc5, 0x96, 0x77, 0x2f, 0x63, 0x69,
	0x4e, 0xac, 0x47, 0xae, 0x43, 0x79, 0xf6, 0xf6, 0xe1, 0x94, 0x6b, 0x8d, 0x95, 0x54, 0x8d, 0xdf,
	0xcb, 0x58, 0xa5, 0xb3, 0xe8, 0xca, 0xbd, 0x07, 0x30, 0xd3, 0x6f, 0x70, 0xa6, 0xb5, 0x86, 0x9e,
	0x32, 0x68, 0xec, 0x65, 0xac, 0xf2, 0xd9, 0xec, 0x1e, 0xdb, 0x85, 0x4a, 0xbc, 0x2c, 0x73, 0xaa,
	0xe7, 0xd8, 0x62, 0xd5, 0x94, 0x61, 0x8b, 0xd5, 0x69, 0x86, 0x2d, 0x0c, 0x1c, 0x69, 0x55, 0x48,
	0x60, 0x8b, 0x4a, 0x0a, 0xc3, 0x16, 0x06, 0xce, 0x45, 0x6c, 0xdb, 0x92, 0xf6, 0x34, 0xb6, 0xed,
	0x38, 0xb6, 0xed, 0xe7, 0x95, 0xf8, 0xcb, 0xe7, 0xf9, 0x1b, 0xa8, 0xf9, 0xe1, 0xa0, 0xee, 0x07,
	0x78, 0xec, 0xf8, 0xa1, 0x5b, 0x17, 0x4f, 0x52, 0xb1, 0x02, 0xf9, 0xbe, 0x3e, 0xf0, 0xe8, 0xe9,
	0xe4, 0x98, 0x55, 0xa7, 0xad, 0x48, 0x65, 0x4b, 0xa8, 0x6c, 0xca, 0x57, 0xeb, 0xf4, 0xab, 0xad,
	0x81, 0x2f, 0x65, 0xc7, 0x05, 0x2e, 0xdc, 0xfe, 0x27, 0x00, 0x00, 0xff, 0xff, 0xe7, 0xa1, 0x28,
	0xad, 0x3c, 0x0f, 0x00, 0x00,
}
