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

package common

import (
	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 TestModeKeys int32

const (
	TestModeKeys_api_test TestModeKeys = 0
)

// Enum value maps for TestModeKeys.
var (
	TestModeKeys_name = map[int32]string{
		0: "api_test",
	}
	TestModeKeys_value = map[string]int32{
		"api_test": 0,
	}
)

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

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

func (TestModeKeys) Descriptor() protoreflect.EnumDescriptor {
	return file_voltha_protos_common_proto_enumTypes[0].Descriptor()
}

func (TestModeKeys) Type() protoreflect.EnumType {
	return &file_voltha_protos_common_proto_enumTypes[0]
}

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

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

// Administrative State
type AdminState_Types int32

const (
	// The administrative state of the device is unknown
	AdminState_UNKNOWN AdminState_Types = 0
	// The device is pre-provisioned into Voltha, but not contacted by it
	AdminState_PREPROVISIONED AdminState_Types = 1
	// The device is enabled for activation and operation
	AdminState_ENABLED AdminState_Types = 2
	// The device is disabled and shall not perform its intended forwarding
	// functions other than being available for re-activation.
	AdminState_DISABLED AdminState_Types = 3
	// The device is in the state of image download
	AdminState_DOWNLOADING_IMAGE AdminState_Types = 4
)

// Enum value maps for AdminState_Types.
var (
	AdminState_Types_name = map[int32]string{
		0: "UNKNOWN",
		1: "PREPROVISIONED",
		2: "ENABLED",
		3: "DISABLED",
		4: "DOWNLOADING_IMAGE",
	}
	AdminState_Types_value = map[string]int32{
		"UNKNOWN":           0,
		"PREPROVISIONED":    1,
		"ENABLED":           2,
		"DISABLED":          3,
		"DOWNLOADING_IMAGE": 4,
	}
)

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

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

func (AdminState_Types) Descriptor() protoreflect.EnumDescriptor {
	return file_voltha_protos_common_proto_enumTypes[1].Descriptor()
}

func (AdminState_Types) Type() protoreflect.EnumType {
	return &file_voltha_protos_common_proto_enumTypes[1]
}

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

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

// Operational Status
type OperStatus_Types int32

const (
	// The status of the device is unknown at this point
	OperStatus_UNKNOWN OperStatus_Types = 0
	// The device has been discovered, but not yet activated
	OperStatus_DISCOVERED OperStatus_Types = 1
	// The device is being activated (booted, rebooted, upgraded, etc.)
	OperStatus_ACTIVATING OperStatus_Types = 2
	// Service impacting tests are being conducted
	OperStatus_TESTING OperStatus_Types = 3
	// The device is up and active
	OperStatus_ACTIVE OperStatus_Types = 4
	// The device has failed and cannot fulfill its intended role
	OperStatus_FAILED OperStatus_Types = 5
	// The device is reconciling
	OperStatus_RECONCILING OperStatus_Types = 6
	// The device is in reconciling failed
	OperStatus_RECONCILING_FAILED OperStatus_Types = 7
	// The device has rebooted
	OperStatus_REBOOTED OperStatus_Types = 8
)

// Enum value maps for OperStatus_Types.
var (
	OperStatus_Types_name = map[int32]string{
		0: "UNKNOWN",
		1: "DISCOVERED",
		2: "ACTIVATING",
		3: "TESTING",
		4: "ACTIVE",
		5: "FAILED",
		6: "RECONCILING",
		7: "RECONCILING_FAILED",
		8: "REBOOTED",
	}
	OperStatus_Types_value = map[string]int32{
		"UNKNOWN":            0,
		"DISCOVERED":         1,
		"ACTIVATING":         2,
		"TESTING":            3,
		"ACTIVE":             4,
		"FAILED":             5,
		"RECONCILING":        6,
		"RECONCILING_FAILED": 7,
		"REBOOTED":           8,
	}
)

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

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

func (OperStatus_Types) Descriptor() protoreflect.EnumDescriptor {
	return file_voltha_protos_common_proto_enumTypes[2].Descriptor()
}

func (OperStatus_Types) Type() protoreflect.EnumType {
	return &file_voltha_protos_common_proto_enumTypes[2]
}

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

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

// Connectivity Status
type ConnectStatus_Types int32

const (
	// The device connectivity status is unknown
	ConnectStatus_UNKNOWN ConnectStatus_Types = 0
	// The device cannot be reached by Voltha
	ConnectStatus_UNREACHABLE ConnectStatus_Types = 1
	// There is live communication between device and Voltha
	ConnectStatus_REACHABLE ConnectStatus_Types = 2
)

// Enum value maps for ConnectStatus_Types.
var (
	ConnectStatus_Types_name = map[int32]string{
		0: "UNKNOWN",
		1: "UNREACHABLE",
		2: "REACHABLE",
	}
	ConnectStatus_Types_value = map[string]int32{
		"UNKNOWN":     0,
		"UNREACHABLE": 1,
		"REACHABLE":   2,
	}
)

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

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

func (ConnectStatus_Types) Descriptor() protoreflect.EnumDescriptor {
	return file_voltha_protos_common_proto_enumTypes[3].Descriptor()
}

func (ConnectStatus_Types) Type() protoreflect.EnumType {
	return &file_voltha_protos_common_proto_enumTypes[3]
}

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

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

type OperationResp_OperationReturnCode int32

const (
	OperationResp_OPERATION_SUCCESS     OperationResp_OperationReturnCode = 0
	OperationResp_OPERATION_FAILURE     OperationResp_OperationReturnCode = 1
	OperationResp_OPERATION_UNSUPPORTED OperationResp_OperationReturnCode = 2
	OperationResp_OPERATION_IN_PROGRESS OperationResp_OperationReturnCode = 3
)

// Enum value maps for OperationResp_OperationReturnCode.
var (
	OperationResp_OperationReturnCode_name = map[int32]string{
		0: "OPERATION_SUCCESS",
		1: "OPERATION_FAILURE",
		2: "OPERATION_UNSUPPORTED",
		3: "OPERATION_IN_PROGRESS",
	}
	OperationResp_OperationReturnCode_value = map[string]int32{
		"OPERATION_SUCCESS":     0,
		"OPERATION_FAILURE":     1,
		"OPERATION_UNSUPPORTED": 2,
		"OPERATION_IN_PROGRESS": 3,
	}
)

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

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

func (OperationResp_OperationReturnCode) Descriptor() protoreflect.EnumDescriptor {
	return file_voltha_protos_common_proto_enumTypes[4].Descriptor()
}

func (OperationResp_OperationReturnCode) Type() protoreflect.EnumType {
	return &file_voltha_protos_common_proto_enumTypes[4]
}

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

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

// Full path for KV store
type Key struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Key           string                 `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Key) ProtoMessage() {}

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

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

// Convey a resource identifier
type ID struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Id            string                 `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ID) ProtoMessage() {}

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

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

// Represents a list of IDs
type IDs struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Items         []*ID                  `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*IDs) ProtoMessage() {}

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

func (x *IDs) GetItems() []*ID {
	if x != nil {
		return x.Items
	}
	return nil
}

type Connection struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// endpoint is the endpoint sending the request
	Endpoint string `protobuf:"bytes,1,opt,name=endpoint,proto3" json:"endpoint,omitempty"`
	// contextInfo represents additional contextual information
	ContextInfo string `protobuf:"bytes,2,opt,name=contextInfo,proto3" json:"contextInfo,omitempty"`
	// keep_alive_interval is used to indicate to the remote endpoint how often it
	// will get a keep alive notification
	KeepAliveInterval int64 `protobuf:"varint,3,opt,name=keep_alive_interval,json=keepAliveInterval,proto3" json:"keep_alive_interval,omitempty"`
	unknownFields     protoimpl.UnknownFields
	sizeCache         protoimpl.SizeCache
}

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

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

func (*Connection) ProtoMessage() {}

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

func (x *Connection) GetEndpoint() string {
	if x != nil {
		return x.Endpoint
	}
	return ""
}

func (x *Connection) GetContextInfo() string {
	if x != nil {
		return x.ContextInfo
	}
	return ""
}

func (x *Connection) GetKeepAliveInterval() int64 {
	if x != nil {
		return x.KeepAliveInterval
	}
	return 0
}

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

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

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

func (*AdminState) ProtoMessage() {}

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

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

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

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

func (*OperStatus) ProtoMessage() {}

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

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

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

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

func (*ConnectStatus) ProtoMessage() {}

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

type OperationResp struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Return code
	Code OperationResp_OperationReturnCode `protobuf:"varint,1,opt,name=code,proto3,enum=common.OperationResp_OperationReturnCode" json:"code,omitempty"`
	// Additional Info
	AdditionalInfo string `protobuf:"bytes,2,opt,name=additional_info,json=additionalInfo,proto3" json:"additional_info,omitempty"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

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

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

func (*OperationResp) ProtoMessage() {}

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

func (x *OperationResp) GetCode() OperationResp_OperationReturnCode {
	if x != nil {
		return x.Code
	}
	return OperationResp_OPERATION_SUCCESS
}

func (x *OperationResp) GetAdditionalInfo() string {
	if x != nil {
		return x.AdditionalInfo
	}
	return ""
}

type PortStatistics struct {
	state   protoimpl.MessageState `protogen:"open.v1"`
	IntfId  uint32                 `protobuf:"fixed32,1,opt,name=intf_id,json=intfId,proto3" json:"intf_id,omitempty"`
	RxBytes uint64                 `protobuf:"fixed64,2,opt,name=rx_bytes,json=rxBytes,proto3" json:"rx_bytes,omitempty"`
	// Deprecated: OLT being a Layer 2 device, use rx_frames (field 17) instead
	//
	// Deprecated: Marked as deprecated in voltha_protos/common.proto.
	RxPackets uint64 `protobuf:"fixed64,3,opt,name=rx_packets,json=rxPackets,proto3" json:"rx_packets,omitempty"`
	// Deprecated: OLT being a Layer 2 device, use rx_ucast_frames (field 63) instead
	//
	// Deprecated: Marked as deprecated in voltha_protos/common.proto.
	RxUcastPackets uint64 `protobuf:"fixed64,4,opt,name=rx_ucast_packets,json=rxUcastPackets,proto3" json:"rx_ucast_packets,omitempty"`
	// Deprecated: OLT being a Layer 2 device, use rx_mcast_frames (field 64) instead
	//
	// Deprecated: Marked as deprecated in voltha_protos/common.proto.
	RxMcastPackets uint64 `protobuf:"fixed64,5,opt,name=rx_mcast_packets,json=rxMcastPackets,proto3" json:"rx_mcast_packets,omitempty"`
	// Deprecated: OLT being a Layer 2 device, use rx_bcast_frames (field 65) instead
	//
	// Deprecated: Marked as deprecated in voltha_protos/common.proto.
	RxBcastPackets uint64 `protobuf:"fixed64,6,opt,name=rx_bcast_packets,json=rxBcastPackets,proto3" json:"rx_bcast_packets,omitempty"`
	// Deprecated: OLT being a Layer 2 device, use rx_error_frames (field 66) instead
	//
	// Deprecated: Marked as deprecated in voltha_protos/common.proto.
	RxErrorPackets          uint64 `protobuf:"fixed64,7,opt,name=rx_error_packets,json=rxErrorPackets,proto3" json:"rx_error_packets,omitempty"`
	RxFrames                uint64 `protobuf:"fixed64,17,opt,name=rx_frames,json=rxFrames,proto3" json:"rx_frames,omitempty"`
	RxFrames_64             uint64 `protobuf:"fixed64,18,opt,name=rx_frames_64,json=rxFrames64,proto3" json:"rx_frames_64,omitempty"`
	RxFrames_65_127         uint64 `protobuf:"fixed64,19,opt,name=rx_frames_65_127,json=rxFrames65127,proto3" json:"rx_frames_65_127,omitempty"`
	RxFrames_128_255        uint64 `protobuf:"fixed64,20,opt,name=rx_frames_128_255,json=rxFrames128255,proto3" json:"rx_frames_128_255,omitempty"`
	RxFrames_256_511        uint64 `protobuf:"fixed64,21,opt,name=rx_frames_256_511,json=rxFrames256511,proto3" json:"rx_frames_256_511,omitempty"`
	RxFrames_512_1023       uint64 `protobuf:"fixed64,22,opt,name=rx_frames_512_1023,json=rxFrames5121023,proto3" json:"rx_frames_512_1023,omitempty"`
	RxFrames_1024_1518      uint64 `protobuf:"fixed64,23,opt,name=rx_frames_1024_1518,json=rxFrames10241518,proto3" json:"rx_frames_1024_1518,omitempty"`
	RxFrames_1519_2047      uint64 `protobuf:"fixed64,24,opt,name=rx_frames_1519_2047,json=rxFrames15192047,proto3" json:"rx_frames_1519_2047,omitempty"`
	RxFrames_2048_4095      uint64 `protobuf:"fixed64,25,opt,name=rx_frames_2048_4095,json=rxFrames20484095,proto3" json:"rx_frames_2048_4095,omitempty"`
	RxFrames_4096_9216      uint64 `protobuf:"fixed64,26,opt,name=rx_frames_4096_9216,json=rxFrames40969216,proto3" json:"rx_frames_4096_9216,omitempty"`
	RxFrames_9217_16383     uint64 `protobuf:"fixed64,27,opt,name=rx_frames_9217_16383,json=rxFrames921716383,proto3" json:"rx_frames_9217_16383,omitempty"`
	RxCrcErrors             uint64 `protobuf:"fixed64,14,opt,name=rx_crc_errors,json=rxCrcErrors,proto3" json:"rx_crc_errors,omitempty"`
	RxUndersizePackets      uint64 `protobuf:"fixed64,39,opt,name=rxUndersizePackets,proto3" json:"rxUndersizePackets,omitempty"`
	RxOversizePackets       uint64 `protobuf:"fixed64,40,opt,name=rxOversizePackets,proto3" json:"rxOversizePackets,omitempty"`
	RxGem                   uint64 `protobuf:"fixed64,43,opt,name=rxGem,proto3" json:"rxGem,omitempty"`
	RxGemDropped            uint64 `protobuf:"fixed64,44,opt,name=rxGemDropped,proto3" json:"rxGemDropped,omitempty"`
	RxGemIdle               uint64 `protobuf:"fixed64,45,opt,name=rxGemIdle,proto3" json:"rxGemIdle,omitempty"`
	RxGemCorrected          uint64 `protobuf:"fixed64,46,opt,name=rxGemCorrected,proto3" json:"rxGemCorrected,omitempty"`
	RxGemIllegal            uint64 `protobuf:"fixed64,47,opt,name=rxGemIllegal,proto3" json:"rxGemIllegal,omitempty"`
	RxFragmentError         uint64 `protobuf:"fixed64,48,opt,name=rxFragmentError,proto3" json:"rxFragmentError,omitempty"`
	RxPacketsDropped        uint64 `protobuf:"fixed64,49,opt,name=rxPacketsDropped,proto3" json:"rxPacketsDropped,omitempty"`
	RxCpuOmciPacketsDropped uint64 `protobuf:"fixed64,50,opt,name=rxCpuOmciPacketsDropped,proto3" json:"rxCpuOmciPacketsDropped,omitempty"`
	RxCpu                   uint64 `protobuf:"fixed64,51,opt,name=rxCpu,proto3" json:"rxCpu,omitempty"`
	RxOmci                  uint64 `protobuf:"fixed64,52,opt,name=rxOmci,proto3" json:"rxOmci,omitempty"`
	RxOmciPacketsCrcError   uint64 `protobuf:"fixed64,53,opt,name=rxOmciPacketsCrcError,proto3" json:"rxOmciPacketsCrcError,omitempty"`
	RxFcsErrorPackets       uint64 `protobuf:"fixed64,62,opt,name=rxFcsErrorPackets,proto3" json:"rxFcsErrorPackets,omitempty"`
	TxBytes                 uint64 `protobuf:"fixed64,8,opt,name=tx_bytes,json=txBytes,proto3" json:"tx_bytes,omitempty"`
	// Deprecated: OLT being a Layer 2 device, use tx_frames (field 28) instead
	//
	// Deprecated: Marked as deprecated in voltha_protos/common.proto.
	TxPackets uint64 `protobuf:"fixed64,9,opt,name=tx_packets,json=txPackets,proto3" json:"tx_packets,omitempty"`
	// Deprecated: OLT being a Layer 2 device, use tx_ucast_frames (field 68) instead
	//
	// Deprecated: Marked as deprecated in voltha_protos/common.proto.
	TxUcastPackets uint64 `protobuf:"fixed64,10,opt,name=tx_ucast_packets,json=txUcastPackets,proto3" json:"tx_ucast_packets,omitempty"`
	// Deprecated: OLT being a Layer 2 device, use tx_mcast_frames (field 69) instead
	//
	// Deprecated: Marked as deprecated in voltha_protos/common.proto.
	TxMcastPackets uint64 `protobuf:"fixed64,11,opt,name=tx_mcast_packets,json=txMcastPackets,proto3" json:"tx_mcast_packets,omitempty"`
	// Deprecated: OLT being a Layer 2 device, use tx_bcast_frames (field 70) instead
	//
	// Deprecated: Marked as deprecated in voltha_protos/common.proto.
	TxBcastPackets uint64 `protobuf:"fixed64,12,opt,name=tx_bcast_packets,json=txBcastPackets,proto3" json:"tx_bcast_packets,omitempty"`
	// Deprecated: OLT being a Layer 2 device, use tx_error_frames (field 71) instead
	//
	// Deprecated: Marked as deprecated in voltha_protos/common.proto.
	TxErrorPackets         uint64 `protobuf:"fixed64,13,opt,name=tx_error_packets,json=txErrorPackets,proto3" json:"tx_error_packets,omitempty"`
	TxFrames               uint64 `protobuf:"fixed64,28,opt,name=tx_frames,json=txFrames,proto3" json:"tx_frames,omitempty"`
	TxFrames_64            uint64 `protobuf:"fixed64,29,opt,name=tx_frames_64,json=txFrames64,proto3" json:"tx_frames_64,omitempty"`
	TxFrames_65_127        uint64 `protobuf:"fixed64,30,opt,name=tx_frames_65_127,json=txFrames65127,proto3" json:"tx_frames_65_127,omitempty"`
	TxFrames_128_255       uint64 `protobuf:"fixed64,31,opt,name=tx_frames_128_255,json=txFrames128255,proto3" json:"tx_frames_128_255,omitempty"`
	TxFrames_256_511       uint64 `protobuf:"fixed64,32,opt,name=tx_frames_256_511,json=txFrames256511,proto3" json:"tx_frames_256_511,omitempty"`
	TxFrames_512_1023      uint64 `protobuf:"fixed64,33,opt,name=tx_frames_512_1023,json=txFrames5121023,proto3" json:"tx_frames_512_1023,omitempty"`
	TxFrames_1024_1518     uint64 `protobuf:"fixed64,34,opt,name=tx_frames_1024_1518,json=txFrames10241518,proto3" json:"tx_frames_1024_1518,omitempty"`
	TxFrames_1519_2047     uint64 `protobuf:"fixed64,35,opt,name=tx_frames_1519_2047,json=txFrames15192047,proto3" json:"tx_frames_1519_2047,omitempty"`
	TxFrames_2048_4095     uint64 `protobuf:"fixed64,36,opt,name=tx_frames_2048_4095,json=txFrames20484095,proto3" json:"tx_frames_2048_4095,omitempty"`
	TxFrames_4096_9216     uint64 `protobuf:"fixed64,37,opt,name=tx_frames_4096_9216,json=txFrames40969216,proto3" json:"tx_frames_4096_9216,omitempty"`
	TxFrames_9217_16383    uint64 `protobuf:"fixed64,38,opt,name=tx_frames_9217_16383,json=txFrames921716383,proto3" json:"tx_frames_9217_16383,omitempty"`
	TxUndersizePackets     uint64 `protobuf:"fixed64,41,opt,name=txUndersizePackets,proto3" json:"txUndersizePackets,omitempty"`
	TxOversizePackets      uint64 `protobuf:"fixed64,42,opt,name=txOversizePackets,proto3" json:"txOversizePackets,omitempty"`
	TxGem                  uint64 `protobuf:"fixed64,54,opt,name=txGem,proto3" json:"txGem,omitempty"`
	TxCpu                  uint64 `protobuf:"fixed64,55,opt,name=txCpu,proto3" json:"txCpu,omitempty"`
	TxOmci                 uint64 `protobuf:"fixed64,56,opt,name=txOmci,proto3" json:"txOmci,omitempty"`
	TxDroppedIllegalLength uint64 `protobuf:"fixed64,57,opt,name=txDroppedIllegalLength,proto3" json:"txDroppedIllegalLength,omitempty"`
	TxDroppedTpidMiss      uint64 `protobuf:"fixed64,58,opt,name=txDroppedTpidMiss,proto3" json:"txDroppedTpidMiss,omitempty"`
	TxDroppedVidMiss       uint64 `protobuf:"fixed64,59,opt,name=txDroppedVidMiss,proto3" json:"txDroppedVidMiss,omitempty"`
	TxDroppedTotal         uint64 `protobuf:"fixed64,60,opt,name=txDroppedTotal,proto3" json:"txDroppedTotal,omitempty"`
	BipErrors              uint64 `protobuf:"fixed64,15,opt,name=bip_errors,json=bipErrors,proto3" json:"bip_errors,omitempty"`
	BipUnits               uint64 `protobuf:"fixed64,61,opt,name=bip_units,json=bipUnits,proto3" json:"bip_units,omitempty"`
	Timestamp              uint32 `protobuf:"fixed32,16,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	RxUcastFrames          uint64 `protobuf:"fixed64,63,opt,name=rx_ucast_frames,json=rxUcastFrames,proto3" json:"rx_ucast_frames,omitempty"`
	RxMcastFrames          uint64 `protobuf:"fixed64,64,opt,name=rx_mcast_frames,json=rxMcastFrames,proto3" json:"rx_mcast_frames,omitempty"`
	RxBcastFrames          uint64 `protobuf:"fixed64,65,opt,name=rx_bcast_frames,json=rxBcastFrames,proto3" json:"rx_bcast_frames,omitempty"`
	RxErrorFrames          uint64 `protobuf:"fixed64,66,opt,name=rx_error_frames,json=rxErrorFrames,proto3" json:"rx_error_frames,omitempty"`
	RxRightFrames          uint64 `protobuf:"fixed64,67,opt,name=rx_right_frames,json=rxRightFrames,proto3" json:"rx_right_frames,omitempty"`
	TxUcastFrames          uint64 `protobuf:"fixed64,68,opt,name=tx_ucast_frames,json=txUcastFrames,proto3" json:"tx_ucast_frames,omitempty"`
	TxMcastFrames          uint64 `protobuf:"fixed64,69,opt,name=tx_mcast_frames,json=txMcastFrames,proto3" json:"tx_mcast_frames,omitempty"`
	TxBcastFrames          uint64 `protobuf:"fixed64,70,opt,name=tx_bcast_frames,json=txBcastFrames,proto3" json:"tx_bcast_frames,omitempty"`
	TxErrorFrames          uint64 `protobuf:"fixed64,71,opt,name=tx_error_frames,json=txErrorFrames,proto3" json:"tx_error_frames,omitempty"`
	RxDiscardedFrames      uint64 `protobuf:"fixed64,72,opt,name=rx_discarded_frames,json=rxDiscardedFrames,proto3" json:"rx_discarded_frames,omitempty"`
	unknownFields          protoimpl.UnknownFields
	sizeCache              protoimpl.SizeCache
}

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

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

func (*PortStatistics) ProtoMessage() {}

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

func (x *PortStatistics) GetIntfId() uint32 {
	if x != nil {
		return x.IntfId
	}
	return 0
}

func (x *PortStatistics) GetRxBytes() uint64 {
	if x != nil {
		return x.RxBytes
	}
	return 0
}

// Deprecated: Marked as deprecated in voltha_protos/common.proto.
func (x *PortStatistics) GetRxPackets() uint64 {
	if x != nil {
		return x.RxPackets
	}
	return 0
}

// Deprecated: Marked as deprecated in voltha_protos/common.proto.
func (x *PortStatistics) GetRxUcastPackets() uint64 {
	if x != nil {
		return x.RxUcastPackets
	}
	return 0
}

// Deprecated: Marked as deprecated in voltha_protos/common.proto.
func (x *PortStatistics) GetRxMcastPackets() uint64 {
	if x != nil {
		return x.RxMcastPackets
	}
	return 0
}

// Deprecated: Marked as deprecated in voltha_protos/common.proto.
func (x *PortStatistics) GetRxBcastPackets() uint64 {
	if x != nil {
		return x.RxBcastPackets
	}
	return 0
}

// Deprecated: Marked as deprecated in voltha_protos/common.proto.
func (x *PortStatistics) GetRxErrorPackets() uint64 {
	if x != nil {
		return x.RxErrorPackets
	}
	return 0
}

func (x *PortStatistics) GetRxFrames() uint64 {
	if x != nil {
		return x.RxFrames
	}
	return 0
}

func (x *PortStatistics) GetRxFrames_64() uint64 {
	if x != nil {
		return x.RxFrames_64
	}
	return 0
}

func (x *PortStatistics) GetRxFrames_65_127() uint64 {
	if x != nil {
		return x.RxFrames_65_127
	}
	return 0
}

func (x *PortStatistics) GetRxFrames_128_255() uint64 {
	if x != nil {
		return x.RxFrames_128_255
	}
	return 0
}

func (x *PortStatistics) GetRxFrames_256_511() uint64 {
	if x != nil {
		return x.RxFrames_256_511
	}
	return 0
}

func (x *PortStatistics) GetRxFrames_512_1023() uint64 {
	if x != nil {
		return x.RxFrames_512_1023
	}
	return 0
}

func (x *PortStatistics) GetRxFrames_1024_1518() uint64 {
	if x != nil {
		return x.RxFrames_1024_1518
	}
	return 0
}

func (x *PortStatistics) GetRxFrames_1519_2047() uint64 {
	if x != nil {
		return x.RxFrames_1519_2047
	}
	return 0
}

func (x *PortStatistics) GetRxFrames_2048_4095() uint64 {
	if x != nil {
		return x.RxFrames_2048_4095
	}
	return 0
}

func (x *PortStatistics) GetRxFrames_4096_9216() uint64 {
	if x != nil {
		return x.RxFrames_4096_9216
	}
	return 0
}

func (x *PortStatistics) GetRxFrames_9217_16383() uint64 {
	if x != nil {
		return x.RxFrames_9217_16383
	}
	return 0
}

func (x *PortStatistics) GetRxCrcErrors() uint64 {
	if x != nil {
		return x.RxCrcErrors
	}
	return 0
}

func (x *PortStatistics) GetRxUndersizePackets() uint64 {
	if x != nil {
		return x.RxUndersizePackets
	}
	return 0
}

func (x *PortStatistics) GetRxOversizePackets() uint64 {
	if x != nil {
		return x.RxOversizePackets
	}
	return 0
}

func (x *PortStatistics) GetRxGem() uint64 {
	if x != nil {
		return x.RxGem
	}
	return 0
}

func (x *PortStatistics) GetRxGemDropped() uint64 {
	if x != nil {
		return x.RxGemDropped
	}
	return 0
}

func (x *PortStatistics) GetRxGemIdle() uint64 {
	if x != nil {
		return x.RxGemIdle
	}
	return 0
}

func (x *PortStatistics) GetRxGemCorrected() uint64 {
	if x != nil {
		return x.RxGemCorrected
	}
	return 0
}

func (x *PortStatistics) GetRxGemIllegal() uint64 {
	if x != nil {
		return x.RxGemIllegal
	}
	return 0
}

func (x *PortStatistics) GetRxFragmentError() uint64 {
	if x != nil {
		return x.RxFragmentError
	}
	return 0
}

func (x *PortStatistics) GetRxPacketsDropped() uint64 {
	if x != nil {
		return x.RxPacketsDropped
	}
	return 0
}

func (x *PortStatistics) GetRxCpuOmciPacketsDropped() uint64 {
	if x != nil {
		return x.RxCpuOmciPacketsDropped
	}
	return 0
}

func (x *PortStatistics) GetRxCpu() uint64 {
	if x != nil {
		return x.RxCpu
	}
	return 0
}

func (x *PortStatistics) GetRxOmci() uint64 {
	if x != nil {
		return x.RxOmci
	}
	return 0
}

func (x *PortStatistics) GetRxOmciPacketsCrcError() uint64 {
	if x != nil {
		return x.RxOmciPacketsCrcError
	}
	return 0
}

func (x *PortStatistics) GetRxFcsErrorPackets() uint64 {
	if x != nil {
		return x.RxFcsErrorPackets
	}
	return 0
}

func (x *PortStatistics) GetTxBytes() uint64 {
	if x != nil {
		return x.TxBytes
	}
	return 0
}

// Deprecated: Marked as deprecated in voltha_protos/common.proto.
func (x *PortStatistics) GetTxPackets() uint64 {
	if x != nil {
		return x.TxPackets
	}
	return 0
}

// Deprecated: Marked as deprecated in voltha_protos/common.proto.
func (x *PortStatistics) GetTxUcastPackets() uint64 {
	if x != nil {
		return x.TxUcastPackets
	}
	return 0
}

// Deprecated: Marked as deprecated in voltha_protos/common.proto.
func (x *PortStatistics) GetTxMcastPackets() uint64 {
	if x != nil {
		return x.TxMcastPackets
	}
	return 0
}

// Deprecated: Marked as deprecated in voltha_protos/common.proto.
func (x *PortStatistics) GetTxBcastPackets() uint64 {
	if x != nil {
		return x.TxBcastPackets
	}
	return 0
}

// Deprecated: Marked as deprecated in voltha_protos/common.proto.
func (x *PortStatistics) GetTxErrorPackets() uint64 {
	if x != nil {
		return x.TxErrorPackets
	}
	return 0
}

func (x *PortStatistics) GetTxFrames() uint64 {
	if x != nil {
		return x.TxFrames
	}
	return 0
}

func (x *PortStatistics) GetTxFrames_64() uint64 {
	if x != nil {
		return x.TxFrames_64
	}
	return 0
}

func (x *PortStatistics) GetTxFrames_65_127() uint64 {
	if x != nil {
		return x.TxFrames_65_127
	}
	return 0
}

func (x *PortStatistics) GetTxFrames_128_255() uint64 {
	if x != nil {
		return x.TxFrames_128_255
	}
	return 0
}

func (x *PortStatistics) GetTxFrames_256_511() uint64 {
	if x != nil {
		return x.TxFrames_256_511
	}
	return 0
}

func (x *PortStatistics) GetTxFrames_512_1023() uint64 {
	if x != nil {
		return x.TxFrames_512_1023
	}
	return 0
}

func (x *PortStatistics) GetTxFrames_1024_1518() uint64 {
	if x != nil {
		return x.TxFrames_1024_1518
	}
	return 0
}

func (x *PortStatistics) GetTxFrames_1519_2047() uint64 {
	if x != nil {
		return x.TxFrames_1519_2047
	}
	return 0
}

func (x *PortStatistics) GetTxFrames_2048_4095() uint64 {
	if x != nil {
		return x.TxFrames_2048_4095
	}
	return 0
}

func (x *PortStatistics) GetTxFrames_4096_9216() uint64 {
	if x != nil {
		return x.TxFrames_4096_9216
	}
	return 0
}

func (x *PortStatistics) GetTxFrames_9217_16383() uint64 {
	if x != nil {
		return x.TxFrames_9217_16383
	}
	return 0
}

func (x *PortStatistics) GetTxUndersizePackets() uint64 {
	if x != nil {
		return x.TxUndersizePackets
	}
	return 0
}

func (x *PortStatistics) GetTxOversizePackets() uint64 {
	if x != nil {
		return x.TxOversizePackets
	}
	return 0
}

func (x *PortStatistics) GetTxGem() uint64 {
	if x != nil {
		return x.TxGem
	}
	return 0
}

func (x *PortStatistics) GetTxCpu() uint64 {
	if x != nil {
		return x.TxCpu
	}
	return 0
}

func (x *PortStatistics) GetTxOmci() uint64 {
	if x != nil {
		return x.TxOmci
	}
	return 0
}

func (x *PortStatistics) GetTxDroppedIllegalLength() uint64 {
	if x != nil {
		return x.TxDroppedIllegalLength
	}
	return 0
}

func (x *PortStatistics) GetTxDroppedTpidMiss() uint64 {
	if x != nil {
		return x.TxDroppedTpidMiss
	}
	return 0
}

func (x *PortStatistics) GetTxDroppedVidMiss() uint64 {
	if x != nil {
		return x.TxDroppedVidMiss
	}
	return 0
}

func (x *PortStatistics) GetTxDroppedTotal() uint64 {
	if x != nil {
		return x.TxDroppedTotal
	}
	return 0
}

func (x *PortStatistics) GetBipErrors() uint64 {
	if x != nil {
		return x.BipErrors
	}
	return 0
}

func (x *PortStatistics) GetBipUnits() uint64 {
	if x != nil {
		return x.BipUnits
	}
	return 0
}

func (x *PortStatistics) GetTimestamp() uint32 {
	if x != nil {
		return x.Timestamp
	}
	return 0
}

func (x *PortStatistics) GetRxUcastFrames() uint64 {
	if x != nil {
		return x.RxUcastFrames
	}
	return 0
}

func (x *PortStatistics) GetRxMcastFrames() uint64 {
	if x != nil {
		return x.RxMcastFrames
	}
	return 0
}

func (x *PortStatistics) GetRxBcastFrames() uint64 {
	if x != nil {
		return x.RxBcastFrames
	}
	return 0
}

func (x *PortStatistics) GetRxErrorFrames() uint64 {
	if x != nil {
		return x.RxErrorFrames
	}
	return 0
}

func (x *PortStatistics) GetRxRightFrames() uint64 {
	if x != nil {
		return x.RxRightFrames
	}
	return 0
}

func (x *PortStatistics) GetTxUcastFrames() uint64 {
	if x != nil {
		return x.TxUcastFrames
	}
	return 0
}

func (x *PortStatistics) GetTxMcastFrames() uint64 {
	if x != nil {
		return x.TxMcastFrames
	}
	return 0
}

func (x *PortStatistics) GetTxBcastFrames() uint64 {
	if x != nil {
		return x.TxBcastFrames
	}
	return 0
}

func (x *PortStatistics) GetTxErrorFrames() uint64 {
	if x != nil {
		return x.TxErrorFrames
	}
	return 0
}

func (x *PortStatistics) GetRxDiscardedFrames() uint64 {
	if x != nil {
		return x.RxDiscardedFrames
	}
	return 0
}

var File_voltha_protos_common_proto protoreflect.FileDescriptor

const file_voltha_protos_common_proto_rawDesc = "" +
	"\n" +
	"\x1avoltha_protos/common.proto\x12\x06common\"\x17\n" +
	"\x03Key\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\"\x14\n" +
	"\x02ID\x12\x0e\n" +
	"\x02id\x18\x01 \x01(\tR\x02id\"'\n" +
	"\x03IDs\x12 \n" +
	"\x05items\x18\x01 \x03(\v2\n" +
	".common.IDR\x05items\"z\n" +
	"\n" +
	"Connection\x12\x1a\n" +
	"\bendpoint\x18\x01 \x01(\tR\bendpoint\x12 \n" +
	"\vcontextInfo\x18\x02 \x01(\tR\vcontextInfo\x12.\n" +
	"\x13keep_alive_interval\x18\x03 \x01(\x03R\x11keepAliveInterval\"h\n" +
	"\n" +
	"AdminState\"Z\n" +
	"\x05Types\x12\v\n" +
	"\aUNKNOWN\x10\x00\x12\x12\n" +
	"\x0ePREPROVISIONED\x10\x01\x12\v\n" +
	"\aENABLED\x10\x02\x12\f\n" +
	"\bDISABLED\x10\x03\x12\x15\n" +
	"\x11DOWNLOADING_IMAGE\x10\x04\"\x9f\x01\n" +
	"\n" +
	"OperStatus\"\x90\x01\n" +
	"\x05Types\x12\v\n" +
	"\aUNKNOWN\x10\x00\x12\x0e\n" +
	"\n" +
	"DISCOVERED\x10\x01\x12\x0e\n" +
	"\n" +
	"ACTIVATING\x10\x02\x12\v\n" +
	"\aTESTING\x10\x03\x12\n" +
	"\n" +
	"\x06ACTIVE\x10\x04\x12\n" +
	"\n" +
	"\x06FAILED\x10\x05\x12\x0f\n" +
	"\vRECONCILING\x10\x06\x12\x16\n" +
	"\x12RECONCILING_FAILED\x10\a\x12\f\n" +
	"\bREBOOTED\x10\b\"E\n" +
	"\rConnectStatus\"4\n" +
	"\x05Types\x12\v\n" +
	"\aUNKNOWN\x10\x00\x12\x0f\n" +
	"\vUNREACHABLE\x10\x01\x12\r\n" +
	"\tREACHABLE\x10\x02\"\xf2\x01\n" +
	"\rOperationResp\x12=\n" +
	"\x04code\x18\x01 \x01(\x0e2).common.OperationResp.OperationReturnCodeR\x04code\x12'\n" +
	"\x0fadditional_info\x18\x02 \x01(\tR\x0eadditionalInfo\"y\n" +
	"\x13OperationReturnCode\x12\x15\n" +
	"\x11OPERATION_SUCCESS\x10\x00\x12\x15\n" +
	"\x11OPERATION_FAILURE\x10\x01\x12\x19\n" +
	"\x15OPERATION_UNSUPPORTED\x10\x02\x12\x19\n" +
	"\x15OPERATION_IN_PROGRESS\x10\x03\"\xdb\x16\n" +
	"\x0ePortStatistics\x12\x17\n" +
	"\aintf_id\x18\x01 \x01(\aR\x06intfId\x12\x19\n" +
	"\brx_bytes\x18\x02 \x01(\x06R\arxBytes\x12!\n" +
	"\n" +
	"rx_packets\x18\x03 \x01(\x06B\x02\x18\x01R\trxPackets\x12,\n" +
	"\x10rx_ucast_packets\x18\x04 \x01(\x06B\x02\x18\x01R\x0erxUcastPackets\x12,\n" +
	"\x10rx_mcast_packets\x18\x05 \x01(\x06B\x02\x18\x01R\x0erxMcastPackets\x12,\n" +
	"\x10rx_bcast_packets\x18\x06 \x01(\x06B\x02\x18\x01R\x0erxBcastPackets\x12,\n" +
	"\x10rx_error_packets\x18\a \x01(\x06B\x02\x18\x01R\x0erxErrorPackets\x12\x1b\n" +
	"\trx_frames\x18\x11 \x01(\x06R\brxFrames\x12 \n" +
	"\frx_frames_64\x18\x12 \x01(\x06R\n" +
	"rxFrames64\x12'\n" +
	"\x10rx_frames_65_127\x18\x13 \x01(\x06R\rrxFrames65127\x12)\n" +
	"\x11rx_frames_128_255\x18\x14 \x01(\x06R\x0erxFrames128255\x12)\n" +
	"\x11rx_frames_256_511\x18\x15 \x01(\x06R\x0erxFrames256511\x12+\n" +
	"\x12rx_frames_512_1023\x18\x16 \x01(\x06R\x0frxFrames5121023\x12-\n" +
	"\x13rx_frames_1024_1518\x18\x17 \x01(\x06R\x10rxFrames10241518\x12-\n" +
	"\x13rx_frames_1519_2047\x18\x18 \x01(\x06R\x10rxFrames15192047\x12-\n" +
	"\x13rx_frames_2048_4095\x18\x19 \x01(\x06R\x10rxFrames20484095\x12-\n" +
	"\x13rx_frames_4096_9216\x18\x1a \x01(\x06R\x10rxFrames40969216\x12/\n" +
	"\x14rx_frames_9217_16383\x18\x1b \x01(\x06R\x11rxFrames921716383\x12\"\n" +
	"\rrx_crc_errors\x18\x0e \x01(\x06R\vrxCrcErrors\x12.\n" +
	"\x12rxUndersizePackets\x18' \x01(\x06R\x12rxUndersizePackets\x12,\n" +
	"\x11rxOversizePackets\x18( \x01(\x06R\x11rxOversizePackets\x12\x14\n" +
	"\x05rxGem\x18+ \x01(\x06R\x05rxGem\x12\"\n" +
	"\frxGemDropped\x18, \x01(\x06R\frxGemDropped\x12\x1c\n" +
	"\trxGemIdle\x18- \x01(\x06R\trxGemIdle\x12&\n" +
	"\x0erxGemCorrected\x18. \x01(\x06R\x0erxGemCorrected\x12\"\n" +
	"\frxGemIllegal\x18/ \x01(\x06R\frxGemIllegal\x12(\n" +
	"\x0frxFragmentError\x180 \x01(\x06R\x0frxFragmentError\x12*\n" +
	"\x10rxPacketsDropped\x181 \x01(\x06R\x10rxPacketsDropped\x128\n" +
	"\x17rxCpuOmciPacketsDropped\x182 \x01(\x06R\x17rxCpuOmciPacketsDropped\x12\x14\n" +
	"\x05rxCpu\x183 \x01(\x06R\x05rxCpu\x12\x16\n" +
	"\x06rxOmci\x184 \x01(\x06R\x06rxOmci\x124\n" +
	"\x15rxOmciPacketsCrcError\x185 \x01(\x06R\x15rxOmciPacketsCrcError\x12,\n" +
	"\x11rxFcsErrorPackets\x18> \x01(\x06R\x11rxFcsErrorPackets\x12\x19\n" +
	"\btx_bytes\x18\b \x01(\x06R\atxBytes\x12!\n" +
	"\n" +
	"tx_packets\x18\t \x01(\x06B\x02\x18\x01R\ttxPackets\x12,\n" +
	"\x10tx_ucast_packets\x18\n" +
	" \x01(\x06B\x02\x18\x01R\x0etxUcastPackets\x12,\n" +
	"\x10tx_mcast_packets\x18\v \x01(\x06B\x02\x18\x01R\x0etxMcastPackets\x12,\n" +
	"\x10tx_bcast_packets\x18\f \x01(\x06B\x02\x18\x01R\x0etxBcastPackets\x12,\n" +
	"\x10tx_error_packets\x18\r \x01(\x06B\x02\x18\x01R\x0etxErrorPackets\x12\x1b\n" +
	"\ttx_frames\x18\x1c \x01(\x06R\btxFrames\x12 \n" +
	"\ftx_frames_64\x18\x1d \x01(\x06R\n" +
	"txFrames64\x12'\n" +
	"\x10tx_frames_65_127\x18\x1e \x01(\x06R\rtxFrames65127\x12)\n" +
	"\x11tx_frames_128_255\x18\x1f \x01(\x06R\x0etxFrames128255\x12)\n" +
	"\x11tx_frames_256_511\x18  \x01(\x06R\x0etxFrames256511\x12+\n" +
	"\x12tx_frames_512_1023\x18! \x01(\x06R\x0ftxFrames5121023\x12-\n" +
	"\x13tx_frames_1024_1518\x18\" \x01(\x06R\x10txFrames10241518\x12-\n" +
	"\x13tx_frames_1519_2047\x18# \x01(\x06R\x10txFrames15192047\x12-\n" +
	"\x13tx_frames_2048_4095\x18$ \x01(\x06R\x10txFrames20484095\x12-\n" +
	"\x13tx_frames_4096_9216\x18% \x01(\x06R\x10txFrames40969216\x12/\n" +
	"\x14tx_frames_9217_16383\x18& \x01(\x06R\x11txFrames921716383\x12.\n" +
	"\x12txUndersizePackets\x18) \x01(\x06R\x12txUndersizePackets\x12,\n" +
	"\x11txOversizePackets\x18* \x01(\x06R\x11txOversizePackets\x12\x14\n" +
	"\x05txGem\x186 \x01(\x06R\x05txGem\x12\x14\n" +
	"\x05txCpu\x187 \x01(\x06R\x05txCpu\x12\x16\n" +
	"\x06txOmci\x188 \x01(\x06R\x06txOmci\x126\n" +
	"\x16txDroppedIllegalLength\x189 \x01(\x06R\x16txDroppedIllegalLength\x12,\n" +
	"\x11txDroppedTpidMiss\x18: \x01(\x06R\x11txDroppedTpidMiss\x12*\n" +
	"\x10txDroppedVidMiss\x18; \x01(\x06R\x10txDroppedVidMiss\x12&\n" +
	"\x0etxDroppedTotal\x18< \x01(\x06R\x0etxDroppedTotal\x12\x1d\n" +
	"\n" +
	"bip_errors\x18\x0f \x01(\x06R\tbipErrors\x12\x1b\n" +
	"\tbip_units\x18= \x01(\x06R\bbipUnits\x12\x1c\n" +
	"\ttimestamp\x18\x10 \x01(\aR\ttimestamp\x12&\n" +
	"\x0frx_ucast_frames\x18? \x01(\x06R\rrxUcastFrames\x12&\n" +
	"\x0frx_mcast_frames\x18@ \x01(\x06R\rrxMcastFrames\x12&\n" +
	"\x0frx_bcast_frames\x18A \x01(\x06R\rrxBcastFrames\x12&\n" +
	"\x0frx_error_frames\x18B \x01(\x06R\rrxErrorFrames\x12&\n" +
	"\x0frx_right_frames\x18C \x01(\x06R\rrxRightFrames\x12&\n" +
	"\x0ftx_ucast_frames\x18D \x01(\x06R\rtxUcastFrames\x12&\n" +
	"\x0ftx_mcast_frames\x18E \x01(\x06R\rtxMcastFrames\x12&\n" +
	"\x0ftx_bcast_frames\x18F \x01(\x06R\rtxBcastFrames\x12&\n" +
	"\x0ftx_error_frames\x18G \x01(\x06R\rtxErrorFrames\x12.\n" +
	"\x13rx_discarded_frames\x18H \x01(\x06R\x11rxDiscardedFrames*\x1c\n" +
	"\fTestModeKeys\x12\f\n" +
	"\bapi_test\x10\x00BE\n" +
	"\x13org.opencord.volthaZ.github.com/opencord/voltha-protos/v5/go/commonb\x06proto3"

var (
	file_voltha_protos_common_proto_rawDescOnce sync.Once
	file_voltha_protos_common_proto_rawDescData []byte
)

func file_voltha_protos_common_proto_rawDescGZIP() []byte {
	file_voltha_protos_common_proto_rawDescOnce.Do(func() {
		file_voltha_protos_common_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_voltha_protos_common_proto_rawDesc), len(file_voltha_protos_common_proto_rawDesc)))
	})
	return file_voltha_protos_common_proto_rawDescData
}

var file_voltha_protos_common_proto_enumTypes = make([]protoimpl.EnumInfo, 5)
var file_voltha_protos_common_proto_msgTypes = make([]protoimpl.MessageInfo, 9)
var file_voltha_protos_common_proto_goTypes = []any{
	(TestModeKeys)(0),                      // 0: common.TestModeKeys
	(AdminState_Types)(0),                  // 1: common.AdminState.Types
	(OperStatus_Types)(0),                  // 2: common.OperStatus.Types
	(ConnectStatus_Types)(0),               // 3: common.ConnectStatus.Types
	(OperationResp_OperationReturnCode)(0), // 4: common.OperationResp.OperationReturnCode
	(*Key)(nil),                            // 5: common.Key
	(*ID)(nil),                             // 6: common.ID
	(*IDs)(nil),                            // 7: common.IDs
	(*Connection)(nil),                     // 8: common.Connection
	(*AdminState)(nil),                     // 9: common.AdminState
	(*OperStatus)(nil),                     // 10: common.OperStatus
	(*ConnectStatus)(nil),                  // 11: common.ConnectStatus
	(*OperationResp)(nil),                  // 12: common.OperationResp
	(*PortStatistics)(nil),                 // 13: common.PortStatistics
}
var file_voltha_protos_common_proto_depIdxs = []int32{
	6, // 0: common.IDs.items:type_name -> common.ID
	4, // 1: common.OperationResp.code:type_name -> common.OperationResp.OperationReturnCode
	2, // [2:2] is the sub-list for method output_type
	2, // [2:2] is the sub-list for method input_type
	2, // [2:2] is the sub-list for extension type_name
	2, // [2:2] is the sub-list for extension extendee
	0, // [0:2] is the sub-list for field type_name
}

func init() { file_voltha_protos_common_proto_init() }
func file_voltha_protos_common_proto_init() {
	if File_voltha_protos_common_proto != nil {
		return
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_voltha_protos_common_proto_rawDesc), len(file_voltha_protos_common_proto_rawDesc)),
			NumEnums:      5,
			NumMessages:   9,
			NumExtensions: 0,
			NumServices:   0,
		},
		GoTypes:           file_voltha_protos_common_proto_goTypes,
		DependencyIndexes: file_voltha_protos_common_proto_depIdxs,
		EnumInfos:         file_voltha_protos_common_proto_enumTypes,
		MessageInfos:      file_voltha_protos_common_proto_msgTypes,
	}.Build()
	File_voltha_protos_common_proto = out.File
	file_voltha_protos_common_proto_goTypes = nil
	file_voltha_protos_common_proto_depIdxs = nil
}
