go/dmi/hw_events_mgmt_service.pb.go

// Code generated by protoc-gen-go. DO NOT EDIT.
// source: dmi/hw_events_mgmt_service.proto

package dmi

import (
	context "context"
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	empty "github.com/golang/protobuf/ptypes/empty"
	timestamp "github.com/golang/protobuf/ptypes/timestamp"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	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 EventIds int32

const (
	EventIds_EVENT_NAME_UNDEFINED EventIds = 0
	// Events from the Transceivers
	EventIds_EVENT_TRANSCEIVER_PLUG_OUT                              EventIds = 100
	EventIds_EVENT_TRANSCEIVER_PLUG_IN                               EventIds = 101
	EventIds_EVENT_TRANSCEIVER_VOLTAGE_ABOVE_THRESHOLD               EventIds = 102
	EventIds_EVENT_TRANSCEIVER_VOLTAGE_BELOW_THRESHOLD               EventIds = 103
	EventIds_EVENT_TRANSCEIVER_TEMPERATURE_ABOVE_THRESHOLD           EventIds = 104
	EventIds_EVENT_TRANSCEIVER_TEMPERATURE_BELOW_THRESHOLD           EventIds = 105
	EventIds_EVENT_TRANSCEIVER_CURRENT_ABOVE_THRESHOLD               EventIds = 106
	EventIds_EVENT_TRANSCEIVER_CURRENT_BELOW_THRESHOLD               EventIds = 107
	EventIds_EVENT_TRANSCEIVER_RX_POWER_ABOVE_THRESHOLD              EventIds = 108
	EventIds_EVENT_TRANSCEIVER_RX_POWER_BELOW_THRESHOLD              EventIds = 109
	EventIds_EVENT_TRANSCEIVER_TX_POWER_ABOVE_THRESHOLD              EventIds = 110
	EventIds_EVENT_TRANSCEIVER_TX_POWER_BELOW_THRESHOLD              EventIds = 111
	EventIds_EVENT_TRANSCEIVER_FAILURE                               EventIds = 112
	EventIds_EVENT_TRANSCEIVER_VOLTAGE_ABOVE_THRESHOLD_RECOVERED     EventIds = 113
	EventIds_EVENT_TRANSCEIVER_VOLTAGE_BELOW_THRESHOLD_RECOVERED     EventIds = 114
	EventIds_EVENT_TRANSCEIVER_TEMPERATURE_ABOVE_THRESHOLD_RECOVERED EventIds = 115
	EventIds_EVENT_TRANSCEIVER_TEMPERATURE_BELOW_THRESHOLD_RECOVERED EventIds = 116
	EventIds_EVENT_TRANSCEIVER_CURRENT_ABOVE_THRESHOLD_RECOVERED     EventIds = 117
	EventIds_EVENT_TRANSCEIVER_CURRENT_BELOW_THRESHOLD_RECOVERED     EventIds = 118
	EventIds_EVENT_TRANSCEIVER_RX_POWER_ABOVE_THRESHOLD_RECOVERED    EventIds = 119
	EventIds_EVENT_TRANSCEIVER_RX_POWER_BELOW_THRESHOLD_RECOVERED    EventIds = 120
	EventIds_EVENT_TRANSCEIVER_TX_POWER_ABOVE_THRESHOLD_RECOVERED    EventIds = 121
	EventIds_EVENT_TRANSCEIVER_TX_POWER_BELOW_THRESHOLD_RECOVERED    EventIds = 122
	EventIds_EVENT_TRANSCEIVER_FAILURE_RECOVERED                     EventIds = 123
	// Events from the PSU
	EventIds_EVENT_PSU_PLUG_OUT          EventIds = 200
	EventIds_EVENT_PSU_PLUG_IN           EventIds = 201
	EventIds_EVENT_PSU_FAILURE           EventIds = 202
	EventIds_EVENT_PSU_FAILURE_RECOVERED EventIds = 203
	// Events for the Fans
	EventIds_EVENT_FAN_FAILURE           EventIds = 300
	EventIds_EVENT_FAN_PLUG_OUT          EventIds = 301
	EventIds_EVENT_FAN_PLUG_IN           EventIds = 302
	EventIds_EVENT_FAN_FAILURE_RECOVERED EventIds = 303
	// Events for the CPUs
	EventIds_EVENT_CPU_TEMPERATURE_ABOVE_CRITICAL           EventIds = 400
	EventIds_EVENT_CPU_TEMPERATURE_ABOVE_FATAL              EventIds = 401
	EventIds_EVENT_CPU_TEMPERATURE_ABOVE_CRITICAL_RECOVERED EventIds = 402
	EventIds_EVENT_CPU_TEMPERATURE_ABOVE_FATAL_RECOVERED    EventIds = 403
	// Events for the complete HW Device
	EventIds_EVENT_HW_DEVICE_RESET                                EventIds = 500
	EventIds_EVENT_HW_DEVICE_TEMPERATURE_ABOVE_CRITICAL           EventIds = 501
	EventIds_EVENT_HW_DEVICE_TEMPERATURE_ABOVE_FATAL              EventIds = 502
	EventIds_EVENT_HW_DEVICE_TEMPERATURE_ABOVE_CRITICAL_RECOVERED EventIds = 503
	EventIds_EVENT_HW_DEVICE_TEMPERATURE_ABOVE_FATAL_RECOVERED    EventIds = 504
	EventIds_EVENT_HW_DEVICE_REBOOT                               EventIds = 505
)

var EventIds_name = map[int32]string{
	0:   "EVENT_NAME_UNDEFINED",
	100: "EVENT_TRANSCEIVER_PLUG_OUT",
	101: "EVENT_TRANSCEIVER_PLUG_IN",
	102: "EVENT_TRANSCEIVER_VOLTAGE_ABOVE_THRESHOLD",
	103: "EVENT_TRANSCEIVER_VOLTAGE_BELOW_THRESHOLD",
	104: "EVENT_TRANSCEIVER_TEMPERATURE_ABOVE_THRESHOLD",
	105: "EVENT_TRANSCEIVER_TEMPERATURE_BELOW_THRESHOLD",
	106: "EVENT_TRANSCEIVER_CURRENT_ABOVE_THRESHOLD",
	107: "EVENT_TRANSCEIVER_CURRENT_BELOW_THRESHOLD",
	108: "EVENT_TRANSCEIVER_RX_POWER_ABOVE_THRESHOLD",
	109: "EVENT_TRANSCEIVER_RX_POWER_BELOW_THRESHOLD",
	110: "EVENT_TRANSCEIVER_TX_POWER_ABOVE_THRESHOLD",
	111: "EVENT_TRANSCEIVER_TX_POWER_BELOW_THRESHOLD",
	112: "EVENT_TRANSCEIVER_FAILURE",
	113: "EVENT_TRANSCEIVER_VOLTAGE_ABOVE_THRESHOLD_RECOVERED",
	114: "EVENT_TRANSCEIVER_VOLTAGE_BELOW_THRESHOLD_RECOVERED",
	115: "EVENT_TRANSCEIVER_TEMPERATURE_ABOVE_THRESHOLD_RECOVERED",
	116: "EVENT_TRANSCEIVER_TEMPERATURE_BELOW_THRESHOLD_RECOVERED",
	117: "EVENT_TRANSCEIVER_CURRENT_ABOVE_THRESHOLD_RECOVERED",
	118: "EVENT_TRANSCEIVER_CURRENT_BELOW_THRESHOLD_RECOVERED",
	119: "EVENT_TRANSCEIVER_RX_POWER_ABOVE_THRESHOLD_RECOVERED",
	120: "EVENT_TRANSCEIVER_RX_POWER_BELOW_THRESHOLD_RECOVERED",
	121: "EVENT_TRANSCEIVER_TX_POWER_ABOVE_THRESHOLD_RECOVERED",
	122: "EVENT_TRANSCEIVER_TX_POWER_BELOW_THRESHOLD_RECOVERED",
	123: "EVENT_TRANSCEIVER_FAILURE_RECOVERED",
	200: "EVENT_PSU_PLUG_OUT",
	201: "EVENT_PSU_PLUG_IN",
	202: "EVENT_PSU_FAILURE",
	203: "EVENT_PSU_FAILURE_RECOVERED",
	300: "EVENT_FAN_FAILURE",
	301: "EVENT_FAN_PLUG_OUT",
	302: "EVENT_FAN_PLUG_IN",
	303: "EVENT_FAN_FAILURE_RECOVERED",
	400: "EVENT_CPU_TEMPERATURE_ABOVE_CRITICAL",
	401: "EVENT_CPU_TEMPERATURE_ABOVE_FATAL",
	402: "EVENT_CPU_TEMPERATURE_ABOVE_CRITICAL_RECOVERED",
	403: "EVENT_CPU_TEMPERATURE_ABOVE_FATAL_RECOVERED",
	500: "EVENT_HW_DEVICE_RESET",
	501: "EVENT_HW_DEVICE_TEMPERATURE_ABOVE_CRITICAL",
	502: "EVENT_HW_DEVICE_TEMPERATURE_ABOVE_FATAL",
	503: "EVENT_HW_DEVICE_TEMPERATURE_ABOVE_CRITICAL_RECOVERED",
	504: "EVENT_HW_DEVICE_TEMPERATURE_ABOVE_FATAL_RECOVERED",
	505: "EVENT_HW_DEVICE_REBOOT",
}

var EventIds_value = map[string]int32{
	"EVENT_NAME_UNDEFINED":                                    0,
	"EVENT_TRANSCEIVER_PLUG_OUT":                              100,
	"EVENT_TRANSCEIVER_PLUG_IN":                               101,
	"EVENT_TRANSCEIVER_VOLTAGE_ABOVE_THRESHOLD":               102,
	"EVENT_TRANSCEIVER_VOLTAGE_BELOW_THRESHOLD":               103,
	"EVENT_TRANSCEIVER_TEMPERATURE_ABOVE_THRESHOLD":           104,
	"EVENT_TRANSCEIVER_TEMPERATURE_BELOW_THRESHOLD":           105,
	"EVENT_TRANSCEIVER_CURRENT_ABOVE_THRESHOLD":               106,
	"EVENT_TRANSCEIVER_CURRENT_BELOW_THRESHOLD":               107,
	"EVENT_TRANSCEIVER_RX_POWER_ABOVE_THRESHOLD":              108,
	"EVENT_TRANSCEIVER_RX_POWER_BELOW_THRESHOLD":              109,
	"EVENT_TRANSCEIVER_TX_POWER_ABOVE_THRESHOLD":              110,
	"EVENT_TRANSCEIVER_TX_POWER_BELOW_THRESHOLD":              111,
	"EVENT_TRANSCEIVER_FAILURE":                               112,
	"EVENT_TRANSCEIVER_VOLTAGE_ABOVE_THRESHOLD_RECOVERED":     113,
	"EVENT_TRANSCEIVER_VOLTAGE_BELOW_THRESHOLD_RECOVERED":     114,
	"EVENT_TRANSCEIVER_TEMPERATURE_ABOVE_THRESHOLD_RECOVERED": 115,
	"EVENT_TRANSCEIVER_TEMPERATURE_BELOW_THRESHOLD_RECOVERED": 116,
	"EVENT_TRANSCEIVER_CURRENT_ABOVE_THRESHOLD_RECOVERED":     117,
	"EVENT_TRANSCEIVER_CURRENT_BELOW_THRESHOLD_RECOVERED":     118,
	"EVENT_TRANSCEIVER_RX_POWER_ABOVE_THRESHOLD_RECOVERED":    119,
	"EVENT_TRANSCEIVER_RX_POWER_BELOW_THRESHOLD_RECOVERED":    120,
	"EVENT_TRANSCEIVER_TX_POWER_ABOVE_THRESHOLD_RECOVERED":    121,
	"EVENT_TRANSCEIVER_TX_POWER_BELOW_THRESHOLD_RECOVERED":    122,
	"EVENT_TRANSCEIVER_FAILURE_RECOVERED":                     123,
	"EVENT_PSU_PLUG_OUT":                                      200,
	"EVENT_PSU_PLUG_IN":                                       201,
	"EVENT_PSU_FAILURE":                                       202,
	"EVENT_PSU_FAILURE_RECOVERED":                             203,
	"EVENT_FAN_FAILURE":                                       300,
	"EVENT_FAN_PLUG_OUT":                                      301,
	"EVENT_FAN_PLUG_IN":                                       302,
	"EVENT_FAN_FAILURE_RECOVERED":                             303,
	"EVENT_CPU_TEMPERATURE_ABOVE_CRITICAL":                    400,
	"EVENT_CPU_TEMPERATURE_ABOVE_FATAL":                       401,
	"EVENT_CPU_TEMPERATURE_ABOVE_CRITICAL_RECOVERED":          402,
	"EVENT_CPU_TEMPERATURE_ABOVE_FATAL_RECOVERED":             403,
	"EVENT_HW_DEVICE_RESET":                                   500,
	"EVENT_HW_DEVICE_TEMPERATURE_ABOVE_CRITICAL":              501,
	"EVENT_HW_DEVICE_TEMPERATURE_ABOVE_FATAL":                 502,
	"EVENT_HW_DEVICE_TEMPERATURE_ABOVE_CRITICAL_RECOVERED":    503,
	"EVENT_HW_DEVICE_TEMPERATURE_ABOVE_FATAL_RECOVERED":       504,
	"EVENT_HW_DEVICE_REBOOT":                                  505,
}

func (x EventIds) String() string {
	return proto.EnumName(EventIds_name, int32(x))
}

func (EventIds) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8962d785556e9979, []int{0}
}

type ListEventsResponse_Reason int32

const (
	ListEventsResponse_UNDEFINED_REASON   ListEventsResponse_Reason = 0
	ListEventsResponse_UNKNOWN_DEVICE     ListEventsResponse_Reason = 1
	ListEventsResponse_INTERNAL_ERROR     ListEventsResponse_Reason = 2
	ListEventsResponse_DEVICE_UNREACHABLE ListEventsResponse_Reason = 3
)

var ListEventsResponse_Reason_name = map[int32]string{
	0: "UNDEFINED_REASON",
	1: "UNKNOWN_DEVICE",
	2: "INTERNAL_ERROR",
	3: "DEVICE_UNREACHABLE",
}

var ListEventsResponse_Reason_value = map[string]int32{
	"UNDEFINED_REASON":   0,
	"UNKNOWN_DEVICE":     1,
	"INTERNAL_ERROR":     2,
	"DEVICE_UNREACHABLE": 3,
}

func (x ListEventsResponse_Reason) String() string {
	return proto.EnumName(ListEventsResponse_Reason_name, int32(x))
}

func (ListEventsResponse_Reason) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8962d785556e9979, []int{6, 0}
}

type EventsConfigurationResponse_Reason int32

const (
	EventsConfigurationResponse_UNDEFINED_REASON   EventsConfigurationResponse_Reason = 0
	EventsConfigurationResponse_UNKNOWN_DEVICE     EventsConfigurationResponse_Reason = 1
	EventsConfigurationResponse_INTERNAL_ERROR     EventsConfigurationResponse_Reason = 2
	EventsConfigurationResponse_INVALID_CONFIG     EventsConfigurationResponse_Reason = 3
	EventsConfigurationResponse_DEVICE_UNREACHABLE EventsConfigurationResponse_Reason = 4
)

var EventsConfigurationResponse_Reason_name = map[int32]string{
	0: "UNDEFINED_REASON",
	1: "UNKNOWN_DEVICE",
	2: "INTERNAL_ERROR",
	3: "INVALID_CONFIG",
	4: "DEVICE_UNREACHABLE",
}

var EventsConfigurationResponse_Reason_value = map[string]int32{
	"UNDEFINED_REASON":   0,
	"UNKNOWN_DEVICE":     1,
	"INTERNAL_ERROR":     2,
	"INVALID_CONFIG":     3,
	"DEVICE_UNREACHABLE": 4,
}

func (x EventsConfigurationResponse_Reason) String() string {
	return proto.EnumName(EventsConfigurationResponse_Reason_name, int32(x))
}

func (EventsConfigurationResponse_Reason) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8962d785556e9979, []int{8, 0}
}

type ValueType struct {
	// Types that are valid to be assigned to Val:
	//	*ValueType_IntVal
	//	*ValueType_UintVal
	//	*ValueType_FloatVal
	Val                  isValueType_Val `protobuf_oneof:"val"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

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

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

var xxx_messageInfo_ValueType proto.InternalMessageInfo

type isValueType_Val interface {
	isValueType_Val()
}

type ValueType_IntVal struct {
	IntVal int64 `protobuf:"varint,1,opt,name=int_val,json=intVal,proto3,oneof"`
}

type ValueType_UintVal struct {
	UintVal uint64 `protobuf:"varint,2,opt,name=uint_val,json=uintVal,proto3,oneof"`
}

type ValueType_FloatVal struct {
	FloatVal float32 `protobuf:"fixed32,3,opt,name=float_val,json=floatVal,proto3,oneof"`
}

func (*ValueType_IntVal) isValueType_Val() {}

func (*ValueType_UintVal) isValueType_Val() {}

func (*ValueType_FloatVal) isValueType_Val() {}

func (m *ValueType) GetVal() isValueType_Val {
	if m != nil {
		return m.Val
	}
	return nil
}

func (m *ValueType) GetIntVal() int64 {
	if x, ok := m.GetVal().(*ValueType_IntVal); ok {
		return x.IntVal
	}
	return 0
}

func (m *ValueType) GetUintVal() uint64 {
	if x, ok := m.GetVal().(*ValueType_UintVal); ok {
		return x.UintVal
	}
	return 0
}

func (m *ValueType) GetFloatVal() float32 {
	if x, ok := m.GetVal().(*ValueType_FloatVal); ok {
		return x.FloatVal
	}
	return 0
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*ValueType) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*ValueType_IntVal)(nil),
		(*ValueType_UintVal)(nil),
		(*ValueType_FloatVal)(nil),
	}
}

type WaterMarks struct {
	High                 *ValueType `protobuf:"bytes,1,opt,name=high,proto3" json:"high,omitempty"`
	Low                  *ValueType `protobuf:"bytes,2,opt,name=low,proto3" json:"low,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

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

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

var xxx_messageInfo_WaterMarks proto.InternalMessageInfo

func (m *WaterMarks) GetHigh() *ValueType {
	if m != nil {
		return m.High
	}
	return nil
}

func (m *WaterMarks) GetLow() *ValueType {
	if m != nil {
		return m.Low
	}
	return nil
}

type Thresholds struct {
	// Types that are valid to be assigned to Threshold:
	//	*Thresholds_Upper
	//	*Thresholds_Lower
	Threshold            isThresholds_Threshold `protobuf_oneof:"threshold"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

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

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

var xxx_messageInfo_Thresholds proto.InternalMessageInfo

type isThresholds_Threshold interface {
	isThresholds_Threshold()
}

type Thresholds_Upper struct {
	Upper *WaterMarks `protobuf:"bytes,1,opt,name=upper,proto3,oneof"`
}

type Thresholds_Lower struct {
	Lower *WaterMarks `protobuf:"bytes,2,opt,name=lower,proto3,oneof"`
}

func (*Thresholds_Upper) isThresholds_Threshold() {}

func (*Thresholds_Lower) isThresholds_Threshold() {}

func (m *Thresholds) GetThreshold() isThresholds_Threshold {
	if m != nil {
		return m.Threshold
	}
	return nil
}

func (m *Thresholds) GetUpper() *WaterMarks {
	if x, ok := m.GetThreshold().(*Thresholds_Upper); ok {
		return x.Upper
	}
	return nil
}

func (m *Thresholds) GetLower() *WaterMarks {
	if x, ok := m.GetThreshold().(*Thresholds_Lower); ok {
		return x.Lower
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*Thresholds) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*Thresholds_Upper)(nil),
		(*Thresholds_Lower)(nil),
	}
}

type ThresholdInformation struct {
	ObservedValue        *ValueType  `protobuf:"bytes,1,opt,name=observed_value,json=observedValue,proto3" json:"observed_value,omitempty"`
	Thresholds           *Thresholds `protobuf:"bytes,2,opt,name=thresholds,proto3" json:"thresholds,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

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

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

var xxx_messageInfo_ThresholdInformation proto.InternalMessageInfo

func (m *ThresholdInformation) GetObservedValue() *ValueType {
	if m != nil {
		return m.ObservedValue
	}
	return nil
}

func (m *ThresholdInformation) GetThresholds() *Thresholds {
	if m != nil {
		return m.Thresholds
	}
	return nil
}

type EventCfg struct {
	EventId      EventIds `protobuf:"varint,1,opt,name=event_id,json=eventId,proto3,enum=dmi.EventIds" json:"event_id,omitempty"`
	IsConfigured bool     `protobuf:"varint,2,opt,name=is_configured,json=isConfigured,proto3" json:"is_configured,omitempty"`
	// Optional threshold values, applicable only for some specific events
	Thresholds           *Thresholds `protobuf:"bytes,3,opt,name=thresholds,proto3" json:"thresholds,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

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

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

var xxx_messageInfo_EventCfg proto.InternalMessageInfo

func (m *EventCfg) GetEventId() EventIds {
	if m != nil {
		return m.EventId
	}
	return EventIds_EVENT_NAME_UNDEFINED
}

func (m *EventCfg) GetIsConfigured() bool {
	if m != nil {
		return m.IsConfigured
	}
	return false
}

func (m *EventCfg) GetThresholds() *Thresholds {
	if m != nil {
		return m.Thresholds
	}
	return nil
}

type EventsCfg struct {
	Items                []*EventCfg `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

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

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

var xxx_messageInfo_EventsCfg proto.InternalMessageInfo

func (m *EventsCfg) GetItems() []*EventCfg {
	if m != nil {
		return m.Items
	}
	return nil
}

type ListEventsResponse struct {
	Status               Status                    `protobuf:"varint,1,opt,name=status,proto3,enum=dmi.Status" json:"status,omitempty"`
	Reason               ListEventsResponse_Reason `protobuf:"varint,2,opt,name=reason,proto3,enum=dmi.ListEventsResponse_Reason" json:"reason,omitempty"`
	Events               *EventsCfg                `protobuf:"bytes,3,opt,name=events,proto3" json:"events,omitempty"`
	ReasonDetail         string                    `protobuf:"bytes,4,opt,name=reason_detail,json=reasonDetail,proto3" json:"reason_detail,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                  `json:"-"`
	XXX_unrecognized     []byte                    `json:"-"`
	XXX_sizecache        int32                     `json:"-"`
}

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

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

var xxx_messageInfo_ListEventsResponse proto.InternalMessageInfo

func (m *ListEventsResponse) GetStatus() Status {
	if m != nil {
		return m.Status
	}
	return Status_UNDEFINED_STATUS
}

func (m *ListEventsResponse) GetReason() ListEventsResponse_Reason {
	if m != nil {
		return m.Reason
	}
	return ListEventsResponse_UNDEFINED_REASON
}

func (m *ListEventsResponse) GetEvents() *EventsCfg {
	if m != nil {
		return m.Events
	}
	return nil
}

func (m *ListEventsResponse) GetReasonDetail() string {
	if m != nil {
		return m.ReasonDetail
	}
	return ""
}

type EventsConfigurationRequest struct {
	DeviceUuid *Uuid `protobuf:"bytes,1,opt,name=device_uuid,json=deviceUuid,proto3" json:"device_uuid,omitempty"`
	// Types that are valid to be assigned to Operation:
	//	*EventsConfigurationRequest_Changes
	//	*EventsConfigurationRequest_ResetToDefault
	Operation            isEventsConfigurationRequest_Operation `protobuf_oneof:"operation"`
	XXX_NoUnkeyedLiteral struct{}                               `json:"-"`
	XXX_unrecognized     []byte                                 `json:"-"`
	XXX_sizecache        int32                                  `json:"-"`
}

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

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

var xxx_messageInfo_EventsConfigurationRequest proto.InternalMessageInfo

func (m *EventsConfigurationRequest) GetDeviceUuid() *Uuid {
	if m != nil {
		return m.DeviceUuid
	}
	return nil
}

type isEventsConfigurationRequest_Operation interface {
	isEventsConfigurationRequest_Operation()
}

type EventsConfigurationRequest_Changes struct {
	Changes *EventsCfg `protobuf:"bytes,2,opt,name=changes,proto3,oneof"`
}

type EventsConfigurationRequest_ResetToDefault struct {
	ResetToDefault bool `protobuf:"varint,3,opt,name=reset_to_default,json=resetToDefault,proto3,oneof"`
}

func (*EventsConfigurationRequest_Changes) isEventsConfigurationRequest_Operation() {}

func (*EventsConfigurationRequest_ResetToDefault) isEventsConfigurationRequest_Operation() {}

func (m *EventsConfigurationRequest) GetOperation() isEventsConfigurationRequest_Operation {
	if m != nil {
		return m.Operation
	}
	return nil
}

func (m *EventsConfigurationRequest) GetChanges() *EventsCfg {
	if x, ok := m.GetOperation().(*EventsConfigurationRequest_Changes); ok {
		return x.Changes
	}
	return nil
}

func (m *EventsConfigurationRequest) GetResetToDefault() bool {
	if x, ok := m.GetOperation().(*EventsConfigurationRequest_ResetToDefault); ok {
		return x.ResetToDefault
	}
	return false
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*EventsConfigurationRequest) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*EventsConfigurationRequest_Changes)(nil),
		(*EventsConfigurationRequest_ResetToDefault)(nil),
	}
}

type EventsConfigurationResponse struct {
	Status               Status                             `protobuf:"varint,1,opt,name=status,proto3,enum=dmi.Status" json:"status,omitempty"`
	Reason               EventsConfigurationResponse_Reason `protobuf:"varint,2,opt,name=reason,proto3,enum=dmi.EventsConfigurationResponse_Reason" json:"reason,omitempty"`
	ReasonDetail         string                             `protobuf:"bytes,3,opt,name=reason_detail,json=reasonDetail,proto3" json:"reason_detail,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                           `json:"-"`
	XXX_unrecognized     []byte                             `json:"-"`
	XXX_sizecache        int32                              `json:"-"`
}

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

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

var xxx_messageInfo_EventsConfigurationResponse proto.InternalMessageInfo

func (m *EventsConfigurationResponse) GetStatus() Status {
	if m != nil {
		return m.Status
	}
	return Status_UNDEFINED_STATUS
}

func (m *EventsConfigurationResponse) GetReason() EventsConfigurationResponse_Reason {
	if m != nil {
		return m.Reason
	}
	return EventsConfigurationResponse_UNDEFINED_REASON
}

func (m *EventsConfigurationResponse) GetReasonDetail() string {
	if m != nil {
		return m.ReasonDetail
	}
	return ""
}

type EventMetaData struct {
	DeviceUuid *Uuid `protobuf:"bytes,1,opt,name=device_uuid,json=deviceUuid,proto3" json:"device_uuid,omitempty"`
	// uuid of the component
	ComponentUuid        *Uuid    `protobuf:"bytes,2,opt,name=component_uuid,json=componentUuid,proto3" json:"component_uuid,omitempty"`
	ComponentName        string   `protobuf:"bytes,3,opt,name=component_name,json=componentName,proto3" json:"component_name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_EventMetaData proto.InternalMessageInfo

func (m *EventMetaData) GetDeviceUuid() *Uuid {
	if m != nil {
		return m.DeviceUuid
	}
	return nil
}

func (m *EventMetaData) GetComponentUuid() *Uuid {
	if m != nil {
		return m.ComponentUuid
	}
	return nil
}

func (m *EventMetaData) GetComponentName() string {
	if m != nil {
		return m.ComponentName
	}
	return ""
}

type Event struct {
	EventMetadata *EventMetaData       `protobuf:"bytes,1,opt,name=event_metadata,json=eventMetadata,proto3" json:"event_metadata,omitempty"`
	EventId       EventIds             `protobuf:"varint,2,opt,name=event_id,json=eventId,proto3,enum=dmi.EventIds" json:"event_id,omitempty"`
	RaisedTs      *timestamp.Timestamp `protobuf:"bytes,3,opt,name=raised_ts,json=raisedTs,proto3" json:"raised_ts,omitempty"`
	// Optional threshold information for an event
	ThresholdInfo *ThresholdInformation `protobuf:"bytes,4,opt,name=threshold_info,json=thresholdInfo,proto3" json:"threshold_info,omitempty"`
	// Any additional info regarding the event
	AddInfo              string   `protobuf:"bytes,5,opt,name=add_info,json=addInfo,proto3" json:"add_info,omitempty"`
	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_8962d785556e9979, []int{10}
}

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) GetEventMetadata() *EventMetaData {
	if m != nil {
		return m.EventMetadata
	}
	return nil
}

func (m *Event) GetEventId() EventIds {
	if m != nil {
		return m.EventId
	}
	return EventIds_EVENT_NAME_UNDEFINED
}

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

func (m *Event) GetThresholdInfo() *ThresholdInformation {
	if m != nil {
		return m.ThresholdInfo
	}
	return nil
}

func (m *Event) GetAddInfo() string {
	if m != nil {
		return m.AddInfo
	}
	return ""
}

func init() {
	proto.RegisterEnum("dmi.EventIds", EventIds_name, EventIds_value)
	proto.RegisterEnum("dmi.ListEventsResponse_Reason", ListEventsResponse_Reason_name, ListEventsResponse_Reason_value)
	proto.RegisterEnum("dmi.EventsConfigurationResponse_Reason", EventsConfigurationResponse_Reason_name, EventsConfigurationResponse_Reason_value)
	proto.RegisterType((*ValueType)(nil), "dmi.ValueType")
	proto.RegisterType((*WaterMarks)(nil), "dmi.WaterMarks")
	proto.RegisterType((*Thresholds)(nil), "dmi.Thresholds")
	proto.RegisterType((*ThresholdInformation)(nil), "dmi.ThresholdInformation")
	proto.RegisterType((*EventCfg)(nil), "dmi.EventCfg")
	proto.RegisterType((*EventsCfg)(nil), "dmi.EventsCfg")
	proto.RegisterType((*ListEventsResponse)(nil), "dmi.ListEventsResponse")
	proto.RegisterType((*EventsConfigurationRequest)(nil), "dmi.EventsConfigurationRequest")
	proto.RegisterType((*EventsConfigurationResponse)(nil), "dmi.EventsConfigurationResponse")
	proto.RegisterType((*EventMetaData)(nil), "dmi.EventMetaData")
	proto.RegisterType((*Event)(nil), "dmi.Event")
}

func init() { proto.RegisterFile("dmi/hw_events_mgmt_service.proto", fileDescriptor_8962d785556e9979) }

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

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// NativeEventsManagementServiceClient is the client API for NativeEventsManagementService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type NativeEventsManagementServiceClient interface {
	// List the supported events for the passed device
	ListEvents(ctx context.Context, in *HardwareID, opts ...grpc.CallOption) (*ListEventsResponse, error)
	// Updates the configuration of the list of events in the request
	// The default behavior of the device is to report all the supported events
	// This configuration is persisted across reboots of the device or the device manager
	UpdateEventsConfiguration(ctx context.Context, in *EventsConfigurationRequest, opts ...grpc.CallOption) (*EventsConfigurationResponse, error)
	// Initiate the server streaming of the events
	StreamEvents(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (NativeEventsManagementService_StreamEventsClient, error)
}

type nativeEventsManagementServiceClient struct {
	cc *grpc.ClientConn
}

func NewNativeEventsManagementServiceClient(cc *grpc.ClientConn) NativeEventsManagementServiceClient {
	return &nativeEventsManagementServiceClient{cc}
}

func (c *nativeEventsManagementServiceClient) ListEvents(ctx context.Context, in *HardwareID, opts ...grpc.CallOption) (*ListEventsResponse, error) {
	out := new(ListEventsResponse)
	err := c.cc.Invoke(ctx, "/dmi.NativeEventsManagementService/ListEvents", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *nativeEventsManagementServiceClient) UpdateEventsConfiguration(ctx context.Context, in *EventsConfigurationRequest, opts ...grpc.CallOption) (*EventsConfigurationResponse, error) {
	out := new(EventsConfigurationResponse)
	err := c.cc.Invoke(ctx, "/dmi.NativeEventsManagementService/UpdateEventsConfiguration", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *nativeEventsManagementServiceClient) StreamEvents(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (NativeEventsManagementService_StreamEventsClient, error) {
	stream, err := c.cc.NewStream(ctx, &_NativeEventsManagementService_serviceDesc.Streams[0], "/dmi.NativeEventsManagementService/StreamEvents", opts...)
	if err != nil {
		return nil, err
	}
	x := &nativeEventsManagementServiceStreamEventsClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type NativeEventsManagementService_StreamEventsClient interface {
	Recv() (*Event, error)
	grpc.ClientStream
}

type nativeEventsManagementServiceStreamEventsClient struct {
	grpc.ClientStream
}

func (x *nativeEventsManagementServiceStreamEventsClient) Recv() (*Event, error) {
	m := new(Event)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

// NativeEventsManagementServiceServer is the server API for NativeEventsManagementService service.
type NativeEventsManagementServiceServer interface {
	// List the supported events for the passed device
	ListEvents(context.Context, *HardwareID) (*ListEventsResponse, error)
	// Updates the configuration of the list of events in the request
	// The default behavior of the device is to report all the supported events
	// This configuration is persisted across reboots of the device or the device manager
	UpdateEventsConfiguration(context.Context, *EventsConfigurationRequest) (*EventsConfigurationResponse, error)
	// Initiate the server streaming of the events
	StreamEvents(*empty.Empty, NativeEventsManagementService_StreamEventsServer) error
}

// UnimplementedNativeEventsManagementServiceServer can be embedded to have forward compatible implementations.
type UnimplementedNativeEventsManagementServiceServer struct {
}

func (*UnimplementedNativeEventsManagementServiceServer) ListEvents(ctx context.Context, req *HardwareID) (*ListEventsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListEvents not implemented")
}
func (*UnimplementedNativeEventsManagementServiceServer) UpdateEventsConfiguration(ctx context.Context, req *EventsConfigurationRequest) (*EventsConfigurationResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateEventsConfiguration not implemented")
}
func (*UnimplementedNativeEventsManagementServiceServer) StreamEvents(req *empty.Empty, srv NativeEventsManagementService_StreamEventsServer) error {
	return status.Errorf(codes.Unimplemented, "method StreamEvents not implemented")
}

func RegisterNativeEventsManagementServiceServer(s *grpc.Server, srv NativeEventsManagementServiceServer) {
	s.RegisterService(&_NativeEventsManagementService_serviceDesc, srv)
}

func _NativeEventsManagementService_ListEvents_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(HardwareID)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NativeEventsManagementServiceServer).ListEvents(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/dmi.NativeEventsManagementService/ListEvents",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NativeEventsManagementServiceServer).ListEvents(ctx, req.(*HardwareID))
	}
	return interceptor(ctx, in, info, handler)
}

func _NativeEventsManagementService_UpdateEventsConfiguration_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(EventsConfigurationRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NativeEventsManagementServiceServer).UpdateEventsConfiguration(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/dmi.NativeEventsManagementService/UpdateEventsConfiguration",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NativeEventsManagementServiceServer).UpdateEventsConfiguration(ctx, req.(*EventsConfigurationRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _NativeEventsManagementService_StreamEvents_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(empty.Empty)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(NativeEventsManagementServiceServer).StreamEvents(m, &nativeEventsManagementServiceStreamEventsServer{stream})
}

type NativeEventsManagementService_StreamEventsServer interface {
	Send(*Event) error
	grpc.ServerStream
}

type nativeEventsManagementServiceStreamEventsServer struct {
	grpc.ServerStream
}

func (x *nativeEventsManagementServiceStreamEventsServer) Send(m *Event) error {
	return x.ServerStream.SendMsg(m)
}

var _NativeEventsManagementService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "dmi.NativeEventsManagementService",
	HandlerType: (*NativeEventsManagementServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ListEvents",
			Handler:    _NativeEventsManagementService_ListEvents_Handler,
		},
		{
			MethodName: "UpdateEventsConfiguration",
			Handler:    _NativeEventsManagementService_UpdateEventsConfiguration_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "StreamEvents",
			Handler:       _NativeEventsManagementService_StreamEvents_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "dmi/hw_events_mgmt_service.proto",
}