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

package core_adapter

import (
	common "github.com/opencord/voltha-protos/v5/go/common"
	extension "github.com/opencord/voltha-protos/v5/go/extension"
	omci "github.com/opencord/voltha-protos/v5/go/omci"
	openflow_13 "github.com/opencord/voltha-protos/v5/go/openflow_13"
	voltha "github.com/opencord/voltha-protos/v5/go/voltha"
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	reflect "reflect"
	sync "sync"
	unsafe "unsafe"
)

const (
	// Verify that this generated code is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
	// Verify that runtime/protoimpl is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)

type AdapterRegistration struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Adapter       *voltha.Adapter        `protobuf:"bytes,1,opt,name=adapter,proto3" json:"adapter,omitempty"`
	DTypes        *voltha.DeviceTypes    `protobuf:"bytes,2,opt,name=dTypes,proto3" json:"dTypes,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*AdapterRegistration) ProtoMessage() {}

func (x *AdapterRegistration) ProtoReflect() protoreflect.Message {
	mi := &file_voltha_protos_core_adapter_proto_msgTypes[0]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use AdapterRegistration.ProtoReflect.Descriptor instead.
func (*AdapterRegistration) Descriptor() ([]byte, []int) {
	return file_voltha_protos_core_adapter_proto_rawDescGZIP(), []int{0}
}

func (x *AdapterRegistration) GetAdapter() *voltha.Adapter {
	if x != nil {
		return x.Adapter
	}
	return nil
}

func (x *AdapterRegistration) GetDTypes() *voltha.DeviceTypes {
	if x != nil {
		return x.DTypes
	}
	return nil
}

type ChildDeviceFilter struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	ParentId      string                 `protobuf:"bytes,1,opt,name=parent_id,json=parentId,proto3" json:"parent_id,omitempty"`
	SerialNumber  string                 `protobuf:"bytes,2,opt,name=serial_number,json=serialNumber,proto3" json:"serial_number,omitempty"`
	OnuId         *uint32                `protobuf:"varint,3,opt,name=onu_id,json=onuId,proto3,oneof" json:"onu_id,omitempty"`
	ParentPortNo  uint32                 `protobuf:"varint,4,opt,name=parent_port_no,json=parentPortNo,proto3" json:"parent_port_no,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ChildDeviceFilter) ProtoMessage() {}

func (x *ChildDeviceFilter) ProtoReflect() protoreflect.Message {
	mi := &file_voltha_protos_core_adapter_proto_msgTypes[1]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use ChildDeviceFilter.ProtoReflect.Descriptor instead.
func (*ChildDeviceFilter) Descriptor() ([]byte, []int) {
	return file_voltha_protos_core_adapter_proto_rawDescGZIP(), []int{1}
}

func (x *ChildDeviceFilter) GetParentId() string {
	if x != nil {
		return x.ParentId
	}
	return ""
}

func (x *ChildDeviceFilter) GetSerialNumber() string {
	if x != nil {
		return x.SerialNumber
	}
	return ""
}

func (x *ChildDeviceFilter) GetOnuId() uint32 {
	if x != nil && x.OnuId != nil {
		return *x.OnuId
	}
	return 0
}

func (x *ChildDeviceFilter) GetParentPortNo() uint32 {
	if x != nil {
		return x.ParentPortNo
	}
	return 0
}

type PortFilter struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	DeviceId      string                 `protobuf:"bytes,1,opt,name=device_id,json=deviceId,proto3" json:"device_id,omitempty"`
	Port          uint32                 `protobuf:"varint,2,opt,name=port,proto3" json:"port,omitempty"`
	PortType      voltha.Port_PortType   `protobuf:"varint,3,opt,name=port_type,json=portType,proto3,enum=device.Port_PortType" json:"port_type,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*PortFilter) ProtoMessage() {}

func (x *PortFilter) ProtoReflect() protoreflect.Message {
	mi := &file_voltha_protos_core_adapter_proto_msgTypes[2]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use PortFilter.ProtoReflect.Descriptor instead.
func (*PortFilter) Descriptor() ([]byte, []int) {
	return file_voltha_protos_core_adapter_proto_rawDescGZIP(), []int{2}
}

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

func (x *PortFilter) GetPort() uint32 {
	if x != nil {
		return x.Port
	}
	return 0
}

func (x *PortFilter) GetPortType() voltha.Port_PortType {
	if x != nil {
		return x.PortType
	}
	return voltha.Port_PortType(0)
}

type DeviceDiscovery struct {
	state           protoimpl.MessageState `protogen:"open.v1"`
	ParentId        string                 `protobuf:"bytes,1,opt,name=parent_id,json=parentId,proto3" json:"parent_id,omitempty"`
	ParentPortNo    uint32                 `protobuf:"varint,2,opt,name=parent_port_no,json=parentPortNo,proto3" json:"parent_port_no,omitempty"`
	ChildDeviceType string                 `protobuf:"bytes,3,opt,name=child_device_type,json=childDeviceType,proto3" json:"child_device_type,omitempty"`
	ChannelId       uint32                 `protobuf:"varint,4,opt,name=channel_id,json=channelId,proto3" json:"channel_id,omitempty"`
	VendorId        string                 `protobuf:"bytes,5,opt,name=vendor_id,json=vendorId,proto3" json:"vendor_id,omitempty"`
	SerialNumber    string                 `protobuf:"bytes,6,opt,name=serial_number,json=serialNumber,proto3" json:"serial_number,omitempty"`
	OnuId           uint32                 `protobuf:"varint,7,opt,name=onu_id,json=onuId,proto3" json:"onu_id,omitempty"`
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

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

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

func (*DeviceDiscovery) ProtoMessage() {}

func (x *DeviceDiscovery) ProtoReflect() protoreflect.Message {
	mi := &file_voltha_protos_core_adapter_proto_msgTypes[3]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use DeviceDiscovery.ProtoReflect.Descriptor instead.
func (*DeviceDiscovery) Descriptor() ([]byte, []int) {
	return file_voltha_protos_core_adapter_proto_rawDescGZIP(), []int{3}
}

func (x *DeviceDiscovery) GetParentId() string {
	if x != nil {
		return x.ParentId
	}
	return ""
}

func (x *DeviceDiscovery) GetParentPortNo() uint32 {
	if x != nil {
		return x.ParentPortNo
	}
	return 0
}

func (x *DeviceDiscovery) GetChildDeviceType() string {
	if x != nil {
		return x.ChildDeviceType
	}
	return ""
}

func (x *DeviceDiscovery) GetChannelId() uint32 {
	if x != nil {
		return x.ChannelId
	}
	return 0
}

func (x *DeviceDiscovery) GetVendorId() string {
	if x != nil {
		return x.VendorId
	}
	return ""
}

func (x *DeviceDiscovery) GetSerialNumber() string {
	if x != nil {
		return x.SerialNumber
	}
	return ""
}

func (x *DeviceDiscovery) GetOnuId() uint32 {
	if x != nil {
		return x.OnuId
	}
	return 0
}

type DeviceStateFilter struct {
	state          protoimpl.MessageState     `protogen:"open.v1"`
	DeviceId       string                     `protobuf:"bytes,1,opt,name=device_id,json=deviceId,proto3" json:"device_id,omitempty"`
	ParentDeviceId string                     `protobuf:"bytes,2,opt,name=parent_device_id,json=parentDeviceId,proto3" json:"parent_device_id,omitempty"`
	OperStatus     common.OperStatus_Types    `protobuf:"varint,3,opt,name=oper_status,json=operStatus,proto3,enum=common.OperStatus_Types" json:"oper_status,omitempty"`
	ConnStatus     common.ConnectStatus_Types `protobuf:"varint,4,opt,name=conn_status,json=connStatus,proto3,enum=common.ConnectStatus_Types" json:"conn_status,omitempty"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

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

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

func (*DeviceStateFilter) ProtoMessage() {}

func (x *DeviceStateFilter) ProtoReflect() protoreflect.Message {
	mi := &file_voltha_protos_core_adapter_proto_msgTypes[4]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use DeviceStateFilter.ProtoReflect.Descriptor instead.
func (*DeviceStateFilter) Descriptor() ([]byte, []int) {
	return file_voltha_protos_core_adapter_proto_rawDescGZIP(), []int{4}
}

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

func (x *DeviceStateFilter) GetParentDeviceId() string {
	if x != nil {
		return x.ParentDeviceId
	}
	return ""
}

func (x *DeviceStateFilter) GetOperStatus() common.OperStatus_Types {
	if x != nil {
		return x.OperStatus
	}
	return common.OperStatus_Types(0)
}

func (x *DeviceStateFilter) GetConnStatus() common.ConnectStatus_Types {
	if x != nil {
		return x.ConnStatus
	}
	return common.ConnectStatus_Types(0)
}

type PortState struct {
	state         protoimpl.MessageState  `protogen:"open.v1"`
	DeviceId      string                  `protobuf:"bytes,1,opt,name=device_id,json=deviceId,proto3" json:"device_id,omitempty"`
	PortType      voltha.Port_PortType    `protobuf:"varint,2,opt,name=port_type,json=portType,proto3,enum=device.Port_PortType" json:"port_type,omitempty"`
	PortNo        uint32                  `protobuf:"varint,3,opt,name=port_no,json=portNo,proto3" json:"port_no,omitempty"`
	OperStatus    common.OperStatus_Types `protobuf:"varint,4,opt,name=oper_status,json=operStatus,proto3,enum=common.OperStatus_Types" json:"oper_status,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*PortState) ProtoMessage() {}

func (x *PortState) ProtoReflect() protoreflect.Message {
	mi := &file_voltha_protos_core_adapter_proto_msgTypes[5]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use PortState.ProtoReflect.Descriptor instead.
func (*PortState) Descriptor() ([]byte, []int) {
	return file_voltha_protos_core_adapter_proto_rawDescGZIP(), []int{5}
}

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

func (x *PortState) GetPortType() voltha.Port_PortType {
	if x != nil {
		return x.PortType
	}
	return voltha.Port_PortType(0)
}

func (x *PortState) GetPortNo() uint32 {
	if x != nil {
		return x.PortNo
	}
	return 0
}

func (x *PortState) GetOperStatus() common.OperStatus_Types {
	if x != nil {
		return x.OperStatus
	}
	return common.OperStatus_Types(0)
}

type PortStateFilter struct {
	state          protoimpl.MessageState  `protogen:"open.v1"`
	DeviceId       string                  `protobuf:"bytes,1,opt,name=device_id,json=deviceId,proto3" json:"device_id,omitempty"`
	PortTypeFilter uint32                  `protobuf:"varint,2,opt,name=port_type_filter,json=portTypeFilter,proto3" json:"port_type_filter,omitempty"`
	OperStatus     common.OperStatus_Types `protobuf:"varint,4,opt,name=oper_status,json=operStatus,proto3,enum=common.OperStatus_Types" json:"oper_status,omitempty"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

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

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

func (*PortStateFilter) ProtoMessage() {}

func (x *PortStateFilter) ProtoReflect() protoreflect.Message {
	mi := &file_voltha_protos_core_adapter_proto_msgTypes[6]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use PortStateFilter.ProtoReflect.Descriptor instead.
func (*PortStateFilter) Descriptor() ([]byte, []int) {
	return file_voltha_protos_core_adapter_proto_rawDescGZIP(), []int{6}
}

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

func (x *PortStateFilter) GetPortTypeFilter() uint32 {
	if x != nil {
		return x.PortTypeFilter
	}
	return 0
}

func (x *PortStateFilter) GetOperStatus() common.OperStatus_Types {
	if x != nil {
		return x.OperStatus
	}
	return common.OperStatus_Types(0)
}

type PacketIn struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	DeviceId      string                 `protobuf:"bytes,1,opt,name=device_id,json=deviceId,proto3" json:"device_id,omitempty"`
	Port          uint32                 `protobuf:"varint,2,opt,name=port,proto3" json:"port,omitempty"`
	Packet        []byte                 `protobuf:"bytes,3,opt,name=packet,proto3" json:"packet,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*PacketIn) ProtoMessage() {}

func (x *PacketIn) ProtoReflect() protoreflect.Message {
	mi := &file_voltha_protos_core_adapter_proto_msgTypes[7]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use PacketIn.ProtoReflect.Descriptor instead.
func (*PacketIn) Descriptor() ([]byte, []int) {
	return file_voltha_protos_core_adapter_proto_rawDescGZIP(), []int{7}
}

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

func (x *PacketIn) GetPort() uint32 {
	if x != nil {
		return x.Port
	}
	return 0
}

func (x *PacketIn) GetPacket() []byte {
	if x != nil {
		return x.Packet
	}
	return nil
}

type PacketOut struct {
	state         protoimpl.MessageState    `protogen:"open.v1"`
	DeviceId      string                    `protobuf:"bytes,1,opt,name=device_id,json=deviceId,proto3" json:"device_id,omitempty"`
	EgressPortNo  uint32                    `protobuf:"varint,2,opt,name=egress_port_no,json=egressPortNo,proto3" json:"egress_port_no,omitempty"`
	Packet        *openflow_13.OfpPacketOut `protobuf:"bytes,3,opt,name=packet,proto3" json:"packet,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*PacketOut) ProtoMessage() {}

func (x *PacketOut) ProtoReflect() protoreflect.Message {
	mi := &file_voltha_protos_core_adapter_proto_msgTypes[8]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use PacketOut.ProtoReflect.Descriptor instead.
func (*PacketOut) Descriptor() ([]byte, []int) {
	return file_voltha_protos_core_adapter_proto_rawDescGZIP(), []int{8}
}

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

func (x *PacketOut) GetEgressPortNo() uint32 {
	if x != nil {
		return x.EgressPortNo
	}
	return 0
}

func (x *PacketOut) GetPacket() *openflow_13.OfpPacketOut {
	if x != nil {
		return x.Packet
	}
	return nil
}

type DeviceReason struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	DeviceId      string                 `protobuf:"bytes,1,opt,name=device_id,json=deviceId,proto3" json:"device_id,omitempty"`
	Reason        string                 `protobuf:"bytes,2,opt,name=reason,proto3" json:"reason,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*DeviceReason) ProtoMessage() {}

func (x *DeviceReason) ProtoReflect() protoreflect.Message {
	mi := &file_voltha_protos_core_adapter_proto_msgTypes[9]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use DeviceReason.ProtoReflect.Descriptor instead.
func (*DeviceReason) Descriptor() ([]byte, []int) {
	return file_voltha_protos_core_adapter_proto_rawDescGZIP(), []int{9}
}

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

func (x *DeviceReason) GetReason() string {
	if x != nil {
		return x.Reason
	}
	return ""
}

type BulkFlows struct {
	state         protoimpl.MessageState    `protogen:"open.v1"`
	Device        *voltha.Device            `protobuf:"bytes,1,opt,name=device,proto3" json:"device,omitempty"`
	Flows         *openflow_13.Flows        `protobuf:"bytes,2,opt,name=flows,proto3" json:"flows,omitempty"`
	Groups        *openflow_13.FlowGroups   `protobuf:"bytes,3,opt,name=groups,proto3" json:"groups,omitempty"`
	FlowMetadata  *openflow_13.FlowMetadata `protobuf:"bytes,4,opt,name=flow_metadata,json=flowMetadata,proto3" json:"flow_metadata,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*BulkFlows) ProtoMessage() {}

func (x *BulkFlows) ProtoReflect() protoreflect.Message {
	mi := &file_voltha_protos_core_adapter_proto_msgTypes[10]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use BulkFlows.ProtoReflect.Descriptor instead.
func (*BulkFlows) Descriptor() ([]byte, []int) {
	return file_voltha_protos_core_adapter_proto_rawDescGZIP(), []int{10}
}

func (x *BulkFlows) GetDevice() *voltha.Device {
	if x != nil {
		return x.Device
	}
	return nil
}

func (x *BulkFlows) GetFlows() *openflow_13.Flows {
	if x != nil {
		return x.Flows
	}
	return nil
}

func (x *BulkFlows) GetGroups() *openflow_13.FlowGroups {
	if x != nil {
		return x.Groups
	}
	return nil
}

func (x *BulkFlows) GetFlowMetadata() *openflow_13.FlowMetadata {
	if x != nil {
		return x.FlowMetadata
	}
	return nil
}

type IncrementalFlows struct {
	state         protoimpl.MessageState        `protogen:"open.v1"`
	Device        *voltha.Device                `protobuf:"bytes,1,opt,name=device,proto3" json:"device,omitempty"`
	Flows         *openflow_13.FlowChanges      `protobuf:"bytes,2,opt,name=flows,proto3" json:"flows,omitempty"`
	Groups        *openflow_13.FlowGroupChanges `protobuf:"bytes,3,opt,name=groups,proto3" json:"groups,omitempty"`
	FlowMetadata  *openflow_13.FlowMetadata     `protobuf:"bytes,4,opt,name=flow_metadata,json=flowMetadata,proto3" json:"flow_metadata,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*IncrementalFlows) ProtoMessage() {}

func (x *IncrementalFlows) ProtoReflect() protoreflect.Message {
	mi := &file_voltha_protos_core_adapter_proto_msgTypes[11]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use IncrementalFlows.ProtoReflect.Descriptor instead.
func (*IncrementalFlows) Descriptor() ([]byte, []int) {
	return file_voltha_protos_core_adapter_proto_rawDescGZIP(), []int{11}
}

func (x *IncrementalFlows) GetDevice() *voltha.Device {
	if x != nil {
		return x.Device
	}
	return nil
}

func (x *IncrementalFlows) GetFlows() *openflow_13.FlowChanges {
	if x != nil {
		return x.Flows
	}
	return nil
}

func (x *IncrementalFlows) GetGroups() *openflow_13.FlowGroupChanges {
	if x != nil {
		return x.Groups
	}
	return nil
}

func (x *IncrementalFlows) GetFlowMetadata() *openflow_13.FlowMetadata {
	if x != nil {
		return x.FlowMetadata
	}
	return nil
}

type PmConfigsInfo struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	DeviceId      string                 `protobuf:"bytes,1,opt,name=device_id,json=deviceId,proto3" json:"device_id,omitempty"`
	PmConfigs     *voltha.PmConfigs      `protobuf:"bytes,2,opt,name=pm_configs,json=pmConfigs,proto3" json:"pm_configs,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*PmConfigsInfo) ProtoMessage() {}

func (x *PmConfigsInfo) ProtoReflect() protoreflect.Message {
	mi := &file_voltha_protos_core_adapter_proto_msgTypes[12]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use PmConfigsInfo.ProtoReflect.Descriptor instead.
func (*PmConfigsInfo) Descriptor() ([]byte, []int) {
	return file_voltha_protos_core_adapter_proto_rawDescGZIP(), []int{12}
}

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

func (x *PmConfigsInfo) GetPmConfigs() *voltha.PmConfigs {
	if x != nil {
		return x.PmConfigs
	}
	return nil
}

type SwitchCapability struct {
	state          protoimpl.MessageState         `protogen:"open.v1"`
	Desc           *openflow_13.OfpDesc           `protobuf:"bytes,1,opt,name=desc,proto3" json:"desc,omitempty"`
	SwitchFeatures *openflow_13.OfpSwitchFeatures `protobuf:"bytes,2,opt,name=switch_features,json=switchFeatures,proto3" json:"switch_features,omitempty"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

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

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

func (*SwitchCapability) ProtoMessage() {}

func (x *SwitchCapability) ProtoReflect() protoreflect.Message {
	mi := &file_voltha_protos_core_adapter_proto_msgTypes[13]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use SwitchCapability.ProtoReflect.Descriptor instead.
func (*SwitchCapability) Descriptor() ([]byte, []int) {
	return file_voltha_protos_core_adapter_proto_rawDescGZIP(), []int{13}
}

func (x *SwitchCapability) GetDesc() *openflow_13.OfpDesc {
	if x != nil {
		return x.Desc
	}
	return nil
}

func (x *SwitchCapability) GetSwitchFeatures() *openflow_13.OfpSwitchFeatures {
	if x != nil {
		return x.SwitchFeatures
	}
	return nil
}

type ImageDownloadMessage struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Device        *voltha.Device         `protobuf:"bytes,1,opt,name=device,proto3" json:"device,omitempty"`
	Image         *voltha.ImageDownload  `protobuf:"bytes,2,opt,name=image,proto3" json:"image,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ImageDownloadMessage) ProtoMessage() {}

func (x *ImageDownloadMessage) ProtoReflect() protoreflect.Message {
	mi := &file_voltha_protos_core_adapter_proto_msgTypes[14]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use ImageDownloadMessage.ProtoReflect.Descriptor instead.
func (*ImageDownloadMessage) Descriptor() ([]byte, []int) {
	return file_voltha_protos_core_adapter_proto_rawDescGZIP(), []int{14}
}

func (x *ImageDownloadMessage) GetDevice() *voltha.Device {
	if x != nil {
		return x.Device
	}
	return nil
}

func (x *ImageDownloadMessage) GetImage() *voltha.ImageDownload {
	if x != nil {
		return x.Image
	}
	return nil
}

type OMCITest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Device        *voltha.Device         `protobuf:"bytes,1,opt,name=device,proto3" json:"device,omitempty"`
	Request       *omci.OmciTestRequest  `protobuf:"bytes,2,opt,name=request,proto3" json:"request,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*OMCITest) ProtoMessage() {}

func (x *OMCITest) ProtoReflect() protoreflect.Message {
	mi := &file_voltha_protos_core_adapter_proto_msgTypes[15]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use OMCITest.ProtoReflect.Descriptor instead.
func (*OMCITest) Descriptor() ([]byte, []int) {
	return file_voltha_protos_core_adapter_proto_rawDescGZIP(), []int{15}
}

func (x *OMCITest) GetDevice() *voltha.Device {
	if x != nil {
		return x.Device
	}
	return nil
}

func (x *OMCITest) GetRequest() *omci.OmciTestRequest {
	if x != nil {
		return x.Request
	}
	return nil
}

type SimulateAlarmMessage struct {
	state         protoimpl.MessageState       `protogen:"open.v1"`
	Device        *voltha.Device               `protobuf:"bytes,1,opt,name=device,proto3" json:"device,omitempty"`
	Request       *voltha.SimulateAlarmRequest `protobuf:"bytes,2,opt,name=request,proto3" json:"request,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*SimulateAlarmMessage) ProtoMessage() {}

func (x *SimulateAlarmMessage) ProtoReflect() protoreflect.Message {
	mi := &file_voltha_protos_core_adapter_proto_msgTypes[16]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use SimulateAlarmMessage.ProtoReflect.Descriptor instead.
func (*SimulateAlarmMessage) Descriptor() ([]byte, []int) {
	return file_voltha_protos_core_adapter_proto_rawDescGZIP(), []int{16}
}

func (x *SimulateAlarmMessage) GetDevice() *voltha.Device {
	if x != nil {
		return x.Device
	}
	return nil
}

func (x *SimulateAlarmMessage) GetRequest() *voltha.SimulateAlarmRequest {
	if x != nil {
		return x.Request
	}
	return nil
}

type GetExtValueMessage struct {
	state         protoimpl.MessageState   `protogen:"open.v1"`
	ParentDevice  *voltha.Device           `protobuf:"bytes,1,opt,name=parent_device,json=parentDevice,proto3" json:"parent_device,omitempty"`
	ChildDevice   *voltha.Device           `protobuf:"bytes,2,opt,name=child_device,json=childDevice,proto3" json:"child_device,omitempty"`
	ValueType     extension.ValueType_Type `protobuf:"varint,3,opt,name=value_type,json=valueType,proto3,enum=extension.ValueType_Type" json:"value_type,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*GetExtValueMessage) ProtoMessage() {}

func (x *GetExtValueMessage) ProtoReflect() protoreflect.Message {
	mi := &file_voltha_protos_core_adapter_proto_msgTypes[17]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use GetExtValueMessage.ProtoReflect.Descriptor instead.
func (*GetExtValueMessage) Descriptor() ([]byte, []int) {
	return file_voltha_protos_core_adapter_proto_rawDescGZIP(), []int{17}
}

func (x *GetExtValueMessage) GetParentDevice() *voltha.Device {
	if x != nil {
		return x.ParentDevice
	}
	return nil
}

func (x *GetExtValueMessage) GetChildDevice() *voltha.Device {
	if x != nil {
		return x.ChildDevice
	}
	return nil
}

func (x *GetExtValueMessage) GetValueType() extension.ValueType_Type {
	if x != nil {
		return x.ValueType
	}
	return extension.ValueType_Type(0)
}

type SetExtValueMessage struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Device        *voltha.Device         `protobuf:"bytes,1,opt,name=device,proto3" json:"device,omitempty"`
	Value         *extension.ValueSet    `protobuf:"bytes,3,opt,name=value,proto3" json:"value,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*SetExtValueMessage) ProtoMessage() {}

func (x *SetExtValueMessage) ProtoReflect() protoreflect.Message {
	mi := &file_voltha_protos_core_adapter_proto_msgTypes[18]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use SetExtValueMessage.ProtoReflect.Descriptor instead.
func (*SetExtValueMessage) Descriptor() ([]byte, []int) {
	return file_voltha_protos_core_adapter_proto_rawDescGZIP(), []int{18}
}

func (x *SetExtValueMessage) GetDevice() *voltha.Device {
	if x != nil {
		return x.Device
	}
	return nil
}

func (x *SetExtValueMessage) GetValue() *extension.ValueSet {
	if x != nil {
		return x.Value
	}
	return nil
}

var File_voltha_protos_core_adapter_proto protoreflect.FileDescriptor

const file_voltha_protos_core_adapter_proto_rawDesc = "" +
	"\n" +
	" voltha_protos/core_adapter.proto\x12\fcore_adapter\x1a\x1avoltha_protos/common.proto\x1a\x1avoltha_protos/voltha.proto\x1a\x1fvoltha_protos/openflow_13.proto\x1a\x1bvoltha_protos/adapter.proto\x1a\x1avoltha_protos/device.proto\x1a\x1evoltha_protos/extensions.proto\x1a\x1dvoltha_protos/omci_test.proto\"n\n" +
	"\x13AdapterRegistration\x12*\n" +
	"\aadapter\x18\x01 \x01(\v2\x10.adapter.AdapterR\aadapter\x12+\n" +
	"\x06dTypes\x18\x02 \x01(\v2\x13.device.DeviceTypesR\x06dTypes\"\xa2\x01\n" +
	"\x11ChildDeviceFilter\x12\x1b\n" +
	"\tparent_id\x18\x01 \x01(\tR\bparentId\x12#\n" +
	"\rserial_number\x18\x02 \x01(\tR\fserialNumber\x12\x1a\n" +
	"\x06onu_id\x18\x03 \x01(\rH\x00R\x05onuId\x88\x01\x01\x12$\n" +
	"\x0eparent_port_no\x18\x04 \x01(\rR\fparentPortNoB\t\n" +
	"\a_onu_id\"q\n" +
	"\n" +
	"PortFilter\x12\x1b\n" +
	"\tdevice_id\x18\x01 \x01(\tR\bdeviceId\x12\x12\n" +
	"\x04port\x18\x02 \x01(\rR\x04port\x122\n" +
	"\tport_type\x18\x03 \x01(\x0e2\x15.device.Port.PortTypeR\bportType\"\xf8\x01\n" +
	"\x0fDeviceDiscovery\x12\x1b\n" +
	"\tparent_id\x18\x01 \x01(\tR\bparentId\x12$\n" +
	"\x0eparent_port_no\x18\x02 \x01(\rR\fparentPortNo\x12*\n" +
	"\x11child_device_type\x18\x03 \x01(\tR\x0fchildDeviceType\x12\x1d\n" +
	"\n" +
	"channel_id\x18\x04 \x01(\rR\tchannelId\x12\x1b\n" +
	"\tvendor_id\x18\x05 \x01(\tR\bvendorId\x12#\n" +
	"\rserial_number\x18\x06 \x01(\tR\fserialNumber\x12\x15\n" +
	"\x06onu_id\x18\a \x01(\rR\x05onuId\"\xd3\x01\n" +
	"\x11DeviceStateFilter\x12\x1b\n" +
	"\tdevice_id\x18\x01 \x01(\tR\bdeviceId\x12(\n" +
	"\x10parent_device_id\x18\x02 \x01(\tR\x0eparentDeviceId\x129\n" +
	"\voper_status\x18\x03 \x01(\x0e2\x18.common.OperStatus.TypesR\n" +
	"operStatus\x12<\n" +
	"\vconn_status\x18\x04 \x01(\x0e2\x1b.common.ConnectStatus.TypesR\n" +
	"connStatus\"\xb0\x01\n" +
	"\tPortState\x12\x1b\n" +
	"\tdevice_id\x18\x01 \x01(\tR\bdeviceId\x122\n" +
	"\tport_type\x18\x02 \x01(\x0e2\x15.device.Port.PortTypeR\bportType\x12\x17\n" +
	"\aport_no\x18\x03 \x01(\rR\x06portNo\x129\n" +
	"\voper_status\x18\x04 \x01(\x0e2\x18.common.OperStatus.TypesR\n" +
	"operStatus\"\x93\x01\n" +
	"\x0fPortStateFilter\x12\x1b\n" +
	"\tdevice_id\x18\x01 \x01(\tR\bdeviceId\x12(\n" +
	"\x10port_type_filter\x18\x02 \x01(\rR\x0eportTypeFilter\x129\n" +
	"\voper_status\x18\x04 \x01(\x0e2\x18.common.OperStatus.TypesR\n" +
	"operStatus\"S\n" +
	"\bPacketIn\x12\x1b\n" +
	"\tdevice_id\x18\x01 \x01(\tR\bdeviceId\x12\x12\n" +
	"\x04port\x18\x02 \x01(\rR\x04port\x12\x16\n" +
	"\x06packet\x18\x03 \x01(\fR\x06packet\"\x83\x01\n" +
	"\tPacketOut\x12\x1b\n" +
	"\tdevice_id\x18\x01 \x01(\tR\bdeviceId\x12$\n" +
	"\x0eegress_port_no\x18\x02 \x01(\rR\fegressPortNo\x123\n" +
	"\x06packet\x18\x03 \x01(\v2\x1b.openflow_13.ofp_packet_outR\x06packet\"C\n" +
	"\fDeviceReason\x12\x1b\n" +
	"\tdevice_id\x18\x01 \x01(\tR\bdeviceId\x12\x16\n" +
	"\x06reason\x18\x02 \x01(\tR\x06reason\"\xce\x01\n" +
	"\tBulkFlows\x12&\n" +
	"\x06device\x18\x01 \x01(\v2\x0e.device.DeviceR\x06device\x12(\n" +
	"\x05flows\x18\x02 \x01(\v2\x12.openflow_13.FlowsR\x05flows\x12/\n" +
	"\x06groups\x18\x03 \x01(\v2\x17.openflow_13.FlowGroupsR\x06groups\x12>\n" +
	"\rflow_metadata\x18\x04 \x01(\v2\x19.openflow_13.FlowMetadataR\fflowMetadata\"\xe1\x01\n" +
	"\x10IncrementalFlows\x12&\n" +
	"\x06device\x18\x01 \x01(\v2\x0e.device.DeviceR\x06device\x12.\n" +
	"\x05flows\x18\x02 \x01(\v2\x18.openflow_13.FlowChangesR\x05flows\x125\n" +
	"\x06groups\x18\x03 \x01(\v2\x1d.openflow_13.FlowGroupChangesR\x06groups\x12>\n" +
	"\rflow_metadata\x18\x04 \x01(\v2\x19.openflow_13.FlowMetadataR\fflowMetadata\"^\n" +
	"\rPmConfigsInfo\x12\x1b\n" +
	"\tdevice_id\x18\x01 \x01(\tR\bdeviceId\x120\n" +
	"\n" +
	"pm_configs\x18\x02 \x01(\v2\x11.device.PmConfigsR\tpmConfigs\"\x88\x01\n" +
	"\x10SwitchCapability\x12)\n" +
	"\x04desc\x18\x01 \x01(\v2\x15.openflow_13.ofp_descR\x04desc\x12I\n" +
	"\x0fswitch_features\x18\x02 \x01(\v2 .openflow_13.ofp_switch_featuresR\x0eswitchFeatures\"k\n" +
	"\x14ImageDownloadMessage\x12&\n" +
	"\x06device\x18\x01 \x01(\v2\x0e.device.DeviceR\x06device\x12+\n" +
	"\x05image\x18\x02 \x01(\v2\x15.device.ImageDownloadR\x05image\"c\n" +
	"\bOMCITest\x12&\n" +
	"\x06device\x18\x01 \x01(\v2\x0e.device.DeviceR\x06device\x12/\n" +
	"\arequest\x18\x02 \x01(\v2\x15.omci.OmciTestRequestR\arequest\"v\n" +
	"\x14SimulateAlarmMessage\x12&\n" +
	"\x06device\x18\x01 \x01(\v2\x0e.device.DeviceR\x06device\x126\n" +
	"\arequest\x18\x02 \x01(\v2\x1c.device.SimulateAlarmRequestR\arequest\"\xb6\x01\n" +
	"\x12GetExtValueMessage\x123\n" +
	"\rparent_device\x18\x01 \x01(\v2\x0e.device.DeviceR\fparentDevice\x121\n" +
	"\fchild_device\x18\x02 \x01(\v2\x0e.device.DeviceR\vchildDevice\x128\n" +
	"\n" +
	"value_type\x18\x03 \x01(\x0e2\x19.extension.ValueType.TypeR\tvalueType\"g\n" +
	"\x12SetExtValueMessage\x12&\n" +
	"\x06device\x18\x01 \x01(\v2\x0e.device.DeviceR\x06device\x12)\n" +
	"\x05value\x18\x03 \x01(\v2\x13.extension.ValueSetR\x05valueBX\n" +
	" org.opencord.voltha.core_adapterZ4github.com/opencord/voltha-protos/v5/go/core_adapterb\x06proto3"

var (
	file_voltha_protos_core_adapter_proto_rawDescOnce sync.Once
	file_voltha_protos_core_adapter_proto_rawDescData []byte
)

func file_voltha_protos_core_adapter_proto_rawDescGZIP() []byte {
	file_voltha_protos_core_adapter_proto_rawDescOnce.Do(func() {
		file_voltha_protos_core_adapter_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_voltha_protos_core_adapter_proto_rawDesc), len(file_voltha_protos_core_adapter_proto_rawDesc)))
	})
	return file_voltha_protos_core_adapter_proto_rawDescData
}

var file_voltha_protos_core_adapter_proto_msgTypes = make([]protoimpl.MessageInfo, 19)
var file_voltha_protos_core_adapter_proto_goTypes = []any{
	(*AdapterRegistration)(nil),           // 0: core_adapter.AdapterRegistration
	(*ChildDeviceFilter)(nil),             // 1: core_adapter.ChildDeviceFilter
	(*PortFilter)(nil),                    // 2: core_adapter.PortFilter
	(*DeviceDiscovery)(nil),               // 3: core_adapter.DeviceDiscovery
	(*DeviceStateFilter)(nil),             // 4: core_adapter.DeviceStateFilter
	(*PortState)(nil),                     // 5: core_adapter.PortState
	(*PortStateFilter)(nil),               // 6: core_adapter.PortStateFilter
	(*PacketIn)(nil),                      // 7: core_adapter.PacketIn
	(*PacketOut)(nil),                     // 8: core_adapter.PacketOut
	(*DeviceReason)(nil),                  // 9: core_adapter.DeviceReason
	(*BulkFlows)(nil),                     // 10: core_adapter.BulkFlows
	(*IncrementalFlows)(nil),              // 11: core_adapter.IncrementalFlows
	(*PmConfigsInfo)(nil),                 // 12: core_adapter.PmConfigsInfo
	(*SwitchCapability)(nil),              // 13: core_adapter.SwitchCapability
	(*ImageDownloadMessage)(nil),          // 14: core_adapter.ImageDownloadMessage
	(*OMCITest)(nil),                      // 15: core_adapter.OMCITest
	(*SimulateAlarmMessage)(nil),          // 16: core_adapter.SimulateAlarmMessage
	(*GetExtValueMessage)(nil),            // 17: core_adapter.GetExtValueMessage
	(*SetExtValueMessage)(nil),            // 18: core_adapter.SetExtValueMessage
	(*voltha.Adapter)(nil),                // 19: adapter.Adapter
	(*voltha.DeviceTypes)(nil),            // 20: device.DeviceTypes
	(voltha.Port_PortType)(0),             // 21: device.Port.PortType
	(common.OperStatus_Types)(0),          // 22: common.OperStatus.Types
	(common.ConnectStatus_Types)(0),       // 23: common.ConnectStatus.Types
	(*openflow_13.OfpPacketOut)(nil),      // 24: openflow_13.ofp_packet_out
	(*voltha.Device)(nil),                 // 25: device.Device
	(*openflow_13.Flows)(nil),             // 26: openflow_13.Flows
	(*openflow_13.FlowGroups)(nil),        // 27: openflow_13.FlowGroups
	(*openflow_13.FlowMetadata)(nil),      // 28: openflow_13.FlowMetadata
	(*openflow_13.FlowChanges)(nil),       // 29: openflow_13.FlowChanges
	(*openflow_13.FlowGroupChanges)(nil),  // 30: openflow_13.FlowGroupChanges
	(*voltha.PmConfigs)(nil),              // 31: device.PmConfigs
	(*openflow_13.OfpDesc)(nil),           // 32: openflow_13.ofp_desc
	(*openflow_13.OfpSwitchFeatures)(nil), // 33: openflow_13.ofp_switch_features
	(*voltha.ImageDownload)(nil),          // 34: device.ImageDownload
	(*omci.OmciTestRequest)(nil),          // 35: omci.OmciTestRequest
	(*voltha.SimulateAlarmRequest)(nil),   // 36: device.SimulateAlarmRequest
	(extension.ValueType_Type)(0),         // 37: extension.ValueType.Type
	(*extension.ValueSet)(nil),            // 38: extension.ValueSet
}
var file_voltha_protos_core_adapter_proto_depIdxs = []int32{
	19, // 0: core_adapter.AdapterRegistration.adapter:type_name -> adapter.Adapter
	20, // 1: core_adapter.AdapterRegistration.dTypes:type_name -> device.DeviceTypes
	21, // 2: core_adapter.PortFilter.port_type:type_name -> device.Port.PortType
	22, // 3: core_adapter.DeviceStateFilter.oper_status:type_name -> common.OperStatus.Types
	23, // 4: core_adapter.DeviceStateFilter.conn_status:type_name -> common.ConnectStatus.Types
	21, // 5: core_adapter.PortState.port_type:type_name -> device.Port.PortType
	22, // 6: core_adapter.PortState.oper_status:type_name -> common.OperStatus.Types
	22, // 7: core_adapter.PortStateFilter.oper_status:type_name -> common.OperStatus.Types
	24, // 8: core_adapter.PacketOut.packet:type_name -> openflow_13.ofp_packet_out
	25, // 9: core_adapter.BulkFlows.device:type_name -> device.Device
	26, // 10: core_adapter.BulkFlows.flows:type_name -> openflow_13.Flows
	27, // 11: core_adapter.BulkFlows.groups:type_name -> openflow_13.FlowGroups
	28, // 12: core_adapter.BulkFlows.flow_metadata:type_name -> openflow_13.FlowMetadata
	25, // 13: core_adapter.IncrementalFlows.device:type_name -> device.Device
	29, // 14: core_adapter.IncrementalFlows.flows:type_name -> openflow_13.FlowChanges
	30, // 15: core_adapter.IncrementalFlows.groups:type_name -> openflow_13.FlowGroupChanges
	28, // 16: core_adapter.IncrementalFlows.flow_metadata:type_name -> openflow_13.FlowMetadata
	31, // 17: core_adapter.PmConfigsInfo.pm_configs:type_name -> device.PmConfigs
	32, // 18: core_adapter.SwitchCapability.desc:type_name -> openflow_13.ofp_desc
	33, // 19: core_adapter.SwitchCapability.switch_features:type_name -> openflow_13.ofp_switch_features
	25, // 20: core_adapter.ImageDownloadMessage.device:type_name -> device.Device
	34, // 21: core_adapter.ImageDownloadMessage.image:type_name -> device.ImageDownload
	25, // 22: core_adapter.OMCITest.device:type_name -> device.Device
	35, // 23: core_adapter.OMCITest.request:type_name -> omci.OmciTestRequest
	25, // 24: core_adapter.SimulateAlarmMessage.device:type_name -> device.Device
	36, // 25: core_adapter.SimulateAlarmMessage.request:type_name -> device.SimulateAlarmRequest
	25, // 26: core_adapter.GetExtValueMessage.parent_device:type_name -> device.Device
	25, // 27: core_adapter.GetExtValueMessage.child_device:type_name -> device.Device
	37, // 28: core_adapter.GetExtValueMessage.value_type:type_name -> extension.ValueType.Type
	25, // 29: core_adapter.SetExtValueMessage.device:type_name -> device.Device
	38, // 30: core_adapter.SetExtValueMessage.value:type_name -> extension.ValueSet
	31, // [31:31] is the sub-list for method output_type
	31, // [31:31] is the sub-list for method input_type
	31, // [31:31] is the sub-list for extension type_name
	31, // [31:31] is the sub-list for extension extendee
	0,  // [0:31] is the sub-list for field type_name
}

func init() { file_voltha_protos_core_adapter_proto_init() }
func file_voltha_protos_core_adapter_proto_init() {
	if File_voltha_protos_core_adapter_proto != nil {
		return
	}
	file_voltha_protos_core_adapter_proto_msgTypes[1].OneofWrappers = []any{}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_voltha_protos_core_adapter_proto_rawDesc), len(file_voltha_protos_core_adapter_proto_rawDesc)),
			NumEnums:      0,
			NumMessages:   19,
			NumExtensions: 0,
			NumServices:   0,
		},
		GoTypes:           file_voltha_protos_core_adapter_proto_goTypes,
		DependencyIndexes: file_voltha_protos_core_adapter_proto_depIdxs,
		MessageInfos:      file_voltha_protos_core_adapter_proto_msgTypes,
	}.Build()
	File_voltha_protos_core_adapter_proto = out.File
	file_voltha_protos_core_adapter_proto_goTypes = nil
	file_voltha_protos_core_adapter_proto_depIdxs = nil
}
