diff --git a/netopeer/voltha-grpc-client/README.md b/netopeer/voltha-grpc-client/README.md
new file mode 100644
index 0000000..a7e00db
--- /dev/null
+++ b/netopeer/voltha-grpc-client/README.md
@@ -0,0 +1,39 @@
+Voltha Golang GRPC Client
+-------------------------
+
+### Introduction
+
+This GoLang library is meant to be used as a layer between C libraries that need to interact with 
+Voltha.  
+
+The Voltha GRPC Go api was generated by first copying all the voltha .proto files located under:
+
+```
+../../voltha/protos
+```
+
+Followed by the execution of the command:
+
+```
+protoc --go_out=plugins=grpc:. *.proto
+```
+
+### TODO(s)
+
+* At the moment, the resulting API files had to be manually fixed to obtain a working solution.
+There were conflicting imports throughout the file.  It still needs to be investigated
+
+* The user-facing API, i.e. the exported methods with the main voltha.go file, need to be 
+manually added.  Only a few commands have been completed as it requires a lot of effort to 
+translate between the GRPC data model to C model that can be used by C libraries.
+
+* As a first attempt to auto-generate some of the code, a utility executable (generate-c-header
+.go) was implemented to create the C header that defines all the necessary C data structures 
+based on the available Voltha GRPC data structures.  This utility still needs some polishing.
+
+
+
+
+
+
+
diff --git a/netopeer/voltha-grpc-client/generate-c-header.go b/netopeer/voltha-grpc-client/generate-c-header.go
new file mode 100644
index 0000000..c84fdda
--- /dev/null
+++ b/netopeer/voltha-grpc-client/generate-c-header.go
@@ -0,0 +1,133 @@
+package main
+
+import (
+	"github.com/opencord/voltha/netconf/translator/voltha"
+	"reflect"
+	"fmt"
+)
+
+var StructMap map[string]map[string]string
+
+func init() {
+	StructMap = make(map[string]map[string]string)
+}
+
+func addArrayType(newType string) {
+	if _, ok := StructMap[newType+"Array"]; !ok {
+		StructMap[newType+"Array"] = make(map[string]string)
+		StructMap[newType+"Array"]["items"] = newType + "*"
+		StructMap[newType+"Array"]["size"] = "int"
+	}
+
+}
+
+func addEnumType(newType string) {
+	if _, ok := StructMap[newType]; !ok {
+		StructMap[newType] = make(map[string]string)
+		StructMap[newType]["Type"] = "enum " + newType + "Enum"
+		StructMap[newType]["Value"] = "char*"
+	}
+}
+
+func traverseVolthaStructures(original reflect.Value) string {
+	field_type := ""
+
+	switch original.Kind() {
+
+	case reflect.Ptr:
+		field_type = traverseVolthaStructures(original.Elem())
+
+	case reflect.Interface:
+		addEnumType(original.Type().Name())
+		field_type = original.Type().Name()
+
+	case reflect.Struct:
+		for i := 0; i < original.NumField(); i += 1 {
+			field_type = ""
+			if original.Field(i).Kind() == reflect.Ptr {
+				newType := reflect.New(original.Type().Field(i).Type.Elem())
+				traverseVolthaStructures(reflect.Indirect(newType))
+				field_type = original.Type().Field(i).Type.Elem().Name() + "*"
+			} else {
+				field_type = traverseVolthaStructures(original.Field(i))
+			}
+			if _, ok := StructMap[original.Type().Name()]; !ok {
+				StructMap[original.Type().Name()] = make(map[string]string)
+			}
+			if _, ok := StructMap[original.Type().Name()][original.Type().Field(i).Name]; !ok {
+				if field_type == "" {
+					StructMap[original.Type().Name()][original.Type().Field(i).Name] =
+						string(original.Type().Field(i).Type.String())
+				} else {
+					StructMap[original.Type().Name()][original.Type().Field(i).Name] =
+						field_type
+				}
+			}
+		}
+
+	case reflect.Slice:
+		if original.Type().Elem().Kind() == reflect.Ptr {
+			newType := reflect.New(original.Type().Elem().Elem())
+			field_type = newType.Type().Elem().Name() + "Array"
+			traverseVolthaStructures(reflect.Indirect(newType))
+			addArrayType(newType.Type().Elem().Name())
+		} else {
+			field_type = original.Type().Elem().Kind().String() + "Array"
+			addArrayType(original.Type().Elem().Kind().String())
+		}
+
+	//case reflect.Map:
+	//	for _, key := range original.MapKeys() {
+	//		originalValue := original.MapIndex(key)
+	//	}
+
+	case reflect.String:
+		field_type = "string"
+		break
+
+	default:
+		field_type = original.Kind().String()
+	}
+
+	return field_type
+}
+
+func main() {
+	traverseVolthaStructures(reflect.ValueOf(voltha.Voltha{}))
+
+	fmt.Printf("#ifndef VOLTHA_DEFS\n")
+	fmt.Printf("#define VOLTHA_DEFS\n")
+	fmt.Printf("\n#include <stdint.h>\n")
+	var attribute_type string
+	for k, v := range StructMap {
+		fmt.Printf("\ntypedef struct {\n")
+		for kk, vv := range v {
+			attribute_type = vv
+			switch vv {
+			case "string*":
+				attribute_type = "char**"
+			case "string":
+				attribute_type = "char*"
+			case "int32":
+				attribute_type = "int32_t"
+			case "uint8*":
+				fallthrough
+			case "uint8":
+				attribute_type = "uint8_t"
+			case "uint32*":
+				fallthrough
+			case "uint32":
+				attribute_type = "uint32_t"
+			case "uint64*":
+				fallthrough
+			case "uint64":
+				attribute_type = "uint64_t"
+			case "bool":
+				attribute_type = "int"
+			}
+			fmt.Printf("\t%s %s;\n", attribute_type, kk)
+		}
+		fmt.Printf("} %s;\n", k)
+	}
+	fmt.Printf("\n#endif\n")
+}
diff --git a/netopeer/voltha-grpc-client/voltha-defs.h b/netopeer/voltha-grpc-client/voltha-defs.h
new file mode 100644
index 0000000..eac9360
--- /dev/null
+++ b/netopeer/voltha-grpc-client/voltha-defs.h
@@ -0,0 +1,456 @@
+#ifndef VOLTHA_DEFS
+#define VOLTHA_DEFS
+
+#include <stdint.h>
+
+typedef enum {
+    OUTPUT = 0,
+    MPLS_TTL = 1,
+    PUSH = 2,
+    POP_MPLS = 3,
+    GROUP = 4,
+    NW_TTL = 5,
+    SET_FIELD = 6,
+    EXPERIMENTER = 7
+} isOfpAction_ActionEnum;
+
+typedef enum {
+    DEBUG = 0,
+    INFO = 1,
+    WARNING = 2,
+    ERROR = 3,
+    CRITICAL = 4
+} LogLevelEnum;
+
+typedef enum {
+    OFPIT_INVALID = 0,
+    OFPIT_GOTO_TABLE = 1,
+    OFPIT_WRITE_METADATA = 2,
+    OFPIT_WRITE_ACTIONS = 3,
+    OFPIT_APPLY_ACTIONS = 4,
+    OFPIT_CLEAR_ACTIONS = 5,
+    OFPIT_METER = 6,
+    OFPIT_EXPERIMENTER = 7
+} isOfpInstruction_DataEnum;
+
+typedef enum {
+    OFB_FIELD = 0,
+    EXPERIMENTER_FIELD = 1
+} isOfpOxmField_FieldEnum;
+
+typedef enum {
+    MAC = 0,
+    IPV4 = 1,
+    IPV6 = 2,
+    HOST_AND_PORT = 3
+} isDevice_AddressEnum;
+
+typedef enum {
+    HEALTHY = 0,
+    OVERLOADED = 1,
+    DYING = 1
+} HealthStatusEnum;
+
+typedef struct {
+	char* State;
+} HealthStatus;
+
+typedef struct {
+	char* MfrDesc;
+	char* HwDesc;
+	char* SwDesc;
+	char* SerialNum;
+	char* DpDesc;
+} OfpDesc;
+
+typedef struct {
+	uint32_t NBuffers;
+	uint32_t NTables;
+	uint32_t AuxiliaryId;
+	uint32_t Capabilities;
+	uint64_t DatapathId;
+} OfpSwitchFeatures;
+
+typedef struct {
+	char* Value;
+	int Type;
+} isOfpOxmField_Field;
+
+typedef struct {
+	int32_t OxmClass;
+	isOfpOxmField_Field Field;
+} OfpOxmField;
+
+typedef struct {
+	OfpOxmField* items;
+	int size;
+} OfpOxmFieldArray;
+
+typedef struct {
+	int32_t Type;
+	OfpOxmFieldArray OxmFields;
+} OfpMatch;
+
+typedef struct {
+	int Type;
+	char* Value;
+} isOfpAction_Action;
+
+typedef struct {
+	int32_t Type;
+	isOfpAction_Action Action;
+} OfpAction;
+
+typedef struct {
+	int Type;
+	char* Value;
+} isOfpInstruction_Data;
+
+typedef struct {
+	isOfpInstruction_Data Data;
+	uint32_t Type;
+} OfpInstruction;
+
+typedef struct {
+	OfpInstruction* items;
+	int size;
+} OfpInstructionArray;
+
+typedef struct {
+	uint64_t PacketCount;
+	uint64_t ByteCount;
+	OfpMatch* Match;
+	uint64_t Id;
+	uint32_t DurationSec;
+	uint32_t Priority;
+	uint32_t HardTimeout;
+	uint32_t Flags;
+	uint32_t TableId;
+	uint32_t DurationNsec;
+	uint32_t IdleTimeout;
+	uint64_t Cookie;
+	OfpInstructionArray Instructions;
+} OfpFlowStats;
+
+typedef struct {
+	OfpFlowStats* items;
+	int size;
+} OfpFlowStatsArray;
+
+typedef struct {
+	OfpFlowStatsArray Items;
+} Flows;
+
+typedef struct {
+	OfpAction* items;
+	int size;
+} OfpActionArray;
+
+typedef struct {
+	OfpActionArray Actions;
+	uint32_t Weight;
+	uint32_t WatchPort;
+	uint32_t WatchGroup;
+} OfpBucket;
+
+typedef struct {
+	OfpBucket* items;
+	int size;
+} OfpBucketArray;
+
+typedef struct {
+	int32_t Type;
+	uint32_t GroupId;
+	OfpBucketArray Buckets;
+} OfpGroupDesc;
+
+typedef struct {
+	uint64_t PacketCount;
+	uint64_t ByteCount;
+} OfpBucketCounter;
+
+typedef struct {
+	OfpBucketCounter* items;
+	int size;
+} OfpBucketCounterArray;
+
+typedef struct {
+	uint32_t RefCount;
+	uint64_t PacketCount;
+	uint64_t ByteCount;
+	uint32_t DurationSec;
+	uint32_t DurationNsec;
+	OfpBucketCounterArray BucketStats;
+	uint32_t GroupId;
+} OfpGroupStats;
+
+typedef struct {
+	OfpGroupDesc* Desc;
+	OfpGroupStats* Stats;
+} OfpGroupEntry;
+
+typedef struct {
+	OfpGroupEntry* items;
+	int size;
+} OfpGroupEntryArray;
+
+typedef struct {
+	OfpGroupEntryArray Items;
+} FlowGroups;
+
+typedef struct {
+	uint32_t SampleFreq;
+	char* Name;
+	int32_t Type;
+	int Enabled;
+} PmConfig;
+
+typedef struct {
+	PmConfig* items;
+	int size;
+} PmConfigArray;
+
+typedef struct {
+	char* GroupName;
+	uint32_t GroupFreq;
+	int Enabled;
+	PmConfigArray Metrics;
+} PmGroupConfig;
+
+typedef struct {
+	PmGroupConfig* items;
+	int size;
+} PmGroupConfigArray;
+
+typedef struct {
+	uint32_t items;
+	int size;
+} uint32Array;
+
+typedef struct {
+	uint32Array HwAddr;
+	uint32_t State;
+	uint32_t Curr;
+	uint32_t MaxSpeed;
+	uint32_t PortNo;
+	char* Name;
+	uint32_t Config;
+	uint32_t Advertised;
+	uint32_t Supported;
+	uint32_t Peer;
+	uint32_t CurrSpeed;
+} OfpPort;
+
+typedef struct {
+	char* Value;
+	int Type;
+} isDevice_Address;
+
+typedef struct {
+	char* DeviceId;
+	uint32_t ChannelId;
+	uint32_t OnuId;
+	uint32_t OnuSessionId;
+} Device_ProxyAddress;
+
+typedef struct {
+	char** items;
+	int size;
+} stringArray;
+
+typedef struct {
+	uint8_t* items;
+	int size;
+} uint8Array;
+
+typedef struct {
+	uint8Array Value;
+	char* TypeUrl;
+} Any;
+
+typedef struct {
+	int32_t LogLevel;
+	Any* AdditionalConfig;
+} AdapterConfig;
+
+typedef struct {
+	AdapterConfig* Config;
+	Any* AdditionalDescription;
+	stringArray LogicalDeviceIds;
+	char* Id;
+	char* Vendor;
+	char* Version;
+} Adapter;
+
+typedef struct {
+	int32_t Key;
+	char* Value;
+} AlarmFilterRule;
+
+typedef struct {
+	AlarmFilterRule* items;
+	int size;
+} AlarmFilterRuleArray;
+
+typedef struct {
+	char* Id;
+	AlarmFilterRuleArray Rules;
+} AlarmFilter;
+
+typedef struct {
+	AlarmFilter* items;
+	int size;
+} AlarmFilterArray;
+
+typedef struct {
+	char* Id;
+	OfpPort* OfpPort;
+	char* DeviceId;
+	uint32_t DevicePortNo;
+	int RootPort;
+} LogicalPort;
+
+typedef struct {
+	LogicalPort* items;
+	int size;
+} LogicalPortArray;
+
+typedef struct {
+	FlowGroups* FlowGroups;
+	char* Id;
+	uint64_t DatapathId;
+	OfpDesc* Desc;
+	OfpSwitchFeatures* SwitchFeatures;
+	char* RootDeviceId;
+	LogicalPortArray Ports;
+	Flows* Flows;
+} LogicalDevice;
+
+typedef struct {
+	LogicalDevice* items;
+	int size;
+} LogicalDeviceArray;
+
+typedef struct {
+	uint32_t PortNo;
+	char* DeviceId;
+} Port_PeerPort;
+
+typedef struct {
+	Port_PeerPort* items;
+	int size;
+} Port_PeerPortArray;
+
+typedef struct {
+	uint32_t PortNo;
+	char* Label;
+	int32_t Type;
+	int32_t AdminState;
+	int32_t OperStatus;
+	char* DeviceId;
+	Port_PeerPortArray Peers;
+} Port;
+
+typedef struct {
+	Port* items;
+	int size;
+} PortArray;
+
+typedef struct {
+	uint32_t DefaultFreq;
+	int Grouped;
+	int FreqOverride;
+	PmGroupConfigArray Groups;
+	PmConfigArray Metrics;
+	char* Id;
+} PmConfigs;
+
+typedef struct {
+	char* Id;
+	char* Adapter;
+	int AcceptsBulkFlowUpdate;
+	int AcceptsAddRemoveFlowUpdates;
+} DeviceType;
+
+typedef struct {
+	DeviceType* items;
+	int size;
+} DeviceTypeArray;
+
+typedef struct {
+	char* Reason;
+	char* ConnectStatus;
+	FlowGroups* FlowGroups;
+	char* Id;
+	char* Model;
+	Device_ProxyAddress* ProxyAddress;
+	char* OperStatus;
+	uint32_t ParentPortNo;
+	char* HardwareVersion;
+	Flows* Flows;
+	PmConfigs* PmConfigs;
+	char* AdminState;
+	char* Type;
+	char* ParentId;
+	char* Vendor;
+	char* SerialNumber;
+	uint32_t Vlan;
+	isDevice_Address Address;
+	Any* Custom;
+	PortArray Ports;
+	int Root;
+	char* FirmwareVersion;
+	char* SoftwareVersion;
+	char* Adapter;
+} Device;
+
+typedef struct {
+	Device* items;
+	int size;
+} DeviceArray;
+
+typedef struct {
+	char* Id;
+	LogicalDeviceArray LogicalDevices;
+	DeviceArray Devices;
+} DeviceGroup;
+
+typedef struct {
+	DeviceGroup* items;
+	int size;
+} DeviceGroupArray;
+
+typedef struct {
+	Adapter* items;
+	int size;
+} AdapterArray;
+
+typedef struct {
+	AlarmFilterArray AlarmFilters;
+	char* InstanceId;
+	HealthStatus Health;
+	AdapterArray Adapters;
+	LogicalDeviceArray LogicalDevices;
+	DeviceGroupArray DeviceGroups;
+	char* Version;
+	char* LogLevel;
+	DeviceArray Devices;
+	DeviceTypeArray DeviceTypes;
+} VolthaInstance;
+
+typedef struct {
+	VolthaInstance* items;
+	int size;
+} VolthaInstanceArray;
+
+typedef struct {
+	char* Version;
+	char* LogLevel;
+	VolthaInstanceArray Instances;
+	AdapterArray Adapters;
+	LogicalDeviceArray LogicalDevices;
+	DeviceArray Devices;
+	DeviceGroupArray DeviceGroups;
+} Voltha;
+
+#endif
diff --git a/netopeer/voltha-grpc-client/voltha.go b/netopeer/voltha-grpc-client/voltha.go
new file mode 100644
index 0000000..2c7853a
--- /dev/null
+++ b/netopeer/voltha-grpc-client/voltha.go
@@ -0,0 +1,497 @@
+//package voltha
+package main
+
+/*
+#include <stdlib.h>
+#include "voltha-defs.h"
+ */
+import "C"
+
+import (
+	"log"
+	"golang.org/x/net/context"
+	"google.golang.org/grpc"
+	"github.com/golang/protobuf/ptypes/empty"
+	"github.com/hashicorp/consul/api"
+	pb "github.com/opencord/voltha/netconf/translator/voltha"
+	pb_health "github.com/opencord/voltha/netconf/translator/voltha/health"
+	pb_device "github.com/opencord/voltha/netconf/translator/voltha/device"
+	pb_adapter "github.com/opencord/voltha/netconf/translator/voltha/adapter"
+	pb_logical_device "github.com/opencord/voltha/netconf/translator/voltha/logical_device"
+	pb_openflow "github.com/opencord/voltha/netconf/translator/voltha/openflow_13"
+	pb_any "github.com/golang/protobuf/ptypes/any"
+	"unsafe"
+	"fmt"
+)
+
+const (
+	default_consul_address = "10.100.198.220:8500"
+	default_grpc_address   = "localhost:50555"
+	grpc_service_name      = "voltha-grpc"
+)
+
+var (
+	GrpcConn           *grpc.ClientConn              = nil
+	VolthaGlobalClient pb.VolthaGlobalServiceClient  = nil
+	HealthClient       pb_health.HealthServiceClient = nil
+	ConsulClient       *api.Client                   = nil
+	GrpcServiceAddress string                        = "localhost:50555"
+)
+
+func init() {
+	ConsulClient = connect_to_consul(default_consul_address)
+	GrpcServiceAddress = get_consul_service_address(grpc_service_name)
+	GrpcConn = connect_to_grpc(GrpcServiceAddress)
+
+	VolthaGlobalClient = pb.NewVolthaGlobalServiceClient(GrpcConn)
+	HealthClient = pb_health.NewHealthServiceClient(GrpcConn)
+}
+
+func connect_to_consul(consul_address string) *api.Client {
+	cfg := api.Config{Address: consul_address }
+
+	log.Printf("Connecting to consul - address: %s", consul_address)
+
+	client, err := api.NewClient(&cfg)
+	if err != nil {
+		panic(err)
+	}
+
+	log.Printf("Connected to consul - address: %s", consul_address)
+
+	return client
+}
+
+func get_consul_service_address(service_name string) string {
+	var service []*api.CatalogService
+	var err error
+
+	log.Printf("Getting consul service - name:%s", service_name)
+
+	if service, _, _ = ConsulClient.Catalog().Service(service_name, "", nil); err != nil {
+		panic(err)
+	}
+
+	address := fmt.Sprintf("%s:%d", service[0].ServiceAddress, service[0].ServicePort)
+
+	log.Printf("Got consul service - name:%s, address:%s", service_name, address)
+
+	return address
+}
+
+func connect_to_grpc(grpc_address string) *grpc.ClientConn {
+	var err error
+	var client *grpc.ClientConn
+
+	log.Printf("Connecting to grpc - address: %s", grpc_address)
+
+	// Set up a connection to the server.
+	client, err = grpc.Dial(grpc_address, grpc.WithInsecure())
+	if err != nil {
+		log.Fatalf("did not connect: %s", err.Error())
+	}
+
+	log.Printf("Connected to grpc - address: %s", grpc_address)
+
+	return client
+}
+// Utility methods
+
+// -------------------------------------------------
+// C to Protobuf conversion methods
+// -------------------------------------------------
+
+func _c_to_proto_Address(address C.isDevice_Address) *pb_device.Device {
+	var device *pb_device.Device
+
+	// Identify the address type to assign
+	switch address.Type {
+	case C.MAC:
+		device.Address = &pb_device.Device_MacAddress{
+			MacAddress: C.GoString(address.Value),
+		}
+		break
+	case C.IPV4:
+		device.Address = &pb_device.Device_Ipv4Address{
+			Ipv4Address: C.GoString(address.Value),
+		}
+		break
+	case C.IPV6:
+		device.Address = &pb_device.Device_Ipv6Address{
+			Ipv6Address: C.GoString(address.Value),
+		}
+		break
+	case C.HOST_AND_PORT:
+		device.Address = &pb_device.Device_HostAndPort{
+			HostAndPort: C.GoString(address.Value),
+		}
+		break
+	}
+
+	return device
+}
+
+// -------------------------------------------------
+// Protobuf to C conversion methods
+// -------------------------------------------------
+
+func _proto_to_c_Adapters(instances []*pb_adapter.Adapter) C.AdapterArray {
+	// TODO: not implemented
+	var result C.AdapterArray
+	return result
+}
+func _proto_to_c_LogicalDevices(instances []*pb_logical_device.LogicalDevice) C.LogicalDeviceArray {
+	// TODO: not implemented
+	var result C.LogicalDeviceArray
+	return result
+}
+func _proto_to_c_DeviceTypes(instances []*pb_device.DeviceType) C.DeviceTypeArray {
+	// TODO: not implemented
+	var result C.DeviceTypeArray
+	return result
+}
+func _proto_to_c_AlarmFilters(instances []*pb.AlarmFilter) C.AlarmFilterArray {
+	// TODO: not implemented
+	var result C.AlarmFilterArray
+	return result
+}
+func _proto_to_c_DeviceGroups(instances []*pb.DeviceGroup) C.DeviceGroupArray {
+	// TODO: not implemented
+	var result C.DeviceGroupArray
+	return result
+}
+func _proto_to_c_ProxyAddress(proxyAddress *pb_device.Device_ProxyAddress) *C.Device_ProxyAddress {
+	// TODO: not implemented
+	var result *C.Device_ProxyAddress
+	defer C.free(unsafe.Pointer(result))
+	return result
+}
+func _proto_to_c_Ports(ports []*pb_device.Port) C.PortArray {
+	// TODO: not implemented
+	var result C.PortArray
+	return result
+}
+func _proto_to_c_Flows(flows *pb_openflow.Flows) *C.Flows {
+	// TODO: not implemented
+	var result *C.Flows
+	defer C.free(unsafe.Pointer(result))
+	return result
+}
+func _proto_to_c_FlowGroups(groups *pb_openflow.FlowGroups) *C.FlowGroups {
+	// TODO: not implemented
+	var result *C.FlowGroups
+	defer C.free(unsafe.Pointer(result))
+	return result
+}
+func _proto_to_c_PmConfigs(configs *pb_device.PmConfigs) *C.PmConfigs {
+	// TODO: not implemented
+	var result *C.PmConfigs
+	defer C.free(unsafe.Pointer(result))
+	return result
+}
+func _proto_to_c_Custom(configs *pb_any.Any) *C.Any {
+	// TODO: not implemented
+	var result *C.Any
+	defer C.free(unsafe.Pointer(result))
+	return result
+}
+func _proto_to_c_HealthStatus(health *pb_health.HealthStatus) C.HealthStatus {
+	var result C.HealthStatus
+
+	var c_string *C.char
+	defer C.free(unsafe.Pointer(c_string))
+
+	if c_string = C.CString(health.GetState().String()); c_string != nil {
+		result.State = c_string
+	}
+
+	return result
+}
+
+func _proto_to_c_VolthaInstances(instances []*pb.VolthaInstance) C.VolthaInstanceArray {
+	var result C.VolthaInstanceArray
+	var c_string *C.char
+	var c_voltha_instance C.VolthaInstance
+	defer C.free(unsafe.Pointer(c_string))
+
+	sizeof := unsafe.Sizeof(c_voltha_instance)
+	count := len(instances)
+	result.size = C.int(count)
+
+	c_items := C.malloc(C.size_t(result.size) * C.size_t(sizeof))
+	defer C.free(unsafe.Pointer(c_items))
+
+	// Array to the allocated space
+	c_array := (*[1<<30 - 1]C.VolthaInstance)(c_items)
+
+	for index, value := range instances {
+		if c_string = C.CString(value.GetInstanceId()); c_string != nil {
+			c_voltha_instance.InstanceId = c_string
+		}
+		if c_string = C.CString(value.GetVersion()); c_string != nil {
+			c_voltha_instance.Version = c_string
+		}
+		if c_string = C.CString(value.GetLogLevel().String()); c_string != nil {
+			c_voltha_instance.LogLevel = c_string
+		}
+		c_voltha_instance.Health = _proto_to_c_HealthStatus(value.GetHealth())
+		c_voltha_instance.Adapters = _proto_to_c_Adapters(value.GetAdapters())
+		c_voltha_instance.LogicalDevices = _proto_to_c_LogicalDevices(value.GetLogicalDevices())
+		c_voltha_instance.Devices = _proto_to_c_Devices(value.GetDevices())
+		c_voltha_instance.DeviceTypes = _proto_to_c_DeviceTypes(value.GetDeviceTypes())
+		c_voltha_instance.DeviceGroups = _proto_to_c_DeviceGroups(value.GetDeviceGroups())
+		c_voltha_instance.AlarmFilters = _proto_to_c_AlarmFilters(value.GetAlarmFilters())
+
+		c_array[index] = c_voltha_instance
+	}
+
+	result.items = (*C.VolthaInstance)(unsafe.Pointer(c_array))
+
+	return result
+}
+func _proto_to_c_Devices(instances []*pb_device.Device) C.DeviceArray {
+	var result C.DeviceArray
+	var c_string *C.char
+	var c_device_instance C.Device
+	defer C.free(unsafe.Pointer(c_string))
+
+	sizeof := unsafe.Sizeof(c_device_instance)
+	count := len(instances)
+	result.size = C.int(count)
+
+	c_items := C.malloc(C.size_t(result.size) * C.size_t(sizeof))
+	defer C.free(unsafe.Pointer(c_items))
+
+	c_array := (*[1<<30 - 1]C.Device)(c_items)
+
+	for index, value := range instances {
+		c_array[index] = _proto_to_c_Device(value)
+	}
+
+	result.items = (*C.Device)(unsafe.Pointer(c_array))
+
+	return result
+}
+func _proto_to_c_Voltha(voltha *pb.Voltha) C.Voltha {
+	var result C.Voltha
+	var c_string *C.char
+	defer C.free(unsafe.Pointer(c_string))
+
+	if c_string = C.CString(voltha.GetVersion()); c_string != nil {
+		result.Version = c_string
+	}
+	if c_string = C.CString(voltha.GetLogLevel().String()); c_string != nil {
+		result.LogLevel = c_string
+	}
+
+	result.Instances = _proto_to_c_VolthaInstances(voltha.GetInstances())
+	result.Adapters = _proto_to_c_Adapters(voltha.GetAdapters())
+	result.LogicalDevices = _proto_to_c_LogicalDevices(voltha.GetLogicalDevices())
+	result.Devices = _proto_to_c_Devices(voltha.GetDevices())
+	result.DeviceGroups = _proto_to_c_DeviceGroups(voltha.GetDeviceGroups())
+
+	return result
+}
+
+func _proto_to_c_Address(device *pb_device.Device) C.isDevice_Address {
+	var address C.isDevice_Address
+	var c_string *C.char
+	defer C.free(unsafe.Pointer(c_string))
+
+	switch device.GetAddress().(type) {
+	case *pb_device.Device_MacAddress:
+		address.Type = C.MAC
+		c_string = C.CString(device.GetMacAddress())
+		address.Value = c_string
+	case *pb_device.Device_Ipv4Address:
+		address.Type = C.IPV4
+		c_string = C.CString(device.GetIpv4Address())
+		address.Value = c_string
+	case *pb_device.Device_Ipv6Address:
+		address.Type = C.IPV6
+		c_string = C.CString(device.GetIpv6Address())
+		address.Value = c_string
+	case *pb_device.Device_HostAndPort:
+		address.Type = C.HOST_AND_PORT
+		c_string = C.CString(device.GetHostAndPort())
+		address.Value = c_string
+	}
+	return address
+}
+
+func _proto_to_c_Device(device *pb_device.Device) C.Device {
+	var result C.Device
+	var c_string *C.char
+	defer C.free(unsafe.Pointer(c_string))
+
+	if c_string = C.CString(device.GetId()); c_string != nil {
+		result.Id = c_string
+	}
+	if c_string = C.CString(device.GetType()); c_string != nil {
+		result.Type = c_string
+	}
+	if device.GetRoot() {
+		result.Root = C.int(1)
+	} else {
+		result.Root = C.int(0)
+	}
+	if c_string = C.CString(device.GetParentId()); c_string != nil {
+		result.ParentId = c_string
+	}
+
+	result.ParentPortNo = C.uint32_t(device.GetParentPortNo())
+
+	if c_string = C.CString(device.GetVendor()); c_string != nil {
+		result.Vendor = c_string
+	}
+	if c_string = C.CString(device.GetModel()); c_string != nil {
+		result.Model = c_string
+	}
+	if c_string = C.CString(device.GetHardwareVersion()); c_string != nil {
+		result.HardwareVersion = c_string
+	}
+	if c_string = C.CString(device.GetFirmwareVersion()); c_string != nil {
+		result.FirmwareVersion = c_string
+	}
+	if c_string = C.CString(device.GetSoftwareVersion()); c_string != nil {
+		result.SoftwareVersion = c_string
+	}
+	if c_string = C.CString(device.GetSerialNumber()); c_string != nil {
+		result.SerialNumber = c_string
+	}
+	if c_string = C.CString(device.GetAdapter()); c_string != nil {
+		result.Adapter = c_string
+	}
+
+	result.Vlan = C.uint32_t(device.GetVlan())
+	result.ProxyAddress = _proto_to_c_ProxyAddress(device.GetProxyAddress())
+
+	if c_string = C.CString(device.GetAdminState().String()); c_string != nil {
+		result.AdminState = c_string
+	}
+	if c_string = C.CString(device.GetOperStatus().String()); c_string != nil {
+		result.OperStatus = c_string
+	}
+	if c_string = C.CString(device.GetReason()); c_string != nil {
+		result.Reason = c_string
+	}
+	if c_string = C.CString(device.GetConnectStatus().String()); c_string != nil {
+		result.ConnectStatus = c_string
+	}
+
+	result.Custom = _proto_to_c_Custom(device.GetCustom())
+	result.Ports = _proto_to_c_Ports(device.GetPorts())
+	result.Flows = _proto_to_c_Flows(device.GetFlows())
+	result.FlowGroups = _proto_to_c_FlowGroups(device.GetFlowGroups())
+	result.PmConfigs = _proto_to_c_PmConfigs(device.GetPmConfigs())
+	result.Address = _proto_to_c_Address(device)
+
+	return result
+}
+
+// ---------------------------------------------------------
+// Exported methods accessible through the shared library
+// ---------------------------------------------------------
+
+//export GetHealthStatus
+func GetHealthStatus() C.HealthStatus {
+	var output *pb_health.HealthStatus
+	var err error
+
+	if output, err = HealthClient.GetHealthStatus(context.Background(), &empty.Empty{}); output == nil || err != nil {
+		log.Fatalf("Failed to retrieve health status: %s", err.Error())
+	}
+
+	return _proto_to_c_HealthStatus(output)
+}
+
+//export GetVoltha
+func GetVoltha() C.Voltha {
+	var output *pb.Voltha
+	var err error
+	if output, err = VolthaGlobalClient.GetVoltha(context.Background(), &empty.Empty{}); output == nil || err != nil {
+		log.Fatalf("Failed to retrieve voltha information: %s", err.Error())
+	}
+
+	return _proto_to_c_Voltha(output)
+}
+
+//export ListDevices
+func ListDevices() C.DeviceArray {
+	var output *pb_device.Devices
+	var err error
+	if output, err = VolthaGlobalClient.ListDevices(context.Background(), &empty.Empty{});
+		output == nil || err != nil {
+		log.Fatalf("Failed to retrieve voltha information: %s", err.Error())
+	}
+
+	return _proto_to_c_Devices(output.Items)
+}
+
+//export ListVolthaInstances
+func ListVolthaInstances() *C.char {
+	return nil
+}
+
+//export ListLogicalDevices
+func ListLogicalDevices() *C.char {
+	return nil
+}
+
+//export GetLogicalDevice
+func GetLogicalDevice(input *C.char) *C.char {
+	return nil
+}
+
+//export ListLogicalDevicePorts
+func ListLogicalDevicePorts(input *C.char) *C.char {
+	return nil
+}
+
+//export ListLogicalDeviceFlows
+func ListLogicalDeviceFlows(input *C.char) *C.char {
+	return nil
+}
+
+//export CreateDevice
+func CreateDevice(input C.Device) C.Device {
+	log.Printf("Incoming C Device - type:%v, address_type: %v, address_value:%s",
+		C.GoString(input.Type),
+		C.int(input.Address.Type),
+		C.GoString(input.Address.Value),
+	)
+
+	device := _c_to_proto_Address(input.Address)
+	device.Type = C.GoString(input.Type)
+
+	var output *pb_device.Device
+	var err error
+
+	if output, err = VolthaGlobalClient.CreateDevice(context.Background(), device);
+		output == nil || err != nil {
+		log.Fatalf("Failed to create device: %s", err.Error())
+	}
+
+	return _proto_to_c_Device(output)
+}
+
+// Debugging code
+func TestSerialize() {
+	var object C.Device
+
+	object.Type = C.CString("simulated_olt")
+	object.Address.Type = 3
+	object.Address.Value = C.CString("172.16.1.233:123")
+
+	//xmlObject, _ := xml.Marshal(object)
+	//
+	//log.Printf("object: %+v", string(xmlObject))
+
+	CreateDevice(object)
+}
+
+func main() {
+	// We need the main function to make possible
+	// CGO compiler to compile the package as C shared library
+	//TestSerialize()
+}
diff --git a/netopeer/voltha-grpc-client/voltha/adapter/adapter.pb.go b/netopeer/voltha-grpc-client/voltha/adapter/adapter.pb.go
new file mode 100644
index 0000000..9c1f8e4
--- /dev/null
+++ b/netopeer/voltha-grpc-client/voltha/adapter/adapter.pb.go
@@ -0,0 +1,170 @@
+// Code generated by protoc-gen-go.
+// source: adapter.proto
+// DO NOT EDIT!
+
+/*
+Package voltha is a generated protocol buffer package.
+
+It is generated from these files:
+	adapter.proto
+
+It has these top-level messages:
+	AdapterConfig
+	Adapter
+	Adapters
+*/
+package adapter
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+import google_protobuf "github.com/golang/protobuf/ptypes/any"
+import voltha2 "github.com/opencord/voltha/netconf/translator/voltha/common"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+type AdapterConfig struct {
+	// Common adapter config attributes here
+	LogLevel voltha2.LogLevel_LogLevel `protobuf:"varint,1,opt,name=log_level,json=logLevel,enum=voltha.LogLevel_LogLevel" json:"log_level,omitempty"`
+	// Custom (vendor-specific) configuration attributes
+	AdditionalConfig *google_protobuf.Any `protobuf:"bytes,64,opt,name=additional_config,json=additionalConfig" json:"additional_config,omitempty"`
+}
+
+func (m *AdapterConfig) Reset()                    { *m = AdapterConfig{} }
+func (m *AdapterConfig) String() string            { return proto.CompactTextString(m) }
+func (*AdapterConfig) ProtoMessage()               {}
+func (*AdapterConfig) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
+
+func (m *AdapterConfig) GetLogLevel() voltha2.LogLevel_LogLevel {
+	if m != nil {
+		return m.LogLevel
+	}
+	return voltha2.LogLevel_DEBUG
+}
+
+func (m *AdapterConfig) GetAdditionalConfig() *google_protobuf.Any {
+	if m != nil {
+		return m.AdditionalConfig
+	}
+	return nil
+}
+
+// Adapter (software plugin)
+type Adapter struct {
+	// Unique name of adapter, matching the python packate name under
+	// voltha/adapters.
+	Id      string `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
+	Vendor  string `protobuf:"bytes,2,opt,name=vendor" json:"vendor,omitempty"`
+	Version string `protobuf:"bytes,3,opt,name=version" json:"version,omitempty"`
+	// Adapter configuration
+	Config *AdapterConfig `protobuf:"bytes,16,opt,name=config" json:"config,omitempty"`
+	// Custom descriptors and custom configuration
+	AdditionalDescription *google_protobuf.Any `protobuf:"bytes,64,opt,name=additional_description,json=additionalDescription" json:"additional_description,omitempty"`
+	LogicalDeviceIds      []string             `protobuf:"bytes,4,rep,name=logical_device_ids,json=logicalDeviceIds" json:"logical_device_ids,omitempty"`
+}
+
+func (m *Adapter) Reset()                    { *m = Adapter{} }
+func (m *Adapter) String() string            { return proto.CompactTextString(m) }
+func (*Adapter) ProtoMessage()               {}
+func (*Adapter) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
+
+func (m *Adapter) GetId() string {
+	if m != nil {
+		return m.Id
+	}
+	return ""
+}
+
+func (m *Adapter) GetVendor() string {
+	if m != nil {
+		return m.Vendor
+	}
+	return ""
+}
+
+func (m *Adapter) GetVersion() string {
+	if m != nil {
+		return m.Version
+	}
+	return ""
+}
+
+func (m *Adapter) GetConfig() *AdapterConfig {
+	if m != nil {
+		return m.Config
+	}
+	return nil
+}
+
+func (m *Adapter) GetAdditionalDescription() *google_protobuf.Any {
+	if m != nil {
+		return m.AdditionalDescription
+	}
+	return nil
+}
+
+func (m *Adapter) GetLogicalDeviceIds() []string {
+	if m != nil {
+		return m.LogicalDeviceIds
+	}
+	return nil
+}
+
+type Adapters struct {
+	Items []*Adapter `protobuf:"bytes,1,rep,name=items" json:"items,omitempty"`
+}
+
+func (m *Adapters) Reset()                    { *m = Adapters{} }
+func (m *Adapters) String() string            { return proto.CompactTextString(m) }
+func (*Adapters) ProtoMessage()               {}
+func (*Adapters) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }
+
+func (m *Adapters) GetItems() []*Adapter {
+	if m != nil {
+		return m.Items
+	}
+	return nil
+}
+
+func init() {
+	proto.RegisterType((*AdapterConfig)(nil), "voltha.AdapterConfig")
+	proto.RegisterType((*Adapter)(nil), "voltha.Adapter")
+	proto.RegisterType((*Adapters)(nil), "voltha.Adapters")
+}
+
+func init() { proto.RegisterFile("adapter.proto", fileDescriptor0) }
+
+var fileDescriptor0 = []byte{
+	// 340 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x90, 0xc1, 0x4e, 0xea, 0x40,
+	0x14, 0x86, 0xd3, 0x72, 0x29, 0x70, 0xb8, 0xdc, 0x8b, 0x13, 0x31, 0x85, 0x84, 0xd8, 0x90, 0x98,
+	0x74, 0xa1, 0x25, 0x62, 0xe2, 0x5a, 0x94, 0x8d, 0x09, 0xab, 0xbe, 0x00, 0x19, 0x3a, 0x43, 0x9d,
+	0x64, 0x3a, 0x87, 0xb4, 0xb5, 0x09, 0xaf, 0xe0, 0xce, 0x07, 0xf3, 0x3d, 0x7c, 0x02, 0xd7, 0x86,
+	0x99, 0xa9, 0xa0, 0x0b, 0x77, 0x67, 0xfe, 0xff, 0x9c, 0xf3, 0x7f, 0x67, 0xa0, 0x47, 0x19, 0xdd,
+	0x96, 0x3c, 0x8f, 0xb6, 0x39, 0x96, 0x48, 0xbc, 0x0a, 0x65, 0xf9, 0x44, 0x47, 0xc3, 0x14, 0x31,
+	0x95, 0x7c, 0xaa, 0xd5, 0xf5, 0xf3, 0x66, 0x4a, 0xd5, 0xce, 0xb4, 0x8c, 0xfe, 0x26, 0x98, 0x65,
+	0xa8, 0xec, 0x0b, 0x32, 0x5e, 0x52, 0x53, 0x4f, 0x5e, 0x1c, 0xe8, 0xcd, 0xcd, 0xba, 0x07, 0x54,
+	0x1b, 0x91, 0x92, 0x5b, 0xe8, 0x48, 0x4c, 0x57, 0x92, 0x57, 0x5c, 0xfa, 0x4e, 0xe0, 0x84, 0xff,
+	0x66, 0xc3, 0xc8, 0x44, 0x44, 0x4b, 0x4c, 0x97, 0x7b, 0xfd, 0xab, 0x88, 0xdb, 0xd2, 0x56, 0x64,
+	0x0e, 0x27, 0x94, 0x31, 0x51, 0x0a, 0x54, 0x54, 0xae, 0x12, 0xbd, 0xcc, 0xbf, 0x0b, 0x9c, 0xb0,
+	0x3b, 0x3b, 0x8d, 0x0c, 0x5a, 0x54, 0xa3, 0x45, 0x73, 0xb5, 0x8b, 0xfb, 0x87, 0x76, 0x13, 0x3d,
+	0x79, 0x75, 0xa1, 0x65, 0x61, 0xc8, 0x00, 0x5c, 0xc1, 0x74, 0x7e, 0xe7, 0xbe, 0xf9, 0xfe, 0xf1,
+	0x36, 0x76, 0x62, 0x57, 0x30, 0x32, 0x06, 0xaf, 0xe2, 0x8a, 0x61, 0xee, 0xbb, 0xc7, 0x96, 0x15,
+	0xc9, 0x39, 0xb4, 0x2a, 0x9e, 0x17, 0x02, 0x95, 0xdf, 0x38, 0xf6, 0x6b, 0x95, 0x5c, 0x81, 0x67,
+	0xd1, 0xfa, 0x1a, 0x6d, 0x50, 0x9f, 0xf6, 0xed, 0x13, 0x62, 0xdb, 0x44, 0x62, 0x38, 0x3b, 0x3a,
+	0x8a, 0xf1, 0x22, 0xc9, 0xc5, 0x76, 0xff, 0xfa, 0xed, 0xb2, 0x3a, 0x74, 0x70, 0x18, 0x5d, 0x1c,
+	0x26, 0xc9, 0x25, 0x10, 0x89, 0xa9, 0x48, 0xf4, 0xc2, 0x4a, 0x24, 0x7c, 0x25, 0x58, 0xe1, 0xff,
+	0x09, 0x1a, 0x61, 0x27, 0xee, 0x5b, 0x67, 0xa1, 0x8d, 0x47, 0x56, 0x4c, 0xae, 0xa1, 0x6d, 0xd1,
+	0x0a, 0x72, 0x01, 0x4d, 0x51, 0xf2, 0xac, 0xf0, 0x9d, 0xa0, 0x11, 0x76, 0x67, 0xff, 0x7f, 0xb0,
+	0xc7, 0xc6, 0x5d, 0x7b, 0x1a, 0xe6, 0xe6, 0x33, 0x00, 0x00, 0xff, 0xff, 0xd4, 0x5e, 0xc4, 0x9a,
+	0x28, 0x02, 0x00, 0x00,
+}
diff --git a/netopeer/voltha-grpc-client/voltha/common/common.pb.go b/netopeer/voltha-grpc-client/voltha/common/common.pb.go
new file mode 100644
index 0000000..7a621d6
--- /dev/null
+++ b/netopeer/voltha-grpc-client/voltha/common/common.pb.go
@@ -0,0 +1,255 @@
+// Code generated by protoc-gen-go.
+// source: common.proto
+// DO NOT EDIT!
+
+/*
+Package voltha is a generated protocol buffer package.
+
+It is generated from these files:
+	common.proto
+
+It has these top-level messages:
+	ID
+	LogLevel
+	AdminState
+	OperStatus
+	ConnectStatus
+*/
+package common
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+// Logging verbosity level
+type LogLevel_LogLevel int32
+
+const (
+	LogLevel_DEBUG    LogLevel_LogLevel = 0
+	LogLevel_INFO     LogLevel_LogLevel = 1
+	LogLevel_WARNING  LogLevel_LogLevel = 2
+	LogLevel_ERROR    LogLevel_LogLevel = 3
+	LogLevel_CRITICAL LogLevel_LogLevel = 4
+)
+
+var LogLevel_LogLevel_name = map[int32]string{
+	0: "DEBUG",
+	1: "INFO",
+	2: "WARNING",
+	3: "ERROR",
+	4: "CRITICAL",
+}
+var LogLevel_LogLevel_value = map[string]int32{
+	"DEBUG":    0,
+	"INFO":     1,
+	"WARNING":  2,
+	"ERROR":    3,
+	"CRITICAL": 4,
+}
+
+func (x LogLevel_LogLevel) String() string {
+	return proto.EnumName(LogLevel_LogLevel_name, int32(x))
+}
+func (LogLevel_LogLevel) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{1, 0} }
+
+// Administrative State
+type AdminState_AdminState int32
+
+const (
+	// The administrative state of the device is unknown
+	AdminState_UNKNOWN AdminState_AdminState = 0
+	// The device is pre-provisioned into Voltha, but not contacted by it
+	AdminState_PREPROVISIONED AdminState_AdminState = 1
+	// The device is enabled for activation and operation
+	AdminState_ENABLED AdminState_AdminState = 3
+	// The device is disabled and shall not perform its intended forwarding
+	// functions other than being available for re-activation.
+	AdminState_DISABLED AdminState_AdminState = 2
+)
+
+var AdminState_AdminState_name = map[int32]string{
+	0: "UNKNOWN",
+	1: "PREPROVISIONED",
+	3: "ENABLED",
+	2: "DISABLED",
+}
+var AdminState_AdminState_value = map[string]int32{
+	"UNKNOWN":        0,
+	"PREPROVISIONED": 1,
+	"ENABLED":        3,
+	"DISABLED":       2,
+}
+
+func (x AdminState_AdminState) String() string {
+	return proto.EnumName(AdminState_AdminState_name, int32(x))
+}
+func (AdminState_AdminState) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{2, 0} }
+
+// Operational Status
+type OperStatus_OperStatus int32
+
+const (
+	// The status of the device is unknown at this point
+	OperStatus_UNKNOWN OperStatus_OperStatus = 0
+	// The device has been discovered, but not yet activated
+	OperStatus_DISCOVERED OperStatus_OperStatus = 1
+	// The device is being activated (booted, rebooted, upgraded, etc.)
+	OperStatus_ACTIVATING OperStatus_OperStatus = 2
+	// Service impacting tests are being conducted
+	OperStatus_TESTING OperStatus_OperStatus = 3
+	// The device is up and active
+	OperStatus_ACTIVE OperStatus_OperStatus = 4
+	// The device has failed and cannot fulfill its intended role
+	OperStatus_FAILED OperStatus_OperStatus = 5
+)
+
+var OperStatus_OperStatus_name = map[int32]string{
+	0: "UNKNOWN",
+	1: "DISCOVERED",
+	2: "ACTIVATING",
+	3: "TESTING",
+	4: "ACTIVE",
+	5: "FAILED",
+}
+var OperStatus_OperStatus_value = map[string]int32{
+	"UNKNOWN":    0,
+	"DISCOVERED": 1,
+	"ACTIVATING": 2,
+	"TESTING":    3,
+	"ACTIVE":     4,
+	"FAILED":     5,
+}
+
+func (x OperStatus_OperStatus) String() string {
+	return proto.EnumName(OperStatus_OperStatus_name, int32(x))
+}
+func (OperStatus_OperStatus) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{3, 0} }
+
+// Connectivity Status
+type ConnectStatus_ConnectStatus int32
+
+const (
+	// The device connectivity status is unknown
+	ConnectStatus_UNKNOWN ConnectStatus_ConnectStatus = 0
+	// The device cannot be reached by Voltha
+	ConnectStatus_UNREACHABLE ConnectStatus_ConnectStatus = 1
+	// There is live communication between device and Voltha
+	ConnectStatus_REACHABLE ConnectStatus_ConnectStatus = 2
+)
+
+var ConnectStatus_ConnectStatus_name = map[int32]string{
+	0: "UNKNOWN",
+	1: "UNREACHABLE",
+	2: "REACHABLE",
+}
+var ConnectStatus_ConnectStatus_value = map[string]int32{
+	"UNKNOWN":     0,
+	"UNREACHABLE": 1,
+	"REACHABLE":   2,
+}
+
+func (x ConnectStatus_ConnectStatus) String() string {
+	return proto.EnumName(ConnectStatus_ConnectStatus_name, int32(x))
+}
+func (ConnectStatus_ConnectStatus) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor0, []int{4, 0}
+}
+
+// Convey a resource identifier
+type ID struct {
+	Id string `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
+}
+
+func (m *ID) Reset()                    { *m = ID{} }
+func (m *ID) String() string            { return proto.CompactTextString(m) }
+func (*ID) ProtoMessage()               {}
+func (*ID) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
+
+func (m *ID) GetId() string {
+	if m != nil {
+		return m.Id
+	}
+	return ""
+}
+
+type LogLevel struct {
+}
+
+func (m *LogLevel) Reset()                    { *m = LogLevel{} }
+func (m *LogLevel) String() string            { return proto.CompactTextString(m) }
+func (*LogLevel) ProtoMessage()               {}
+func (*LogLevel) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
+
+type AdminState struct {
+}
+
+func (m *AdminState) Reset()                    { *m = AdminState{} }
+func (m *AdminState) String() string            { return proto.CompactTextString(m) }
+func (*AdminState) ProtoMessage()               {}
+func (*AdminState) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }
+
+type OperStatus struct {
+}
+
+func (m *OperStatus) Reset()                    { *m = OperStatus{} }
+func (m *OperStatus) String() string            { return proto.CompactTextString(m) }
+func (*OperStatus) ProtoMessage()               {}
+func (*OperStatus) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} }
+
+type ConnectStatus struct {
+}
+
+func (m *ConnectStatus) Reset()                    { *m = ConnectStatus{} }
+func (m *ConnectStatus) String() string            { return proto.CompactTextString(m) }
+func (*ConnectStatus) ProtoMessage()               {}
+func (*ConnectStatus) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} }
+
+func init() {
+	proto.RegisterType((*ID)(nil), "voltha.ID")
+	proto.RegisterType((*LogLevel)(nil), "voltha.LogLevel")
+	proto.RegisterType((*AdminState)(nil), "voltha.AdminState")
+	proto.RegisterType((*OperStatus)(nil), "voltha.OperStatus")
+	proto.RegisterType((*ConnectStatus)(nil), "voltha.ConnectStatus")
+	proto.RegisterEnum("voltha.LogLevel_LogLevel", LogLevel_LogLevel_name, LogLevel_LogLevel_value)
+	proto.RegisterEnum("voltha.AdminState_AdminState", AdminState_AdminState_name, AdminState_AdminState_value)
+	proto.RegisterEnum("voltha.OperStatus_OperStatus", OperStatus_OperStatus_name, OperStatus_OperStatus_value)
+	proto.RegisterEnum("voltha.ConnectStatus_ConnectStatus", ConnectStatus_ConnectStatus_name, ConnectStatus_ConnectStatus_value)
+}
+
+func init() { proto.RegisterFile("common.proto", fileDescriptor0) }
+
+var fileDescriptor0 = []byte{
+	// 326 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x5c, 0x91, 0x4f, 0x4f, 0xc2, 0x30,
+	0x18, 0xc6, 0xd9, 0xf8, 0xff, 0x02, 0xb3, 0x69, 0x3c, 0x18, 0x13, 0x13, 0xb3, 0x93, 0x27, 0x2f,
+	0xde, 0x8c, 0x97, 0xb2, 0x15, 0x68, 0x5c, 0x5a, 0xd2, 0x0d, 0xf0, 0xa2, 0x06, 0x61, 0xc1, 0x25,
+	0xd0, 0x12, 0xa8, 0x24, 0x7e, 0x48, 0xbf, 0x8b, 0x27, 0xcf, 0xa6, 0x9b, 0x04, 0xf0, 0xf6, 0x3e,
+	0x7d, 0x9b, 0xdf, 0xaf, 0x4f, 0x0a, 0xed, 0x99, 0x5e, 0xad, 0xb4, 0xba, 0x5d, 0x6f, 0xb4, 0xd1,
+	0xb8, 0xb6, 0xd3, 0x4b, 0xf3, 0x3e, 0xbd, 0xc4, 0x9f, 0x53, 0xb5, 0x78, 0xd5, 0x6b, 0x93, 0x69,
+	0xb5, 0x2d, 0x76, 0xfe, 0x39, 0xb8, 0x2c, 0xc4, 0x1e, 0xb8, 0xd9, 0xfc, 0xc2, 0xb9, 0x76, 0x6e,
+	0x9a, 0xd2, 0xcd, 0xe6, 0xfe, 0x13, 0x34, 0x22, 0xbd, 0x88, 0xd2, 0x5d, 0xba, 0xf4, 0xe9, 0x61,
+	0xc6, 0x4d, 0xa8, 0x86, 0xb4, 0x3b, 0xea, 0xa3, 0x12, 0x6e, 0x40, 0x85, 0xf1, 0x9e, 0x40, 0x0e,
+	0x6e, 0x41, 0x7d, 0x42, 0x24, 0x67, 0xbc, 0x8f, 0x5c, 0x7b, 0x83, 0x4a, 0x29, 0x24, 0x2a, 0xe3,
+	0x36, 0x34, 0x02, 0xc9, 0x12, 0x16, 0x90, 0x08, 0x55, 0xee, 0xab, 0xdf, 0x3f, 0x5f, 0x57, 0x25,
+	0xff, 0x19, 0x80, 0xcc, 0x57, 0x99, 0x8a, 0xcd, 0xd4, 0xa4, 0xfe, 0xe0, 0x38, 0x59, 0xd0, 0x88,
+	0x3f, 0x72, 0x31, 0xe1, 0xa8, 0x84, 0x31, 0x78, 0x43, 0x49, 0x87, 0x52, 0x8c, 0x59, 0xcc, 0x04,
+	0xa7, 0x61, 0x61, 0xa2, 0x9c, 0x74, 0x23, 0x1a, 0x16, 0xf8, 0x90, 0xc5, 0x45, 0x72, 0xf7, 0xf8,
+	0x2d, 0x80, 0x58, 0xa7, 0x1b, 0xcb, 0xfb, 0xd8, 0xfa, 0x2f, 0xc7, 0xe9, 0x14, 0xef, 0x01, 0x84,
+	0x2c, 0x0e, 0xc4, 0x98, 0xca, 0x1c, 0xed, 0x01, 0x90, 0x20, 0x61, 0x63, 0x92, 0x14, 0x3d, 0x5a,
+	0x50, 0x4f, 0x68, 0x9c, 0x87, 0x32, 0x06, 0xa8, 0xe5, 0x4b, 0x8a, 0x2a, 0x76, 0xee, 0x11, 0x66,
+	0xa5, 0xd5, 0xbd, 0x34, 0x81, 0x4e, 0xa0, 0x95, 0x4a, 0x67, 0xe6, 0xcf, 0xfb, 0xf0, 0xef, 0xe0,
+	0x54, 0x7d, 0x06, 0xad, 0x11, 0x97, 0x94, 0x04, 0x03, 0xfb, 0x78, 0xe4, 0xe0, 0x0e, 0x34, 0x0f,
+	0x71, 0x5f, 0xe5, 0xad, 0x96, 0x7f, 0xd0, 0xdd, 0x6f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x49, 0x80,
+	0x95, 0xd3, 0xcc, 0x01, 0x00, 0x00,
+}
diff --git a/netopeer/voltha-grpc-client/voltha/device/device.pb.go b/netopeer/voltha-grpc-client/voltha/device/device.pb.go
new file mode 100644
index 0000000..9e87b04
--- /dev/null
+++ b/netopeer/voltha-grpc-client/voltha/device/device.pb.go
@@ -0,0 +1,918 @@
+// Code generated by protoc-gen-go.
+// source: device.proto
+// DO NOT EDIT!
+
+/*
+Package voltha is a generated protocol buffer package.
+
+It is generated from these files:
+	device.proto
+
+It has these top-level messages:
+	DeviceType
+	DeviceTypes
+	PmConfig
+	PmGroupConfig
+	PmConfigs
+	Port
+	Ports
+	Device
+	Devices
+*/
+package device
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+import google_protobuf1 "github.com/golang/protobuf/ptypes/any"
+import voltha3 "github.com/opencord/voltha/netconf/translator/voltha/common"
+import openflow_13 "github.com/opencord/voltha/netconf/translator/voltha/openflow_13"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+type PmConfig_PmType int32
+
+const (
+	PmConfig_COUNTER PmConfig_PmType = 0
+	PmConfig_GUAGE   PmConfig_PmType = 1
+	PmConfig_STATE   PmConfig_PmType = 2
+)
+
+var PmConfig_PmType_name = map[int32]string{
+	0: "COUNTER",
+	1: "GUAGE",
+	2: "STATE",
+}
+var PmConfig_PmType_value = map[string]int32{
+	"COUNTER": 0,
+	"GUAGE":   1,
+	"STATE":   2,
+}
+
+func (x PmConfig_PmType) String() string {
+	return proto.EnumName(PmConfig_PmType_name, int32(x))
+}
+func (PmConfig_PmType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{2, 0} }
+
+type Port_PortType int32
+
+const (
+	Port_UNKNOWN      Port_PortType = 0
+	Port_ETHERNET_NNI Port_PortType = 1
+	Port_ETHERNET_UNI Port_PortType = 2
+	Port_PON_OLT      Port_PortType = 3
+	Port_PON_ONU      Port_PortType = 4
+)
+
+var Port_PortType_name = map[int32]string{
+	0: "UNKNOWN",
+	1: "ETHERNET_NNI",
+	2: "ETHERNET_UNI",
+	3: "PON_OLT",
+	4: "PON_ONU",
+}
+var Port_PortType_value = map[string]int32{
+	"UNKNOWN":      0,
+	"ETHERNET_NNI": 1,
+	"ETHERNET_UNI": 2,
+	"PON_OLT":      3,
+	"PON_ONU":      4,
+}
+
+func (x Port_PortType) String() string {
+	return proto.EnumName(Port_PortType_name, int32(x))
+}
+func (Port_PortType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{5, 0} }
+
+// A Device Type
+type DeviceType struct {
+	// Unique name for the device type
+	Id string `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
+	// Name of the adapter that handles device type
+	Adapter                     string `protobuf:"bytes,2,opt,name=adapter" json:"adapter,omitempty"`
+	AcceptsBulkFlowUpdate       bool   `protobuf:"varint,3,opt,name=accepts_bulk_flow_update,json=acceptsBulkFlowUpdate" json:"accepts_bulk_flow_update,omitempty"`
+	AcceptsAddRemoveFlowUpdates bool   `protobuf:"varint,4,opt,name=accepts_add_remove_flow_updates,json=acceptsAddRemoveFlowUpdates" json:"accepts_add_remove_flow_updates,omitempty"`
+}
+
+func (m *DeviceType) Reset()                    { *m = DeviceType{} }
+func (m *DeviceType) String() string            { return proto.CompactTextString(m) }
+func (*DeviceType) ProtoMessage()               {}
+func (*DeviceType) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
+
+func (m *DeviceType) GetId() string {
+	if m != nil {
+		return m.Id
+	}
+	return ""
+}
+
+func (m *DeviceType) GetAdapter() string {
+	if m != nil {
+		return m.Adapter
+	}
+	return ""
+}
+
+func (m *DeviceType) GetAcceptsBulkFlowUpdate() bool {
+	if m != nil {
+		return m.AcceptsBulkFlowUpdate
+	}
+	return false
+}
+
+func (m *DeviceType) GetAcceptsAddRemoveFlowUpdates() bool {
+	if m != nil {
+		return m.AcceptsAddRemoveFlowUpdates
+	}
+	return false
+}
+
+// A plurality of device types
+type DeviceTypes struct {
+	Items []*DeviceType `protobuf:"bytes,1,rep,name=items" json:"items,omitempty"`
+}
+
+func (m *DeviceTypes) Reset()                    { *m = DeviceTypes{} }
+func (m *DeviceTypes) String() string            { return proto.CompactTextString(m) }
+func (*DeviceTypes) ProtoMessage()               {}
+func (*DeviceTypes) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
+
+func (m *DeviceTypes) GetItems() []*DeviceType {
+	if m != nil {
+		return m.Items
+	}
+	return nil
+}
+
+type PmConfig struct {
+	Name       string          `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
+	Type       PmConfig_PmType `protobuf:"varint,2,opt,name=type,enum=voltha.PmConfig_PmType" json:"type,omitempty"`
+	Enabled    bool            `protobuf:"varint,3,opt,name=enabled" json:"enabled,omitempty"`
+	SampleFreq uint32          `protobuf:"varint,4,opt,name=sample_freq,json=sampleFreq" json:"sample_freq,omitempty"`
+}
+
+func (m *PmConfig) Reset()                    { *m = PmConfig{} }
+func (m *PmConfig) String() string            { return proto.CompactTextString(m) }
+func (*PmConfig) ProtoMessage()               {}
+func (*PmConfig) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }
+
+func (m *PmConfig) GetName() string {
+	if m != nil {
+		return m.Name
+	}
+	return ""
+}
+
+func (m *PmConfig) GetType() PmConfig_PmType {
+	if m != nil {
+		return m.Type
+	}
+	return PmConfig_COUNTER
+}
+
+func (m *PmConfig) GetEnabled() bool {
+	if m != nil {
+		return m.Enabled
+	}
+	return false
+}
+
+func (m *PmConfig) GetSampleFreq() uint32 {
+	if m != nil {
+		return m.SampleFreq
+	}
+	return 0
+}
+
+type PmGroupConfig struct {
+	GroupName string      `protobuf:"bytes,1,opt,name=group_name,json=groupName" json:"group_name,omitempty"`
+	GroupFreq uint32      `protobuf:"varint,2,opt,name=group_freq,json=groupFreq" json:"group_freq,omitempty"`
+	Enabled   bool        `protobuf:"varint,3,opt,name=enabled" json:"enabled,omitempty"`
+	Metrics   []*PmConfig `protobuf:"bytes,4,rep,name=metrics" json:"metrics,omitempty"`
+}
+
+func (m *PmGroupConfig) Reset()                    { *m = PmGroupConfig{} }
+func (m *PmGroupConfig) String() string            { return proto.CompactTextString(m) }
+func (*PmGroupConfig) ProtoMessage()               {}
+func (*PmGroupConfig) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} }
+
+func (m *PmGroupConfig) GetGroupName() string {
+	if m != nil {
+		return m.GroupName
+	}
+	return ""
+}
+
+func (m *PmGroupConfig) GetGroupFreq() uint32 {
+	if m != nil {
+		return m.GroupFreq
+	}
+	return 0
+}
+
+func (m *PmGroupConfig) GetEnabled() bool {
+	if m != nil {
+		return m.Enabled
+	}
+	return false
+}
+
+func (m *PmGroupConfig) GetMetrics() []*PmConfig {
+	if m != nil {
+		return m.Metrics
+	}
+	return nil
+}
+
+type PmConfigs struct {
+	Id          string `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
+	DefaultFreq uint32 `protobuf:"varint,2,opt,name=default_freq,json=defaultFreq" json:"default_freq,omitempty"`
+	// Forces group names and group semantics
+	Grouped bool `protobuf:"varint,3,opt,name=grouped" json:"grouped,omitempty"`
+	// Allows Pm to set an individual sample frequency
+	FreqOverride bool             `protobuf:"varint,4,opt,name=freq_override,json=freqOverride" json:"freq_override,omitempty"`
+	Groups       []*PmGroupConfig `protobuf:"bytes,5,rep,name=groups" json:"groups,omitempty"`
+	Metrics      []*PmConfig      `protobuf:"bytes,6,rep,name=metrics" json:"metrics,omitempty"`
+}
+
+func (m *PmConfigs) Reset()                    { *m = PmConfigs{} }
+func (m *PmConfigs) String() string            { return proto.CompactTextString(m) }
+func (*PmConfigs) ProtoMessage()               {}
+func (*PmConfigs) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} }
+
+func (m *PmConfigs) GetId() string {
+	if m != nil {
+		return m.Id
+	}
+	return ""
+}
+
+func (m *PmConfigs) GetDefaultFreq() uint32 {
+	if m != nil {
+		return m.DefaultFreq
+	}
+	return 0
+}
+
+func (m *PmConfigs) GetGrouped() bool {
+	if m != nil {
+		return m.Grouped
+	}
+	return false
+}
+
+func (m *PmConfigs) GetFreqOverride() bool {
+	if m != nil {
+		return m.FreqOverride
+	}
+	return false
+}
+
+func (m *PmConfigs) GetGroups() []*PmGroupConfig {
+	if m != nil {
+		return m.Groups
+	}
+	return nil
+}
+
+func (m *PmConfigs) GetMetrics() []*PmConfig {
+	if m != nil {
+		return m.Metrics
+	}
+	return nil
+}
+
+type Port struct {
+	PortNo     uint32                        `protobuf:"varint,1,opt,name=port_no,json=portNo" json:"port_no,omitempty"`
+	Label      string                        `protobuf:"bytes,2,opt,name=label" json:"label,omitempty"`
+	Type       Port_PortType                 `protobuf:"varint,3,opt,name=type,enum=voltha.Port_PortType" json:"type,omitempty"`
+	AdminState voltha3.AdminState_AdminState `protobuf:"varint,5,opt,name=admin_state,json=adminState,enum=voltha.AdminState_AdminState" json:"admin_state,omitempty"`
+	OperStatus voltha3.OperStatus_OperStatus `protobuf:"varint,6,opt,name=oper_status,json=operStatus,enum=voltha.OperStatus_OperStatus" json:"oper_status,omitempty"`
+	DeviceId   string                        `protobuf:"bytes,7,opt,name=device_id,json=deviceId" json:"device_id,omitempty"`
+	Peers      []*Port_PeerPort              `protobuf:"bytes,8,rep,name=peers" json:"peers,omitempty"`
+}
+
+func (m *Port) Reset()                    { *m = Port{} }
+func (m *Port) String() string            { return proto.CompactTextString(m) }
+func (*Port) ProtoMessage()               {}
+func (*Port) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5} }
+
+func (m *Port) GetPortNo() uint32 {
+	if m != nil {
+		return m.PortNo
+	}
+	return 0
+}
+
+func (m *Port) GetLabel() string {
+	if m != nil {
+		return m.Label
+	}
+	return ""
+}
+
+func (m *Port) GetType() Port_PortType {
+	if m != nil {
+		return m.Type
+	}
+	return Port_UNKNOWN
+}
+
+func (m *Port) GetAdminState() voltha3.AdminState_AdminState {
+	if m != nil {
+		return m.AdminState
+	}
+	return voltha3.AdminState_UNKNOWN
+}
+
+func (m *Port) GetOperStatus() voltha3.OperStatus_OperStatus {
+	if m != nil {
+		return m.OperStatus
+	}
+	return voltha3.OperStatus_UNKNOWN
+}
+
+func (m *Port) GetDeviceId() string {
+	if m != nil {
+		return m.DeviceId
+	}
+	return ""
+}
+
+func (m *Port) GetPeers() []*Port_PeerPort {
+	if m != nil {
+		return m.Peers
+	}
+	return nil
+}
+
+type Port_PeerPort struct {
+	DeviceId string `protobuf:"bytes,1,opt,name=device_id,json=deviceId" json:"device_id,omitempty"`
+	PortNo   uint32 `protobuf:"varint,2,opt,name=port_no,json=portNo" json:"port_no,omitempty"`
+}
+
+func (m *Port_PeerPort) Reset()                    { *m = Port_PeerPort{} }
+func (m *Port_PeerPort) String() string            { return proto.CompactTextString(m) }
+func (*Port_PeerPort) ProtoMessage()               {}
+func (*Port_PeerPort) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5, 0} }
+
+func (m *Port_PeerPort) GetDeviceId() string {
+	if m != nil {
+		return m.DeviceId
+	}
+	return ""
+}
+
+func (m *Port_PeerPort) GetPortNo() uint32 {
+	if m != nil {
+		return m.PortNo
+	}
+	return 0
+}
+
+type Ports struct {
+	Items []*Port `protobuf:"bytes,1,rep,name=items" json:"items,omitempty"`
+}
+
+func (m *Ports) Reset()                    { *m = Ports{} }
+func (m *Ports) String() string            { return proto.CompactTextString(m) }
+func (*Ports) ProtoMessage()               {}
+func (*Ports) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{6} }
+
+func (m *Ports) GetItems() []*Port {
+	if m != nil {
+		return m.Items
+	}
+	return nil
+}
+
+// A Physical Device instance
+type Device struct {
+	// Voltha's device identifier
+	Id string `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
+	// Device type, refers to one of the registered device types
+	Type string `protobuf:"bytes,2,opt,name=type" json:"type,omitempty"`
+	// Is this device a root device. Each logical switch has one root
+	// device that is associated with the logical flow switch.
+	Root bool `protobuf:"varint,3,opt,name=root" json:"root,omitempty"`
+	// Parent device id, in the device tree (for a root device, the parent_id
+	// is the logical_device.id)
+	ParentId     string `protobuf:"bytes,4,opt,name=parent_id,json=parentId" json:"parent_id,omitempty"`
+	ParentPortNo uint32 `protobuf:"varint,20,opt,name=parent_port_no,json=parentPortNo" json:"parent_port_no,omitempty"`
+	// Vendor, version, serial number, etc.
+	Vendor          string `protobuf:"bytes,5,opt,name=vendor" json:"vendor,omitempty"`
+	Model           string `protobuf:"bytes,6,opt,name=model" json:"model,omitempty"`
+	HardwareVersion string `protobuf:"bytes,7,opt,name=hardware_version,json=hardwareVersion" json:"hardware_version,omitempty"`
+	FirmwareVersion string `protobuf:"bytes,8,opt,name=firmware_version,json=firmwareVersion" json:"firmware_version,omitempty"`
+	SoftwareVersion string `protobuf:"bytes,9,opt,name=software_version,json=softwareVersion" json:"software_version,omitempty"`
+	SerialNumber    string `protobuf:"bytes,10,opt,name=serial_number,json=serialNumber" json:"serial_number,omitempty"`
+	// Addapter that takes care of device
+	Adapter string `protobuf:"bytes,11,opt,name=adapter" json:"adapter,omitempty"`
+	// Device contact on vlan (if 0, no vlan)
+	Vlan uint32 `protobuf:"varint,12,opt,name=vlan" json:"vlan,omitempty"`
+	// Types that are valid to be assigned to Address:
+	//	*Device_MacAddress
+	//	*Device_Ipv4Address
+	//	*Device_Ipv6Address
+	//	*Device_HostAndPort
+	Address       isDevice_Address                    `protobuf_oneof:"address"`
+	ProxyAddress  *Device_ProxyAddress                `protobuf:"bytes,19,opt,name=proxy_address,json=proxyAddress" json:"proxy_address,omitempty"`
+	AdminState    voltha3.AdminState_AdminState       `protobuf:"varint,16,opt,name=admin_state,json=adminState,enum=voltha.AdminState_AdminState" json:"admin_state,omitempty"`
+	OperStatus    voltha3.OperStatus_OperStatus       `protobuf:"varint,17,opt,name=oper_status,json=operStatus,enum=voltha.OperStatus_OperStatus" json:"oper_status,omitempty"`
+	Reason        string                              `protobuf:"bytes,22,opt,name=reason" json:"reason,omitempty"`
+	ConnectStatus voltha3.ConnectStatus_ConnectStatus `protobuf:"varint,18,opt,name=connect_status,json=connectStatus,enum=voltha.ConnectStatus_ConnectStatus" json:"connect_status,omitempty"`
+	// Device type specific attributes
+	Custom     *google_protobuf1.Any   `protobuf:"bytes,64,opt,name=custom" json:"custom,omitempty"`
+	Ports      []*Port                 `protobuf:"bytes,128,rep,name=ports" json:"ports,omitempty"`
+	Flows      *openflow_13.Flows      `protobuf:"bytes,129,opt,name=flows" json:"flows,omitempty"`
+	FlowGroups *openflow_13.FlowGroups `protobuf:"bytes,130,opt,name=flow_groups,json=flowGroups" json:"flow_groups,omitempty"`
+	// PmConfigs will eventually converted to a child node of the
+	// device to falicitata callbacks and to simplify manipulation.
+	PmConfigs *PmConfigs `protobuf:"bytes,131,opt,name=pm_configs,json=pmConfigs" json:"pm_configs,omitempty"`
+}
+
+func (m *Device) Reset()                    { *m = Device{} }
+func (m *Device) String() string            { return proto.CompactTextString(m) }
+func (*Device) ProtoMessage()               {}
+func (*Device) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7} }
+
+type isDevice_Address interface {
+	isDevice_Address()
+}
+
+type Device_MacAddress struct {
+	MacAddress string `protobuf:"bytes,13,opt,name=mac_address,json=macAddress,oneof"`
+}
+type Device_Ipv4Address struct {
+	Ipv4Address string `protobuf:"bytes,14,opt,name=ipv4_address,json=ipv4Address,oneof"`
+}
+type Device_Ipv6Address struct {
+	Ipv6Address string `protobuf:"bytes,15,opt,name=ipv6_address,json=ipv6Address,oneof"`
+}
+type Device_HostAndPort struct {
+	HostAndPort string `protobuf:"bytes,21,opt,name=host_and_port,json=hostAndPort,oneof"`
+}
+
+func (*Device_MacAddress) isDevice_Address()  {}
+func (*Device_Ipv4Address) isDevice_Address() {}
+func (*Device_Ipv6Address) isDevice_Address() {}
+func (*Device_HostAndPort) isDevice_Address() {}
+
+func (m *Device) GetAddress() isDevice_Address {
+	if m != nil {
+		return m.Address
+	}
+	return nil
+}
+
+func (m *Device) GetId() string {
+	if m != nil {
+		return m.Id
+	}
+	return ""
+}
+
+func (m *Device) GetType() string {
+	if m != nil {
+		return m.Type
+	}
+	return ""
+}
+
+func (m *Device) GetRoot() bool {
+	if m != nil {
+		return m.Root
+	}
+	return false
+}
+
+func (m *Device) GetParentId() string {
+	if m != nil {
+		return m.ParentId
+	}
+	return ""
+}
+
+func (m *Device) GetParentPortNo() uint32 {
+	if m != nil {
+		return m.ParentPortNo
+	}
+	return 0
+}
+
+func (m *Device) GetVendor() string {
+	if m != nil {
+		return m.Vendor
+	}
+	return ""
+}
+
+func (m *Device) GetModel() string {
+	if m != nil {
+		return m.Model
+	}
+	return ""
+}
+
+func (m *Device) GetHardwareVersion() string {
+	if m != nil {
+		return m.HardwareVersion
+	}
+	return ""
+}
+
+func (m *Device) GetFirmwareVersion() string {
+	if m != nil {
+		return m.FirmwareVersion
+	}
+	return ""
+}
+
+func (m *Device) GetSoftwareVersion() string {
+	if m != nil {
+		return m.SoftwareVersion
+	}
+	return ""
+}
+
+func (m *Device) GetSerialNumber() string {
+	if m != nil {
+		return m.SerialNumber
+	}
+	return ""
+}
+
+func (m *Device) GetAdapter() string {
+	if m != nil {
+		return m.Adapter
+	}
+	return ""
+}
+
+func (m *Device) GetVlan() uint32 {
+	if m != nil {
+		return m.Vlan
+	}
+	return 0
+}
+
+func (m *Device) GetMacAddress() string {
+	if x, ok := m.GetAddress().(*Device_MacAddress); ok {
+		return x.MacAddress
+	}
+	return ""
+}
+
+func (m *Device) GetIpv4Address() string {
+	if x, ok := m.GetAddress().(*Device_Ipv4Address); ok {
+		return x.Ipv4Address
+	}
+	return ""
+}
+
+func (m *Device) GetIpv6Address() string {
+	if x, ok := m.GetAddress().(*Device_Ipv6Address); ok {
+		return x.Ipv6Address
+	}
+	return ""
+}
+
+func (m *Device) GetHostAndPort() string {
+	if x, ok := m.GetAddress().(*Device_HostAndPort); ok {
+		return x.HostAndPort
+	}
+	return ""
+}
+
+func (m *Device) GetProxyAddress() *Device_ProxyAddress {
+	if m != nil {
+		return m.ProxyAddress
+	}
+	return nil
+}
+
+func (m *Device) GetAdminState() voltha3.AdminState_AdminState {
+	if m != nil {
+		return m.AdminState
+	}
+	return voltha3.AdminState_UNKNOWN
+}
+
+func (m *Device) GetOperStatus() voltha3.OperStatus_OperStatus {
+	if m != nil {
+		return m.OperStatus
+	}
+	return voltha3.OperStatus_UNKNOWN
+}
+
+func (m *Device) GetReason() string {
+	if m != nil {
+		return m.Reason
+	}
+	return ""
+}
+
+func (m *Device) GetConnectStatus() voltha3.ConnectStatus_ConnectStatus {
+	if m != nil {
+		return m.ConnectStatus
+	}
+	return voltha3.ConnectStatus_UNKNOWN
+}
+
+func (m *Device) GetCustom() *google_protobuf1.Any {
+	if m != nil {
+		return m.Custom
+	}
+	return nil
+}
+
+func (m *Device) GetPorts() []*Port {
+	if m != nil {
+		return m.Ports
+	}
+	return nil
+}
+
+func (m *Device) GetFlows() *openflow_13.Flows {
+	if m != nil {
+		return m.Flows
+	}
+	return nil
+}
+
+func (m *Device) GetFlowGroups() *openflow_13.FlowGroups {
+	if m != nil {
+		return m.FlowGroups
+	}
+	return nil
+}
+
+func (m *Device) GetPmConfigs() *PmConfigs {
+	if m != nil {
+		return m.PmConfigs
+	}
+	return nil
+}
+
+// XXX_OneofFuncs is for the internal use of the proto package.
+func (*Device) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
+	return _Device_OneofMarshaler, _Device_OneofUnmarshaler, _Device_OneofSizer, []interface{}{
+		(*Device_MacAddress)(nil),
+		(*Device_Ipv4Address)(nil),
+		(*Device_Ipv6Address)(nil),
+		(*Device_HostAndPort)(nil),
+	}
+}
+
+func _Device_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
+	m := msg.(*Device)
+	// address
+	switch x := m.Address.(type) {
+	case *Device_MacAddress:
+		b.EncodeVarint(13<<3 | proto.WireBytes)
+		b.EncodeStringBytes(x.MacAddress)
+	case *Device_Ipv4Address:
+		b.EncodeVarint(14<<3 | proto.WireBytes)
+		b.EncodeStringBytes(x.Ipv4Address)
+	case *Device_Ipv6Address:
+		b.EncodeVarint(15<<3 | proto.WireBytes)
+		b.EncodeStringBytes(x.Ipv6Address)
+	case *Device_HostAndPort:
+		b.EncodeVarint(21<<3 | proto.WireBytes)
+		b.EncodeStringBytes(x.HostAndPort)
+	case nil:
+	default:
+		return fmt.Errorf("Device.Address has unexpected type %T", x)
+	}
+	return nil
+}
+
+func _Device_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
+	m := msg.(*Device)
+	switch tag {
+	case 13: // address.mac_address
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeStringBytes()
+		m.Address = &Device_MacAddress{x}
+		return true, err
+	case 14: // address.ipv4_address
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeStringBytes()
+		m.Address = &Device_Ipv4Address{x}
+		return true, err
+	case 15: // address.ipv6_address
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeStringBytes()
+		m.Address = &Device_Ipv6Address{x}
+		return true, err
+	case 21: // address.host_and_port
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeStringBytes()
+		m.Address = &Device_HostAndPort{x}
+		return true, err
+	default:
+		return false, nil
+	}
+}
+
+func _Device_OneofSizer(msg proto.Message) (n int) {
+	m := msg.(*Device)
+	// address
+	switch x := m.Address.(type) {
+	case *Device_MacAddress:
+		n += proto.SizeVarint(13<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(len(x.MacAddress)))
+		n += len(x.MacAddress)
+	case *Device_Ipv4Address:
+		n += proto.SizeVarint(14<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(len(x.Ipv4Address)))
+		n += len(x.Ipv4Address)
+	case *Device_Ipv6Address:
+		n += proto.SizeVarint(15<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(len(x.Ipv6Address)))
+		n += len(x.Ipv6Address)
+	case *Device_HostAndPort:
+		n += proto.SizeVarint(21<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(len(x.HostAndPort)))
+		n += len(x.HostAndPort)
+	case nil:
+	default:
+		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
+	}
+	return n
+}
+
+type Device_ProxyAddress struct {
+	DeviceId     string `protobuf:"bytes,1,opt,name=device_id,json=deviceId" json:"device_id,omitempty"`
+	ChannelId    uint32 `protobuf:"varint,2,opt,name=channel_id,json=channelId" json:"channel_id,omitempty"`
+	OnuId        uint32 `protobuf:"varint,3,opt,name=onu_id,json=onuId" json:"onu_id,omitempty"`
+	OnuSessionId uint32 `protobuf:"varint,4,opt,name=onu_session_id,json=onuSessionId" json:"onu_session_id,omitempty"`
+}
+
+func (m *Device_ProxyAddress) Reset()                    { *m = Device_ProxyAddress{} }
+func (m *Device_ProxyAddress) String() string            { return proto.CompactTextString(m) }
+func (*Device_ProxyAddress) ProtoMessage()               {}
+func (*Device_ProxyAddress) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7, 0} }
+
+func (m *Device_ProxyAddress) GetDeviceId() string {
+	if m != nil {
+		return m.DeviceId
+	}
+	return ""
+}
+
+func (m *Device_ProxyAddress) GetChannelId() uint32 {
+	if m != nil {
+		return m.ChannelId
+	}
+	return 0
+}
+
+func (m *Device_ProxyAddress) GetOnuId() uint32 {
+	if m != nil {
+		return m.OnuId
+	}
+	return 0
+}
+
+func (m *Device_ProxyAddress) GetOnuSessionId() uint32 {
+	if m != nil {
+		return m.OnuSessionId
+	}
+	return 0
+}
+
+type Devices struct {
+	Items []*Device `protobuf:"bytes,1,rep,name=items" json:"items,omitempty"`
+}
+
+func (m *Devices) Reset()                    { *m = Devices{} }
+func (m *Devices) String() string            { return proto.CompactTextString(m) }
+func (*Devices) ProtoMessage()               {}
+func (*Devices) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{8} }
+
+func (m *Devices) GetItems() []*Device {
+	if m != nil {
+		return m.Items
+	}
+	return nil
+}
+
+func init() {
+	proto.RegisterType((*DeviceType)(nil), "voltha.DeviceType")
+	proto.RegisterType((*DeviceTypes)(nil), "voltha.DeviceTypes")
+	proto.RegisterType((*PmConfig)(nil), "voltha.PmConfig")
+	proto.RegisterType((*PmGroupConfig)(nil), "voltha.PmGroupConfig")
+	proto.RegisterType((*PmConfigs)(nil), "voltha.PmConfigs")
+	proto.RegisterType((*Port)(nil), "voltha.Port")
+	proto.RegisterType((*Port_PeerPort)(nil), "voltha.Port.PeerPort")
+	proto.RegisterType((*Ports)(nil), "voltha.Ports")
+	proto.RegisterType((*Device)(nil), "voltha.Device")
+	proto.RegisterType((*Device_ProxyAddress)(nil), "voltha.Device.ProxyAddress")
+	proto.RegisterType((*Devices)(nil), "voltha.Devices")
+	proto.RegisterEnum("voltha.PmConfig_PmType", PmConfig_PmType_name, PmConfig_PmType_value)
+	proto.RegisterEnum("voltha.Port_PortType", Port_PortType_name, Port_PortType_value)
+}
+
+func init() { proto.RegisterFile("device.proto", fileDescriptor0) }
+
+var fileDescriptor0 = []byte{
+	// 1280 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x56, 0x4d, 0x6f, 0xdb, 0xb6,
+	0x1b, 0x8f, 0x1c, 0xcb, 0x2f, 0x8f, 0x5f, 0xea, 0xf2, 0xdf, 0xfc, 0xab, 0x26, 0x30, 0x9a, 0xba,
+	0x3d, 0x64, 0xcd, 0xe6, 0x76, 0xed, 0xd0, 0x0e, 0x3b, 0x0c, 0x71, 0x5a, 0xb7, 0x0d, 0x36, 0x38,
+	0x9e, 0x62, 0x6f, 0x47, 0x81, 0x91, 0xe8, 0x44, 0xa8, 0x44, 0xaa, 0xa4, 0xec, 0x2e, 0xb7, 0xbd,
+	0x1c, 0xf6, 0x01, 0xf6, 0x51, 0x86, 0x7d, 0x89, 0x01, 0xbd, 0xed, 0x13, 0xec, 0x30, 0xec, 0xb8,
+	0x53, 0xce, 0x03, 0x49, 0x51, 0x91, 0xd2, 0xa1, 0xdb, 0x2e, 0x06, 0xf9, 0x7b, 0x21, 0xf9, 0x3c,
+	0x7e, 0xf8, 0x50, 0xd0, 0x0e, 0xc8, 0x2a, 0xf4, 0xc9, 0x30, 0xe1, 0x2c, 0x65, 0xa8, 0xb6, 0x62,
+	0x51, 0x7a, 0x8a, 0x37, 0x21, 0x26, 0x29, 0xd6, 0xd8, 0xe6, 0x8d, 0x13, 0xc6, 0x4e, 0x22, 0x72,
+	0x4f, 0xcd, 0x8e, 0x97, 0x8b, 0x7b, 0x98, 0x9e, 0x65, 0x54, 0xdb, 0x67, 0x71, 0xcc, 0x68, 0x36,
+	0xbb, 0xca, 0x12, 0x42, 0x17, 0x11, 0x7b, 0xed, 0x7d, 0xf8, 0x30, 0x83, 0xd0, 0x19, 0xa6, 0x27,
+	0x1e, 0x4b, 0xd2, 0x90, 0x51, 0xa1, 0xb1, 0xc1, 0xcf, 0x16, 0xc0, 0x53, 0xb5, 0xe9, 0xec, 0x2c,
+	0x21, 0xa8, 0x0b, 0x95, 0x30, 0x70, 0xac, 0x6d, 0x6b, 0xa7, 0xe9, 0x56, 0xc2, 0x00, 0x39, 0x50,
+	0xc7, 0x01, 0x4e, 0x52, 0xc2, 0x9d, 0x8a, 0x02, 0xcd, 0x14, 0x3d, 0x06, 0x07, 0xfb, 0x3e, 0x49,
+	0x52, 0xe1, 0x1d, 0x2f, 0xa3, 0x97, 0x9e, 0xda, 0x6a, 0x99, 0x04, 0x38, 0x25, 0xce, 0xfa, 0xb6,
+	0xb5, 0xd3, 0x70, 0x37, 0x32, 0x7e, 0x7f, 0x19, 0xbd, 0x7c, 0x16, 0xb1, 0xd7, 0x73, 0x45, 0xa2,
+	0xa7, 0x70, 0xd3, 0x18, 0x71, 0x10, 0x78, 0x9c, 0xc4, 0x6c, 0x45, 0x8a, 0x76, 0xe1, 0x54, 0x95,
+	0x7f, 0x2b, 0x93, 0x8d, 0x82, 0xc0, 0x55, 0xa2, 0x8b, 0x45, 0xc4, 0xe0, 0x31, 0xb4, 0x2e, 0x8e,
+	0x2d, 0xd0, 0x0e, 0xd8, 0x61, 0x4a, 0x62, 0xe1, 0x58, 0xdb, 0xeb, 0x3b, 0xad, 0x07, 0x68, 0xa8,
+	0x53, 0x37, 0xbc, 0xd0, 0xb8, 0x5a, 0x30, 0xf8, 0xc9, 0x82, 0xc6, 0x34, 0x7e, 0xc2, 0xe8, 0x22,
+	0x3c, 0x41, 0x08, 0xaa, 0x14, 0xc7, 0x24, 0x0b, 0x58, 0x8d, 0xd1, 0x2e, 0x54, 0xd3, 0xb3, 0x84,
+	0xa8, 0x78, 0xbb, 0x0f, 0xae, 0x9b, 0x95, 0x8c, 0x67, 0x38, 0x8d, 0xd5, 0x72, 0x4a, 0x24, 0xf3,
+	0x43, 0x28, 0x3e, 0x8e, 0x48, 0x90, 0x05, 0x6d, 0xa6, 0xe8, 0x26, 0xb4, 0x04, 0x8e, 0x93, 0x88,
+	0x78, 0x0b, 0x4e, 0x5e, 0xa9, 0x90, 0x3a, 0x2e, 0x68, 0xe8, 0x19, 0x27, 0xaf, 0x06, 0xbb, 0x50,
+	0xd3, 0x4b, 0xa1, 0x16, 0xd4, 0x9f, 0x1c, 0xce, 0x27, 0xb3, 0xb1, 0xdb, 0x5b, 0x43, 0x4d, 0xb0,
+	0x9f, 0xcf, 0x47, 0xcf, 0xc7, 0x3d, 0x4b, 0x0e, 0x8f, 0x66, 0xa3, 0xd9, 0xb8, 0x57, 0x19, 0xfc,
+	0x68, 0x41, 0x67, 0x1a, 0x3f, 0xe7, 0x6c, 0x99, 0x64, 0x47, 0xef, 0x03, 0x9c, 0xc8, 0xa9, 0x57,
+	0x08, 0xa0, 0xa9, 0x90, 0x89, 0x8c, 0x22, 0xa7, 0xd5, 0xee, 0x15, 0xb5, 0xbb, 0xa6, 0xe5, 0xe6,
+	0xef, 0x38, 0xf7, 0x5d, 0xa8, 0xc7, 0x24, 0xe5, 0xa1, 0x2f, 0xff, 0x06, 0x99, 0xcb, 0xde, 0xe5,
+	0x0c, 0xb8, 0x46, 0x30, 0xf8, 0xdd, 0x82, 0xa6, 0x41, 0xc5, 0x5b, 0xb5, 0x73, 0x4b, 0x96, 0xf3,
+	0x02, 0x2f, 0xa3, 0xb4, 0x78, 0x88, 0x56, 0x86, 0xa9, 0x63, 0xdc, 0x84, 0xba, 0x3a, 0x93, 0x39,
+	0xc6, 0xbe, 0xfd, 0xc7, 0xf9, 0x9b, 0xbe, 0xe5, 0x1a, 0x14, 0xdd, 0x85, 0x8e, 0xf4, 0x7a, 0x6c,
+	0x45, 0x38, 0x0f, 0x03, 0xa2, 0x4b, 0xc3, 0xc8, 0xda, 0x92, 0x3b, 0xcc, 0x28, 0xf4, 0x01, 0xd4,
+	0x94, 0x4d, 0x38, 0xb6, 0x3a, 0xf8, 0xc6, 0xc5, 0xc1, 0x0b, 0x89, 0x73, 0x33, 0x51, 0x31, 0xd0,
+	0xda, 0x3f, 0x05, 0xfa, 0xcb, 0x3a, 0x54, 0xa7, 0x8c, 0xa7, 0xe8, 0x3a, 0xd4, 0x13, 0xc6, 0x53,
+	0x8f, 0x32, 0x15, 0x68, 0xc7, 0xad, 0xc9, 0xe9, 0x84, 0xa1, 0x6b, 0x60, 0x47, 0xf8, 0x98, 0x44,
+	0xd9, 0x35, 0xd1, 0x13, 0xf4, 0x5e, 0x56, 0x4b, 0xeb, 0xaa, 0x96, 0x2e, 0x0e, 0xc4, 0x78, 0xaa,
+	0x7e, 0x0a, 0x95, 0xf4, 0x29, 0xb4, 0x70, 0x10, 0x87, 0xd4, 0x13, 0xa9, 0xbc, 0x42, 0xb6, 0x72,
+	0xf4, 0x8d, 0x63, 0x24, 0xa9, 0x23, 0xc9, 0x14, 0x86, 0x2e, 0xe0, 0x7c, 0x2c, 0xfd, 0x2c, 0x21,
+	0x5c, 0xd9, 0x97, 0x32, 0xa4, 0x92, 0xff, 0x30, 0x21, 0xfc, 0x48, 0x31, 0x85, 0xa1, 0x0b, 0x2c,
+	0x1f, 0xa3, 0x2d, 0x68, 0xea, 0xe6, 0xe3, 0x85, 0x81, 0x53, 0x57, 0x41, 0x34, 0x34, 0x70, 0x10,
+	0xa0, 0x5d, 0xb0, 0x13, 0x42, 0xb8, 0x70, 0x1a, 0x97, 0x32, 0xab, 0x02, 0x21, 0x84, 0xcb, 0x81,
+	0xab, 0x35, 0x9b, 0x7b, 0xd0, 0x30, 0x50, 0x79, 0x55, 0xeb, 0xd2, 0xaa, 0x85, 0x64, 0x56, 0x8a,
+	0xc9, 0x1c, 0xcc, 0xa1, 0x61, 0xb2, 0x23, 0x2f, 0xc7, 0x7c, 0xf2, 0xd9, 0xe4, 0xf0, 0xab, 0x49,
+	0x6f, 0x0d, 0xf5, 0xa0, 0x3d, 0x9e, 0xbd, 0x18, 0xbb, 0x93, 0xf1, 0xcc, 0x9b, 0x4c, 0x0e, 0x7a,
+	0x56, 0x09, 0x99, 0x4f, 0x0e, 0x7a, 0x15, 0x69, 0x98, 0x1e, 0x4e, 0xbc, 0xc3, 0xcf, 0x67, 0xbd,
+	0xf5, 0x7c, 0x32, 0x99, 0xf7, 0xaa, 0x9f, 0xd8, 0x7f, 0x9e, 0xbf, 0xe9, 0xaf, 0x0d, 0x76, 0xc1,
+	0x96, 0xab, 0x0b, 0x34, 0x28, 0x37, 0x8d, 0x76, 0x31, 0x2a, 0xd3, 0x2e, 0x7e, 0x05, 0xa8, 0xe9,
+	0x26, 0x82, 0x36, 0x2e, 0xea, 0xdb, 0x14, 0xa0, 0x2c, 0xf3, 0x1b, 0x85, 0x7e, 0x91, 0x13, 0xfa,
+	0x3f, 0xbd, 0x01, 0x55, 0xce, 0x58, 0x5a, 0xae, 0x6d, 0x05, 0xa1, 0x01, 0x34, 0x13, 0xcc, 0x09,
+	0x4d, 0x65, 0x62, 0xaa, 0x45, 0x6b, 0x43, 0xe3, 0x2a, 0xeb, 0xdd, 0x4c, 0x63, 0xd2, 0x74, 0x4d,
+	0xa6, 0x29, 0xaf, 0x7e, 0x4d, 0x4e, 0x75, 0x01, 0xf6, 0xa1, 0xb6, 0x22, 0x34, 0x60, 0x5c, 0x95,
+	0x4e, 0xbe, 0x5a, 0x06, 0xa2, 0x2d, 0xb0, 0x63, 0x16, 0x90, 0x48, 0x15, 0x46, 0xce, 0x6a, 0x0c,
+	0xdd, 0x87, 0xde, 0x29, 0xe6, 0xc1, 0x6b, 0xcc, 0x89, 0xb7, 0x22, 0x5c, 0x84, 0x8c, 0xea, 0x12,
+	0x30, 0xba, 0x2b, 0x86, 0xfe, 0x52, 0xb3, 0xd2, 0xb1, 0x08, 0x79, 0x5c, 0x72, 0x34, 0x4a, 0x0e,
+	0x43, 0x17, 0x1c, 0x82, 0x2d, 0xd2, 0x92, 0xa3, 0x59, 0x72, 0x18, 0xda, 0x38, 0xee, 0x42, 0x47,
+	0x10, 0x1e, 0xe2, 0xc8, 0xa3, 0xcb, 0xf8, 0x98, 0x70, 0x07, 0x8a, 0xf2, 0xb6, 0xe6, 0x26, 0x8a,
+	0x92, 0x8d, 0xc4, 0xbc, 0x53, 0xad, 0xa2, 0x2a, 0x7f, 0xae, 0x10, 0x54, 0x57, 0x11, 0xa6, 0x4e,
+	0x5b, 0x15, 0x9a, 0x1a, 0xa3, 0x5b, 0xd0, 0x8a, 0xb1, 0x2f, 0x5f, 0x21, 0x4e, 0x84, 0x70, 0x3a,
+	0xd2, 0xf8, 0x62, 0xcd, 0x85, 0x18, 0xfb, 0x23, 0x8d, 0xa1, 0xdb, 0xd0, 0x0e, 0x93, 0xd5, 0x47,
+	0xb9, 0xa6, 0x9b, 0x69, 0x5a, 0x12, 0x2d, 0x8b, 0x1e, 0xe5, 0xa2, 0x2b, 0x05, 0xd1, 0x23, 0x23,
+	0xba, 0x03, 0x9d, 0x53, 0x26, 0x52, 0x0f, 0xd3, 0x40, 0xfd, 0x9d, 0xce, 0x86, 0x51, 0x49, 0x78,
+	0x44, 0x03, 0x75, 0x5f, 0xf6, 0xa0, 0x93, 0x70, 0xf6, 0xf5, 0x59, 0xbe, 0xd6, 0xff, 0xb6, 0xad,
+	0x9d, 0xd6, 0x83, 0xad, 0xf2, 0x7b, 0x36, 0x9c, 0x4a, 0x4d, 0xb6, 0xb2, 0xdb, 0x4e, 0x0a, 0xb3,
+	0xcb, 0x7d, 0xa4, 0xf7, 0x5f, 0xfb, 0xc8, 0xb8, 0xdc, 0x47, 0xae, 0xfe, 0x8b, 0x3e, 0x62, 0x92,
+	0x5d, 0x6c, 0x27, 0x7d, 0xa8, 0x71, 0x82, 0x05, 0xa3, 0xce, 0xff, 0x4b, 0xe5, 0xa8, 0x41, 0xf4,
+	0x05, 0x74, 0x7d, 0x46, 0x29, 0xf1, 0x53, 0xb3, 0x11, 0x52, 0x1b, 0xdd, 0x36, 0x1b, 0x3d, 0xd1,
+	0x6c, 0xb6, 0x57, 0x69, 0x66, 0xd6, 0xea, 0xf8, 0x45, 0x14, 0xbd, 0x0f, 0x35, 0x7f, 0x29, 0x52,
+	0x16, 0x3b, 0x7b, 0x2a, 0x67, 0xd7, 0x86, 0xfa, 0x53, 0x69, 0x68, 0x3e, 0x95, 0x86, 0x23, 0x7a,
+	0xe6, 0x66, 0x1a, 0xf4, 0x10, 0x6c, 0xf9, 0x2f, 0x08, 0xe7, 0x9b, 0xbf, 0xb9, 0xfc, 0xfb, 0xdd,
+	0xdf, 0xce, 0xdf, 0xf4, 0x9b, 0x79, 0x7b, 0x72, 0xb5, 0x16, 0xdd, 0x07, 0x5b, 0x7e, 0xa7, 0x08,
+	0xe7, 0x5b, 0x4b, 0x6d, 0x81, 0x86, 0xc5, 0x8f, 0x2c, 0xf9, 0x79, 0x22, 0xf6, 0x6d, 0x69, 0x5d,
+	0x73, 0xb5, 0x10, 0xed, 0x41, 0x4b, 0xd1, 0xd9, 0xc3, 0xf4, 0x9d, 0xf6, 0x5d, 0x7f, 0xcb, 0xa7,
+	0x1e, 0xa8, 0xdc, 0x0c, 0x8b, 0x1c, 0x42, 0x1f, 0x03, 0x24, 0xb1, 0xe7, 0xeb, 0x37, 0xd6, 0xf9,
+	0x5e, 0x2f, 0x70, 0xf5, 0xf2, 0x53, 0x95, 0x5b, 0x9b, 0x89, 0x41, 0x36, 0x7f, 0xb0, 0xa0, 0x5d,
+	0x2c, 0x94, 0x77, 0x37, 0xe3, 0x3e, 0x80, 0x7f, 0x8a, 0x29, 0x25, 0x91, 0x64, 0xb3, 0x0f, 0x86,
+	0x0c, 0x39, 0x08, 0xd0, 0x06, 0xd4, 0x18, 0x5d, 0x4a, 0x6a, 0x5d, 0x51, 0x36, 0xa3, 0xcb, 0x83,
+	0x00, 0xdd, 0x81, 0xae, 0x84, 0x05, 0x11, 0xf2, 0xca, 0x9a, 0x5e, 0xd6, 0x71, 0xdb, 0x8c, 0x2e,
+	0x8f, 0x34, 0x78, 0x10, 0x64, 0x8d, 0x77, 0xbf, 0x29, 0x2f, 0xa9, 0x3a, 0xca, 0xe0, 0x1e, 0xd4,
+	0x75, 0x29, 0xcb, 0x8b, 0x51, 0xea, 0xc2, 0xdd, 0x72, 0xa9, 0x67, 0x7d, 0xf8, 0xb8, 0xa6, 0xfe,
+	0xc5, 0x87, 0x7f, 0x05, 0x00, 0x00, 0xff, 0xff, 0xa7, 0x33, 0xa2, 0x3e, 0x22, 0x0b, 0x00, 0x00,
+}
diff --git a/netopeer/voltha-grpc-client/voltha/events/events.pb.go b/netopeer/voltha-grpc-client/voltha/events/events.pb.go
new file mode 100644
index 0000000..dea9896
--- /dev/null
+++ b/netopeer/voltha-grpc-client/voltha/events/events.pb.go
@@ -0,0 +1,518 @@
+// Code generated by protoc-gen-go.
+// source: events.proto
+// DO NOT EDIT!
+
+/*
+Package voltha is a generated protocol buffer package.
+
+It is generated from these files:
+	events.proto
+
+It has these top-level messages:
+	ConfigEventType
+	ConfigEvent
+	KpiEventType
+	MetricValuePairs
+	KpiEvent
+	AlarmEventType
+	AlarmEventCategory
+	AlarmEventState
+	AlarmEventSeverity
+	AlarmEvent
+*/
+package events
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+type ConfigEventType_ConfigEventType int32
+
+const (
+	ConfigEventType_add    ConfigEventType_ConfigEventType = 0
+	ConfigEventType_remove ConfigEventType_ConfigEventType = 1
+	ConfigEventType_update ConfigEventType_ConfigEventType = 2
+)
+
+var ConfigEventType_ConfigEventType_name = map[int32]string{
+	0: "add",
+	1: "remove",
+	2: "update",
+}
+var ConfigEventType_ConfigEventType_value = map[string]int32{
+	"add":    0,
+	"remove": 1,
+	"update": 2,
+}
+
+func (x ConfigEventType_ConfigEventType) String() string {
+	return proto.EnumName(ConfigEventType_ConfigEventType_name, int32(x))
+}
+func (ConfigEventType_ConfigEventType) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor0, []int{0, 0}
+}
+
+type KpiEventType_KpiEventType int32
+
+const (
+	KpiEventType_slice KpiEventType_KpiEventType = 0
+	KpiEventType_ts    KpiEventType_KpiEventType = 1
+)
+
+var KpiEventType_KpiEventType_name = map[int32]string{
+	0: "slice",
+	1: "ts",
+}
+var KpiEventType_KpiEventType_value = map[string]int32{
+	"slice": 0,
+	"ts":    1,
+}
+
+func (x KpiEventType_KpiEventType) String() string {
+	return proto.EnumName(KpiEventType_KpiEventType_name, int32(x))
+}
+func (KpiEventType_KpiEventType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{2, 0} }
+
+type AlarmEventType_AlarmEventType int32
+
+const (
+	AlarmEventType_COMMUNICATION AlarmEventType_AlarmEventType = 0
+	AlarmEventType_ENVIRONMENT   AlarmEventType_AlarmEventType = 1
+	AlarmEventType_EQUIPMENT     AlarmEventType_AlarmEventType = 2
+	AlarmEventType_SERVICE       AlarmEventType_AlarmEventType = 3
+	AlarmEventType_PROCESSING    AlarmEventType_AlarmEventType = 4
+	AlarmEventType_SECURITY      AlarmEventType_AlarmEventType = 5
+)
+
+var AlarmEventType_AlarmEventType_name = map[int32]string{
+	0: "COMMUNICATION",
+	1: "ENVIRONMENT",
+	2: "EQUIPMENT",
+	3: "SERVICE",
+	4: "PROCESSING",
+	5: "SECURITY",
+}
+var AlarmEventType_AlarmEventType_value = map[string]int32{
+	"COMMUNICATION": 0,
+	"ENVIRONMENT":   1,
+	"EQUIPMENT":     2,
+	"SERVICE":       3,
+	"PROCESSING":    4,
+	"SECURITY":      5,
+}
+
+func (x AlarmEventType_AlarmEventType) String() string {
+	return proto.EnumName(AlarmEventType_AlarmEventType_name, int32(x))
+}
+func (AlarmEventType_AlarmEventType) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor0, []int{5, 0}
+}
+
+type AlarmEventCategory_AlarmEventCategory int32
+
+const (
+	AlarmEventCategory_PON AlarmEventCategory_AlarmEventCategory = 0
+)
+
+var AlarmEventCategory_AlarmEventCategory_name = map[int32]string{
+	0: "PON",
+}
+var AlarmEventCategory_AlarmEventCategory_value = map[string]int32{
+	"PON": 0,
+}
+
+func (x AlarmEventCategory_AlarmEventCategory) String() string {
+	return proto.EnumName(AlarmEventCategory_AlarmEventCategory_name, int32(x))
+}
+func (AlarmEventCategory_AlarmEventCategory) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor0, []int{6, 0}
+}
+
+type AlarmEventState_AlarmEventState int32
+
+const (
+	AlarmEventState_RAISED  AlarmEventState_AlarmEventState = 0
+	AlarmEventState_CLEARED AlarmEventState_AlarmEventState = 1
+)
+
+var AlarmEventState_AlarmEventState_name = map[int32]string{
+	0: "RAISED",
+	1: "CLEARED",
+}
+var AlarmEventState_AlarmEventState_value = map[string]int32{
+	"RAISED":  0,
+	"CLEARED": 1,
+}
+
+func (x AlarmEventState_AlarmEventState) String() string {
+	return proto.EnumName(AlarmEventState_AlarmEventState_name, int32(x))
+}
+func (AlarmEventState_AlarmEventState) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor0, []int{7, 0}
+}
+
+type AlarmEventSeverity_AlarmEventSeverity int32
+
+const (
+	AlarmEventSeverity_INDETERMINATE AlarmEventSeverity_AlarmEventSeverity = 0
+	AlarmEventSeverity_WARNING       AlarmEventSeverity_AlarmEventSeverity = 1
+	AlarmEventSeverity_MINOR         AlarmEventSeverity_AlarmEventSeverity = 2
+	AlarmEventSeverity_MAJOR         AlarmEventSeverity_AlarmEventSeverity = 3
+	AlarmEventSeverity_CRITICAL      AlarmEventSeverity_AlarmEventSeverity = 4
+)
+
+var AlarmEventSeverity_AlarmEventSeverity_name = map[int32]string{
+	0: "INDETERMINATE",
+	1: "WARNING",
+	2: "MINOR",
+	3: "MAJOR",
+	4: "CRITICAL",
+}
+var AlarmEventSeverity_AlarmEventSeverity_value = map[string]int32{
+	"INDETERMINATE": 0,
+	"WARNING":       1,
+	"MINOR":         2,
+	"MAJOR":         3,
+	"CRITICAL":      4,
+}
+
+func (x AlarmEventSeverity_AlarmEventSeverity) String() string {
+	return proto.EnumName(AlarmEventSeverity_AlarmEventSeverity_name, int32(x))
+}
+func (AlarmEventSeverity_AlarmEventSeverity) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor0, []int{8, 0}
+}
+
+type ConfigEventType struct {
+}
+
+func (m *ConfigEventType) Reset()                    { *m = ConfigEventType{} }
+func (m *ConfigEventType) String() string            { return proto.CompactTextString(m) }
+func (*ConfigEventType) ProtoMessage()               {}
+func (*ConfigEventType) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
+
+type ConfigEvent struct {
+	Type ConfigEventType_ConfigEventType `protobuf:"varint,1,opt,name=type,enum=voltha.ConfigEventType_ConfigEventType" json:"type,omitempty"`
+	Hash string                          `protobuf:"bytes,2,opt,name=hash" json:"hash,omitempty"`
+	Data string                          `protobuf:"bytes,3,opt,name=data" json:"data,omitempty"`
+}
+
+func (m *ConfigEvent) Reset()                    { *m = ConfigEvent{} }
+func (m *ConfigEvent) String() string            { return proto.CompactTextString(m) }
+func (*ConfigEvent) ProtoMessage()               {}
+func (*ConfigEvent) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
+
+func (m *ConfigEvent) GetType() ConfigEventType_ConfigEventType {
+	if m != nil {
+		return m.Type
+	}
+	return ConfigEventType_add
+}
+
+func (m *ConfigEvent) GetHash() string {
+	if m != nil {
+		return m.Hash
+	}
+	return ""
+}
+
+func (m *ConfigEvent) GetData() string {
+	if m != nil {
+		return m.Data
+	}
+	return ""
+}
+
+type KpiEventType struct {
+}
+
+func (m *KpiEventType) Reset()                    { *m = KpiEventType{} }
+func (m *KpiEventType) String() string            { return proto.CompactTextString(m) }
+func (*KpiEventType) ProtoMessage()               {}
+func (*KpiEventType) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }
+
+//
+// Struct to convey a dictionary of metric->value pairs. Typically used in
+// pure shared-timestamp or shared-timestamp + shared object prefix situations.
+type MetricValuePairs struct {
+	// Metric / value pairs.
+	Metrics map[string]float32 `protobuf:"bytes,1,rep,name=metrics" json:"metrics,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"fixed32,2,opt,name=value"`
+}
+
+func (m *MetricValuePairs) Reset()                    { *m = MetricValuePairs{} }
+func (m *MetricValuePairs) String() string            { return proto.CompactTextString(m) }
+func (*MetricValuePairs) ProtoMessage()               {}
+func (*MetricValuePairs) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} }
+
+func (m *MetricValuePairs) GetMetrics() map[string]float32 {
+	if m != nil {
+		return m.Metrics
+	}
+	return nil
+}
+
+type KpiEvent struct {
+	Type     KpiEventType_KpiEventType    `protobuf:"varint,1,opt,name=type,enum=voltha.KpiEventType_KpiEventType" json:"type,omitempty"`
+	Ts       float32                      `protobuf:"fixed32,2,opt,name=ts" json:"ts,omitempty"`
+	Prefixes map[string]*MetricValuePairs `protobuf:"bytes,3,rep,name=prefixes" json:"prefixes,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
+}
+
+func (m *KpiEvent) Reset()                    { *m = KpiEvent{} }
+func (m *KpiEvent) String() string            { return proto.CompactTextString(m) }
+func (*KpiEvent) ProtoMessage()               {}
+func (*KpiEvent) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} }
+
+func (m *KpiEvent) GetType() KpiEventType_KpiEventType {
+	if m != nil {
+		return m.Type
+	}
+	return KpiEventType_slice
+}
+
+func (m *KpiEvent) GetTs() float32 {
+	if m != nil {
+		return m.Ts
+	}
+	return 0
+}
+
+func (m *KpiEvent) GetPrefixes() map[string]*MetricValuePairs {
+	if m != nil {
+		return m.Prefixes
+	}
+	return nil
+}
+
+//
+// Identify to the area of the system impacted by the alarm
+type AlarmEventType struct {
+}
+
+func (m *AlarmEventType) Reset()                    { *m = AlarmEventType{} }
+func (m *AlarmEventType) String() string            { return proto.CompactTextString(m) }
+func (*AlarmEventType) ProtoMessage()               {}
+func (*AlarmEventType) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5} }
+
+//
+// Identify to the functional category originating the alarm
+type AlarmEventCategory struct {
+}
+
+func (m *AlarmEventCategory) Reset()                    { *m = AlarmEventCategory{} }
+func (m *AlarmEventCategory) String() string            { return proto.CompactTextString(m) }
+func (*AlarmEventCategory) ProtoMessage()               {}
+func (*AlarmEventCategory) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{6} }
+
+//
+// Active state of the alarm
+type AlarmEventState struct {
+}
+
+func (m *AlarmEventState) Reset()                    { *m = AlarmEventState{} }
+func (m *AlarmEventState) String() string            { return proto.CompactTextString(m) }
+func (*AlarmEventState) ProtoMessage()               {}
+func (*AlarmEventState) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7} }
+
+//
+// Identify the overall impact of the alarm on the system
+type AlarmEventSeverity struct {
+}
+
+func (m *AlarmEventSeverity) Reset()                    { *m = AlarmEventSeverity{} }
+func (m *AlarmEventSeverity) String() string            { return proto.CompactTextString(m) }
+func (*AlarmEventSeverity) ProtoMessage()               {}
+func (*AlarmEventSeverity) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{8} }
+
+//
+//
+type AlarmEvent struct {
+	// Unique ID for this alarm.  e.g. voltha.some_olt.1234
+	Id string `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
+	// Refers to the area of the system impacted by the alarm
+	Type AlarmEventType_AlarmEventType `protobuf:"varint,2,opt,name=type,enum=voltha.AlarmEventType_AlarmEventType" json:"type,omitempty"`
+	// Refers to functional category of the alarm
+	Category AlarmEventCategory_AlarmEventCategory `protobuf:"varint,3,opt,name=category,enum=voltha.AlarmEventCategory_AlarmEventCategory" json:"category,omitempty"`
+	// Current active state of the alarm
+	State AlarmEventState_AlarmEventState `protobuf:"varint,4,opt,name=state,enum=voltha.AlarmEventState_AlarmEventState" json:"state,omitempty"`
+	// Overall impact of the alarm on the system
+	Severity AlarmEventSeverity_AlarmEventSeverity `protobuf:"varint,5,opt,name=severity,enum=voltha.AlarmEventSeverity_AlarmEventSeverity" json:"severity,omitempty"`
+	// Timestamp at which the alarm was first raised
+	RaisedTs float32 `protobuf:"fixed32,6,opt,name=raised_ts,json=raisedTs" json:"raised_ts,omitempty"`
+	// Timestamp at which the alarm was reported
+	ReportedTs float32 `protobuf:"fixed32,7,opt,name=reported_ts,json=reportedTs" json:"reported_ts,omitempty"`
+	// Timestamp at which the alarm has changed since it was raised
+	ChangedTs float32 `protobuf:"fixed32,8,opt,name=changed_ts,json=changedTs" json:"changed_ts,omitempty"`
+	// Identifier of the originating resource of the alarm
+	ResourceId string `protobuf:"bytes,9,opt,name=resource_id,json=resourceId" json:"resource_id,omitempty"`
+	// Textual explanation of the alarm
+	Description string `protobuf:"bytes,10,opt,name=description" json:"description,omitempty"`
+	// Key/Value storage for extra information that may give context to the alarm
+	Context map[string]string `protobuf:"bytes,11,rep,name=context" json:"context,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
+}
+
+func (m *AlarmEvent) Reset()                    { *m = AlarmEvent{} }
+func (m *AlarmEvent) String() string            { return proto.CompactTextString(m) }
+func (*AlarmEvent) ProtoMessage()               {}
+func (*AlarmEvent) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{9} }
+
+func (m *AlarmEvent) GetId() string {
+	if m != nil {
+		return m.Id
+	}
+	return ""
+}
+
+func (m *AlarmEvent) GetType() AlarmEventType_AlarmEventType {
+	if m != nil {
+		return m.Type
+	}
+	return AlarmEventType_COMMUNICATION
+}
+
+func (m *AlarmEvent) GetCategory() AlarmEventCategory_AlarmEventCategory {
+	if m != nil {
+		return m.Category
+	}
+	return AlarmEventCategory_PON
+}
+
+func (m *AlarmEvent) GetState() AlarmEventState_AlarmEventState {
+	if m != nil {
+		return m.State
+	}
+	return AlarmEventState_RAISED
+}
+
+func (m *AlarmEvent) GetSeverity() AlarmEventSeverity_AlarmEventSeverity {
+	if m != nil {
+		return m.Severity
+	}
+	return AlarmEventSeverity_INDETERMINATE
+}
+
+func (m *AlarmEvent) GetRaisedTs() float32 {
+	if m != nil {
+		return m.RaisedTs
+	}
+	return 0
+}
+
+func (m *AlarmEvent) GetReportedTs() float32 {
+	if m != nil {
+		return m.ReportedTs
+	}
+	return 0
+}
+
+func (m *AlarmEvent) GetChangedTs() float32 {
+	if m != nil {
+		return m.ChangedTs
+	}
+	return 0
+}
+
+func (m *AlarmEvent) GetResourceId() string {
+	if m != nil {
+		return m.ResourceId
+	}
+	return ""
+}
+
+func (m *AlarmEvent) GetDescription() string {
+	if m != nil {
+		return m.Description
+	}
+	return ""
+}
+
+func (m *AlarmEvent) GetContext() map[string]string {
+	if m != nil {
+		return m.Context
+	}
+	return nil
+}
+
+func init() {
+	proto.RegisterType((*ConfigEventType)(nil), "voltha.ConfigEventType")
+	proto.RegisterType((*ConfigEvent)(nil), "voltha.ConfigEvent")
+	proto.RegisterType((*KpiEventType)(nil), "voltha.KpiEventType")
+	proto.RegisterType((*MetricValuePairs)(nil), "voltha.MetricValuePairs")
+	proto.RegisterType((*KpiEvent)(nil), "voltha.KpiEvent")
+	proto.RegisterType((*AlarmEventType)(nil), "voltha.AlarmEventType")
+	proto.RegisterType((*AlarmEventCategory)(nil), "voltha.AlarmEventCategory")
+	proto.RegisterType((*AlarmEventState)(nil), "voltha.AlarmEventState")
+	proto.RegisterType((*AlarmEventSeverity)(nil), "voltha.AlarmEventSeverity")
+	proto.RegisterType((*AlarmEvent)(nil), "voltha.AlarmEvent")
+	proto.RegisterEnum("voltha.ConfigEventType_ConfigEventType", ConfigEventType_ConfigEventType_name, ConfigEventType_ConfigEventType_value)
+	proto.RegisterEnum("voltha.KpiEventType_KpiEventType", KpiEventType_KpiEventType_name, KpiEventType_KpiEventType_value)
+	proto.RegisterEnum("voltha.AlarmEventType_AlarmEventType", AlarmEventType_AlarmEventType_name, AlarmEventType_AlarmEventType_value)
+	proto.RegisterEnum("voltha.AlarmEventCategory_AlarmEventCategory", AlarmEventCategory_AlarmEventCategory_name, AlarmEventCategory_AlarmEventCategory_value)
+	proto.RegisterEnum("voltha.AlarmEventState_AlarmEventState", AlarmEventState_AlarmEventState_name, AlarmEventState_AlarmEventState_value)
+	proto.RegisterEnum("voltha.AlarmEventSeverity_AlarmEventSeverity", AlarmEventSeverity_AlarmEventSeverity_name, AlarmEventSeverity_AlarmEventSeverity_value)
+}
+
+func init() { proto.RegisterFile("events.proto", fileDescriptor0) }
+
+var fileDescriptor0 = []byte{
+	// 775 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x55, 0xef, 0x6e, 0xe3, 0x44,
+	0x10, 0xaf, 0x9d, 0xbf, 0x1e, 0xb7, 0xe9, 0xb2, 0xe2, 0x83, 0x55, 0x38, 0xae, 0x67, 0x09, 0x51,
+	0x21, 0x91, 0x13, 0x39, 0x21, 0x71, 0x45, 0x27, 0x64, 0xb9, 0x2b, 0x64, 0xb8, 0x38, 0x61, 0xe3,
+	0x16, 0xf8, 0x74, 0x5a, 0xe2, 0xbd, 0xd4, 0x22, 0xb5, 0x2d, 0xef, 0x36, 0xba, 0x7c, 0xe3, 0x0d,
+	0x78, 0x28, 0x5e, 0x85, 0x07, 0x41, 0xbb, 0xb6, 0x1b, 0xc7, 0x4d, 0x75, 0xdf, 0x66, 0x7e, 0xf3,
+	0xc7, 0xf3, 0x9b, 0x9d, 0x19, 0xc3, 0x31, 0xdf, 0xf0, 0x54, 0x8a, 0x71, 0x5e, 0x64, 0x32, 0xc3,
+	0xfd, 0x4d, 0xb6, 0x96, 0xb7, 0xec, 0x0c, 0xee, 0xb8, 0x64, 0x25, 0x76, 0xf6, 0xf9, 0x2a, 0xcb,
+	0x56, 0x6b, 0xfe, 0x92, 0xe5, 0xc9, 0x4b, 0x96, 0xa6, 0x99, 0x64, 0x32, 0xc9, 0xd2, 0x2a, 0xc2,
+	0x25, 0x70, 0xea, 0x67, 0xe9, 0xfb, 0x64, 0x45, 0x54, 0x9e, 0x68, 0x9b, 0x73, 0x77, 0xf2, 0x08,
+	0xc2, 0x03, 0xe8, 0xb0, 0x38, 0x46, 0x47, 0x18, 0xa0, 0x5f, 0xf0, 0xbb, 0x6c, 0xc3, 0x91, 0xa1,
+	0xe4, 0xfb, 0x3c, 0x66, 0x92, 0x23, 0xd3, 0x2d, 0xc0, 0x6e, 0xc4, 0xe0, 0x1f, 0xa0, 0x2b, 0xb7,
+	0x39, 0x77, 0x8c, 0x73, 0xe3, 0x62, 0x34, 0xf9, 0x6a, 0x5c, 0x96, 0x35, 0x6e, 0xa5, 0x6d, 0xeb,
+	0x54, 0x07, 0x61, 0x0c, 0xdd, 0x5b, 0x26, 0x6e, 0x1d, 0xf3, 0xdc, 0xb8, 0xb0, 0xa8, 0x96, 0x15,
+	0x16, 0x33, 0xc9, 0x9c, 0x4e, 0x89, 0x29, 0xd9, 0xfd, 0x16, 0x8e, 0x7f, 0xc9, 0x93, 0x5d, 0xdd,
+	0x2f, 0xf6, 0x75, 0x6c, 0x41, 0x4f, 0xac, 0x93, 0x25, 0x47, 0x47, 0xb8, 0x0f, 0xa6, 0x14, 0xc8,
+	0x70, 0xff, 0x31, 0x00, 0x4d, 0xb9, 0x2c, 0x92, 0xe5, 0x0d, 0x5b, 0xdf, 0xf3, 0x39, 0x4b, 0x0a,
+	0x81, 0x7f, 0x84, 0xc1, 0x9d, 0xc6, 0x84, 0x63, 0x9c, 0x77, 0x2e, 0xec, 0xc9, 0x97, 0x75, 0xbd,
+	0x6d, 0xd7, 0x0a, 0x10, 0x24, 0x95, 0xc5, 0x96, 0xd6, 0x51, 0x67, 0x97, 0x70, 0xdc, 0x34, 0x60,
+	0x04, 0x9d, 0xbf, 0xf8, 0x56, 0x93, 0xb7, 0xa8, 0x12, 0xf1, 0xa7, 0xd0, 0xdb, 0xa8, 0x2c, 0x9a,
+	0x93, 0x49, 0x4b, 0xe5, 0xd2, 0xfc, 0xde, 0x70, 0xff, 0x33, 0x60, 0x58, 0x57, 0x8d, 0xbf, 0xdb,
+	0x6b, 0xdb, 0x8b, 0xba, 0x8c, 0x26, 0xab, 0x3d, 0xa5, 0x6a, 0xd8, 0x48, 0xb1, 0xab, 0x52, 0x9b,
+	0x52, 0xe0, 0x4b, 0x18, 0xe6, 0x05, 0x7f, 0x9f, 0x7c, 0xe0, 0xc2, 0xe9, 0x68, 0x46, 0x5f, 0xb4,
+	0x53, 0x8d, 0xe7, 0x95, 0x43, 0x49, 0xe5, 0xc1, 0xff, 0xec, 0x1a, 0x4e, 0xf6, 0x4c, 0x07, 0xc8,
+	0x8c, 0x9b, 0x64, 0xec, 0x89, 0xf3, 0x54, 0xb7, 0x9a, 0x34, 0xff, 0x36, 0x60, 0xe4, 0xad, 0x59,
+	0x71, 0xb7, 0x7b, 0xae, 0xb4, 0x8d, 0xe0, 0x4f, 0xe0, 0xc4, 0x9f, 0x4d, 0xa7, 0xd7, 0x61, 0xe0,
+	0x7b, 0x51, 0x30, 0x0b, 0xd1, 0x11, 0x3e, 0x05, 0x9b, 0x84, 0x37, 0x01, 0x9d, 0x85, 0x53, 0x12,
+	0x46, 0xc8, 0xc0, 0x27, 0x60, 0x91, 0x5f, 0xaf, 0x83, 0xb9, 0x56, 0x4d, 0x6c, 0xc3, 0x60, 0x41,
+	0xe8, 0x4d, 0xe0, 0x13, 0xd4, 0xc1, 0x23, 0x80, 0x39, 0x9d, 0xf9, 0x64, 0xb1, 0x08, 0xc2, 0x9f,
+	0x50, 0x17, 0x1f, 0xc3, 0x70, 0x41, 0xfc, 0x6b, 0x1a, 0x44, 0x7f, 0xa0, 0x9e, 0xfb, 0x0a, 0xf0,
+	0xee, 0x7b, 0x3e, 0x93, 0x7c, 0x95, 0x15, 0x5b, 0xf7, 0xd9, 0x21, 0x54, 0xcd, 0xfb, 0x5c, 0x7d,
+	0xdf, 0x7d, 0x03, 0xa7, 0x3b, 0xf3, 0x42, 0x32, 0xc9, 0xdd, 0xaf, 0x1f, 0x41, 0x6a, 0x13, 0xa8,
+	0x17, 0x2c, 0xc8, 0x15, 0x3a, 0x52, 0x15, 0xf9, 0x6f, 0x89, 0x47, 0xc9, 0x15, 0x32, 0xdc, 0xb4,
+	0x99, 0x7d, 0xc1, 0x37, 0xbc, 0x48, 0xe4, 0xd6, 0xfd, 0xfd, 0x10, 0xaa, 0xd8, 0x07, 0xe1, 0x15,
+	0x89, 0x08, 0x9d, 0x06, 0xa1, 0x17, 0x91, 0x32, 0xd7, 0x6f, 0x1e, 0x0d, 0x15, 0x1b, 0x43, 0x8d,
+	0xf3, 0x34, 0x08, 0x67, 0x14, 0x99, 0x5a, 0xf4, 0x7e, 0x9e, 0x51, 0xd4, 0x51, 0x1c, 0x7d, 0x1a,
+	0x44, 0x81, 0xef, 0xbd, 0x45, 0x5d, 0xf7, 0xdf, 0x2e, 0xc0, 0x2e, 0xb5, 0x1a, 0x8c, 0x24, 0xae,
+	0x9e, 0xce, 0x4c, 0x62, 0xfc, 0xba, 0x9a, 0x2f, 0x53, 0xcf, 0xd7, 0xc3, 0x98, 0xef, 0x3f, 0x43,
+	0x4b, 0xad, 0x66, 0x2c, 0x80, 0xe1, 0xb2, 0xea, 0x8e, 0x5e, 0xc2, 0xd1, 0xe4, 0x9b, 0xc7, 0xe1,
+	0x75, 0xff, 0x0e, 0x40, 0xf4, 0x21, 0x1c, 0xbf, 0x81, 0x9e, 0x50, 0x6d, 0x73, 0xba, 0xfb, 0xd7,
+	0xa1, 0xd5, 0xd5, 0xb6, 0x4e, 0xcb, 0x28, 0x55, 0x89, 0xa8, 0x7a, 0xe6, 0xf4, 0x9e, 0xaa, 0xa4,
+	0xee, 0xea, 0x01, 0x88, 0x3e, 0x84, 0xe3, 0xcf, 0xc0, 0x2a, 0x58, 0x22, 0x78, 0xfc, 0x4e, 0x0a,
+	0xa7, 0xaf, 0xf7, 0x67, 0x58, 0x02, 0x91, 0xc0, 0xcf, 0xc1, 0x2e, 0x78, 0x9e, 0x15, 0xb2, 0x34,
+	0x0f, 0xb4, 0x19, 0x6a, 0x28, 0x12, 0xf8, 0x19, 0xc0, 0xf2, 0x96, 0xa5, 0xab, 0xd2, 0x3e, 0xd4,
+	0x76, 0xab, 0x42, 0xea, 0x78, 0x91, 0xdd, 0x17, 0x4b, 0xfe, 0x2e, 0x89, 0x1d, 0x4b, 0xbf, 0x02,
+	0xd4, 0x50, 0x10, 0xe3, 0x73, 0xb0, 0x63, 0x2e, 0x96, 0x45, 0x92, 0xab, 0x83, 0xec, 0x80, 0x76,
+	0x68, 0x42, 0xf8, 0x35, 0x0c, 0x96, 0x59, 0x2a, 0xf9, 0x07, 0xe9, 0xd8, 0x7a, 0x8f, 0x9f, 0x3f,
+	0x66, 0xaa, 0x8e, 0xa8, 0xf2, 0xa8, 0x6e, 0x52, 0xe5, 0xaf, 0x6e, 0x52, 0xd3, 0xf0, 0xb1, 0x9b,
+	0x64, 0x35, 0x96, 0xf5, 0xcf, 0xbe, 0xfe, 0x35, 0xbc, 0xfa, 0x3f, 0x00, 0x00, 0xff, 0xff, 0x27,
+	0x78, 0x37, 0x67, 0x5c, 0x06, 0x00, 0x00,
+}
diff --git a/netopeer/voltha-grpc-client/voltha/health/health.pb.go b/netopeer/voltha-grpc-client/voltha/health/health.pb.go
new file mode 100644
index 0000000..cf98267
--- /dev/null
+++ b/netopeer/voltha-grpc-client/voltha/health/health.pb.go
@@ -0,0 +1,179 @@
+// Code generated by protoc-gen-go.
+// source: health.proto
+// DO NOT EDIT!
+
+/*
+Package voltha is a generated protocol buffer package.
+
+It is generated from these files:
+	health.proto
+
+It has these top-level messages:
+	HealthStatus
+*/
+package health
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+import google_protobuf1 "github.com/golang/protobuf/ptypes/empty"
+
+import (
+	context "golang.org/x/net/context"
+	grpc "google.golang.org/grpc"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+// Health states
+type HealthStatus_HealthState int32
+
+const (
+	HealthStatus_HEALTHY    HealthStatus_HealthState = 0
+	HealthStatus_OVERLOADED HealthStatus_HealthState = 1
+	HealthStatus_DYING      HealthStatus_HealthState = 2
+)
+
+var HealthStatus_HealthState_name = map[int32]string{
+	0: "HEALTHY",
+	1: "OVERLOADED",
+	2: "DYING",
+}
+var HealthStatus_HealthState_value = map[string]int32{
+	"HEALTHY":    0,
+	"OVERLOADED": 1,
+	"DYING":      2,
+}
+
+func (x HealthStatus_HealthState) String() string {
+	return proto.EnumName(HealthStatus_HealthState_name, int32(x))
+}
+func (HealthStatus_HealthState) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{0, 0} }
+
+// Encode health status of a Voltha instance
+type HealthStatus struct {
+	// Current state of health of this Voltha instance
+	State HealthStatus_HealthState `protobuf:"varint,1,opt,name=state,enum=voltha.HealthStatus_HealthState" json:"state,omitempty"`
+}
+
+func (m *HealthStatus) Reset()                    { *m = HealthStatus{} }
+func (m *HealthStatus) String() string            { return proto.CompactTextString(m) }
+func (*HealthStatus) ProtoMessage()               {}
+func (*HealthStatus) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
+
+func (m *HealthStatus) GetState() HealthStatus_HealthState {
+	if m != nil {
+		return m.State
+	}
+	return HealthStatus_HEALTHY
+}
+
+func init() {
+	proto.RegisterType((*HealthStatus)(nil), "voltha.HealthStatus")
+	proto.RegisterEnum("voltha.HealthStatus_HealthState", HealthStatus_HealthState_name, HealthStatus_HealthState_value)
+}
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ context.Context
+var _ grpc.ClientConn
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+const _ = grpc.SupportPackageIsVersion4
+
+// Client API for HealthService service
+
+type HealthServiceClient interface {
+	// Return current health status of a Voltha instance
+	GetHealthStatus(ctx context.Context, in *google_protobuf1.Empty, opts ...grpc.CallOption) (*HealthStatus, error)
+}
+
+type healthServiceClient struct {
+	cc *grpc.ClientConn
+}
+
+func NewHealthServiceClient(cc *grpc.ClientConn) HealthServiceClient {
+	return &healthServiceClient{cc}
+}
+
+func (c *healthServiceClient) GetHealthStatus(ctx context.Context, in *google_protobuf1.Empty, opts ...grpc.CallOption) (*HealthStatus, error) {
+	out := new(HealthStatus)
+	err := grpc.Invoke(ctx, "/voltha.HealthService/GetHealthStatus", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// Server API for HealthService service
+
+type HealthServiceServer interface {
+	// Return current health status of a Voltha instance
+	GetHealthStatus(context.Context, *google_protobuf1.Empty) (*HealthStatus, error)
+}
+
+func RegisterHealthServiceServer(s *grpc.Server, srv HealthServiceServer) {
+	s.RegisterService(&_HealthService_serviceDesc, srv)
+}
+
+func _HealthService_GetHealthStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(google_protobuf1.Empty)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(HealthServiceServer).GetHealthStatus(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/voltha.HealthService/GetHealthStatus",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(HealthServiceServer).GetHealthStatus(ctx, req.(*google_protobuf1.Empty))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+var _HealthService_serviceDesc = grpc.ServiceDesc{
+	ServiceName: "voltha.HealthService",
+	HandlerType: (*HealthServiceServer)(nil),
+	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "GetHealthStatus",
+			Handler:    _HealthService_GetHealthStatus_Handler,
+		},
+	},
+	Streams:  []grpc.StreamDesc{},
+	Metadata: "health.proto",
+}
+
+func init() { proto.RegisterFile("health.proto", fileDescriptor0) }
+
+var fileDescriptor0 = []byte{
+	// 248 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xe2, 0xc9, 0x48, 0x4d, 0xcc,
+	0x29, 0xc9, 0xd0, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x62, 0x2b, 0xcb, 0xcf, 0x29, 0xc9, 0x48,
+	0x94, 0x92, 0x49, 0xcf, 0xcf, 0x4f, 0xcf, 0x49, 0xd5, 0x4f, 0x2c, 0xc8, 0xd4, 0x4f, 0xcc, 0xcb,
+	0xcb, 0x2f, 0x49, 0x2c, 0xc9, 0xcc, 0xcf, 0x2b, 0x86, 0xa8, 0x92, 0x92, 0x86, 0xca, 0x82, 0x79,
+	0x49, 0xa5, 0x69, 0xfa, 0xa9, 0xb9, 0x05, 0x25, 0x95, 0x50, 0x49, 0xae, 0xdc, 0xd4, 0x92, 0x44,
+	0x08, 0x5b, 0xa9, 0x85, 0x91, 0x8b, 0xc7, 0x03, 0x6c, 0x7e, 0x70, 0x49, 0x62, 0x49, 0x69, 0xb1,
+	0x90, 0x2d, 0x17, 0x6b, 0x71, 0x49, 0x62, 0x49, 0xaa, 0x04, 0xa3, 0x02, 0xa3, 0x06, 0x9f, 0x91,
+	0x82, 0x1e, 0xc4, 0x3e, 0x3d, 0x64, 0x45, 0x48, 0x9c, 0x54, 0x27, 0xd6, 0x17, 0xdf, 0xce, 0xca,
+	0x32, 0x06, 0x41, 0x74, 0x29, 0x99, 0x72, 0x71, 0x23, 0x49, 0x0a, 0x71, 0x73, 0xb1, 0x7b, 0xb8,
+	0x3a, 0xfa, 0x84, 0x78, 0x44, 0x0a, 0x30, 0x08, 0xf1, 0x71, 0x71, 0xf9, 0x87, 0xb9, 0x06, 0xf9,
+	0xf8, 0x3b, 0xba, 0xb8, 0xba, 0x08, 0x30, 0x0a, 0x71, 0x72, 0xb1, 0xba, 0x44, 0x7a, 0xfa, 0xb9,
+	0x0b, 0x30, 0x19, 0x25, 0x72, 0xf1, 0x42, 0xb5, 0xa5, 0x16, 0x95, 0x65, 0x26, 0xa7, 0x0a, 0x05,
+	0x70, 0xf1, 0xbb, 0xa7, 0x96, 0xa0, 0xb8, 0x4c, 0x4c, 0x0f, 0xe2, 0x29, 0x3d, 0x98, 0xa7, 0xf4,
+	0x5c, 0x41, 0x9e, 0x92, 0x12, 0xc1, 0xe6, 0x44, 0x25, 0xfe, 0xa6, 0xcb, 0x4f, 0x26, 0x33, 0x71,
+	0x0a, 0xb1, 0xeb, 0x43, 0x82, 0x2f, 0x89, 0x0d, 0xac, 0xcd, 0x18, 0x10, 0x00, 0x00, 0xff, 0xff,
+	0x59, 0x30, 0x7e, 0x18, 0x4f, 0x01, 0x00, 0x00,
+}
diff --git a/netopeer/voltha-grpc-client/voltha/logical_device/logical_device.pb.go b/netopeer/voltha-grpc-client/voltha/logical_device/logical_device.pb.go
new file mode 100644
index 0000000..04bde69
--- /dev/null
+++ b/netopeer/voltha-grpc-client/voltha/logical_device/logical_device.pb.go
@@ -0,0 +1,234 @@
+// Code generated by protoc-gen-go.
+// source: logical_device.proto
+// DO NOT EDIT!
+
+/*
+Package voltha is a generated protocol buffer package.
+
+It is generated from these files:
+	logical_device.proto
+
+It has these top-level messages:
+	LogicalPort
+	LogicalPorts
+	LogicalDevice
+	LogicalDevices
+*/
+package logical_device
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+import openflow_13 "github.com/opencord/voltha/netconf/translator/voltha/openflow_13"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+type LogicalPort struct {
+	Id           string               `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
+	OfpPort      *openflow_13.OfpPort `protobuf:"bytes,2,opt,name=ofp_port,json=ofpPort" json:"ofp_port,omitempty"`
+	DeviceId     string               `protobuf:"bytes,3,opt,name=device_id,json=deviceId" json:"device_id,omitempty"`
+	DevicePortNo uint32               `protobuf:"varint,4,opt,name=device_port_no,json=devicePortNo" json:"device_port_no,omitempty"`
+	RootPort     bool                 `protobuf:"varint,5,opt,name=root_port,json=rootPort" json:"root_port,omitempty"`
+}
+
+func (m *LogicalPort) Reset()                    { *m = LogicalPort{} }
+func (m *LogicalPort) String() string            { return proto.CompactTextString(m) }
+func (*LogicalPort) ProtoMessage()               {}
+func (*LogicalPort) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
+
+func (m *LogicalPort) GetId() string {
+	if m != nil {
+		return m.Id
+	}
+	return ""
+}
+
+func (m *LogicalPort) GetOfpPort() *openflow_13.OfpPort {
+	if m != nil {
+		return m.OfpPort
+	}
+	return nil
+}
+
+func (m *LogicalPort) GetDeviceId() string {
+	if m != nil {
+		return m.DeviceId
+	}
+	return ""
+}
+
+func (m *LogicalPort) GetDevicePortNo() uint32 {
+	if m != nil {
+		return m.DevicePortNo
+	}
+	return 0
+}
+
+func (m *LogicalPort) GetRootPort() bool {
+	if m != nil {
+		return m.RootPort
+	}
+	return false
+}
+
+type LogicalPorts struct {
+	Items []*LogicalPort `protobuf:"bytes,1,rep,name=items" json:"items,omitempty"`
+}
+
+func (m *LogicalPorts) Reset()                    { *m = LogicalPorts{} }
+func (m *LogicalPorts) String() string            { return proto.CompactTextString(m) }
+func (*LogicalPorts) ProtoMessage()               {}
+func (*LogicalPorts) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
+
+func (m *LogicalPorts) GetItems() []*LogicalPort {
+	if m != nil {
+		return m.Items
+	}
+	return nil
+}
+
+type LogicalDevice struct {
+	// unique id of logical device
+	Id string `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
+	// unique datapath id for the logical device (used by the SDN controller)
+	DatapathId uint64 `protobuf:"varint,2,opt,name=datapath_id,json=datapathId" json:"datapath_id,omitempty"`
+	// device description
+	Desc *openflow_13.OfpDesc `protobuf:"bytes,3,opt,name=desc" json:"desc,omitempty"`
+	// device features
+	SwitchFeatures *openflow_13.OfpSwitchFeatures `protobuf:"bytes,4,opt,name=switch_features,json=switchFeatures" json:"switch_features,omitempty"`
+	// name of the root device anchoring logical device
+	RootDeviceId string `protobuf:"bytes,5,opt,name=root_device_id,json=rootDeviceId" json:"root_device_id,omitempty"`
+	// logical device ports
+	Ports []*LogicalPort `protobuf:"bytes,128,rep,name=ports" json:"ports,omitempty"`
+	// flows configured on the logical device
+	Flows *openflow_13.Flows `protobuf:"bytes,129,opt,name=flows" json:"flows,omitempty"`
+	// flow groups configured on the logical device
+	FlowGroups *openflow_13.FlowGroups `protobuf:"bytes,130,opt,name=flow_groups,json=flowGroups" json:"flow_groups,omitempty"`
+}
+
+func (m *LogicalDevice) Reset()                    { *m = LogicalDevice{} }
+func (m *LogicalDevice) String() string            { return proto.CompactTextString(m) }
+func (*LogicalDevice) ProtoMessage()               {}
+func (*LogicalDevice) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }
+
+func (m *LogicalDevice) GetId() string {
+	if m != nil {
+		return m.Id
+	}
+	return ""
+}
+
+func (m *LogicalDevice) GetDatapathId() uint64 {
+	if m != nil {
+		return m.DatapathId
+	}
+	return 0
+}
+
+func (m *LogicalDevice) GetDesc() *openflow_13.OfpDesc {
+	if m != nil {
+		return m.Desc
+	}
+	return nil
+}
+
+func (m *LogicalDevice) GetSwitchFeatures() *openflow_13.OfpSwitchFeatures {
+	if m != nil {
+		return m.SwitchFeatures
+	}
+	return nil
+}
+
+func (m *LogicalDevice) GetRootDeviceId() string {
+	if m != nil {
+		return m.RootDeviceId
+	}
+	return ""
+}
+
+func (m *LogicalDevice) GetPorts() []*LogicalPort {
+	if m != nil {
+		return m.Ports
+	}
+	return nil
+}
+
+func (m *LogicalDevice) GetFlows() *openflow_13.Flows {
+	if m != nil {
+		return m.Flows
+	}
+	return nil
+}
+
+func (m *LogicalDevice) GetFlowGroups() *openflow_13.FlowGroups {
+	if m != nil {
+		return m.FlowGroups
+	}
+	return nil
+}
+
+type LogicalDevices struct {
+	Items []*LogicalDevice `protobuf:"bytes,1,rep,name=items" json:"items,omitempty"`
+}
+
+func (m *LogicalDevices) Reset()                    { *m = LogicalDevices{} }
+func (m *LogicalDevices) String() string            { return proto.CompactTextString(m) }
+func (*LogicalDevices) ProtoMessage()               {}
+func (*LogicalDevices) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} }
+
+func (m *LogicalDevices) GetItems() []*LogicalDevice {
+	if m != nil {
+		return m.Items
+	}
+	return nil
+}
+
+func init() {
+	proto.RegisterType((*LogicalPort)(nil), "voltha.LogicalPort")
+	proto.RegisterType((*LogicalPorts)(nil), "voltha.LogicalPorts")
+	proto.RegisterType((*LogicalDevice)(nil), "voltha.LogicalDevice")
+	proto.RegisterType((*LogicalDevices)(nil), "voltha.LogicalDevices")
+}
+
+func init() { proto.RegisterFile("logical_device.proto", fileDescriptor0) }
+
+var fileDescriptor0 = []byte{
+	// 438 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x52, 0xd1, 0x6e, 0xd3, 0x30,
+	0x14, 0xc5, 0x6d, 0x33, 0xda, 0x9b, 0xae, 0x08, 0xc3, 0x84, 0x35, 0x40, 0x44, 0x15, 0x0f, 0x99,
+	0x90, 0xba, 0xd1, 0x89, 0x07, 0x1e, 0x90, 0xd0, 0x34, 0x0d, 0x55, 0x42, 0x08, 0xf9, 0x07, 0x22,
+	0x53, 0x3b, 0xad, 0xa5, 0x2c, 0xd7, 0x8a, 0xbd, 0xed, 0x15, 0x78, 0xe1, 0x73, 0xf8, 0x12, 0x7e,
+	0x82, 0x8f, 0xe0, 0x19, 0xd9, 0x4e, 0xa0, 0x5d, 0xe1, 0x31, 0xe7, 0x9c, 0x7b, 0x7c, 0xee, 0xb9,
+	0x81, 0x87, 0x15, 0xae, 0xf4, 0x52, 0x54, 0x85, 0x54, 0xd7, 0x7a, 0xa9, 0x66, 0xa6, 0x41, 0x87,
+	0x74, 0xef, 0x1a, 0x2b, 0xb7, 0x16, 0x87, 0x70, 0xa9, 0x9c, 0x88, 0xd8, 0xe1, 0x93, 0x15, 0xe2,
+	0xaa, 0x52, 0xc7, 0xc2, 0xe8, 0x63, 0x51, 0xd7, 0xe8, 0x84, 0xd3, 0x58, 0xdb, 0x96, 0xbd, 0x8f,
+	0x46, 0xd5, 0x65, 0x85, 0x37, 0xc5, 0xcb, 0xd3, 0x08, 0x4d, 0xbf, 0x13, 0x48, 0xdf, 0x47, 0xf7,
+	0x8f, 0xd8, 0x38, 0x3a, 0x81, 0x9e, 0x96, 0x8c, 0x64, 0x24, 0x1f, 0xf1, 0x9e, 0x96, 0xf4, 0x04,
+	0x86, 0x58, 0x9a, 0xc2, 0x60, 0xe3, 0x58, 0x2f, 0x23, 0x79, 0x3a, 0x3f, 0x98, 0x6d, 0xba, 0x74,
+	0x24, 0xbf, 0x8b, 0xa5, 0x09, 0x0e, 0x8f, 0x61, 0x14, 0x63, 0x16, 0x5a, 0xb2, 0x7e, 0x30, 0x1a,
+	0x46, 0x60, 0x21, 0xe9, 0x73, 0x98, 0xb4, 0xa4, 0x1f, 0x2a, 0x6a, 0x64, 0x83, 0x8c, 0xe4, 0xfb,
+	0x7c, 0x1c, 0x51, 0x6f, 0xf0, 0x01, 0xbd, 0x45, 0x83, 0xe8, 0xe2, 0xab, 0x49, 0x46, 0xf2, 0x21,
+	0x1f, 0x7a, 0xc0, 0xd3, 0xd3, 0xd7, 0x30, 0xde, 0x08, 0x6c, 0xe9, 0x11, 0x24, 0xda, 0xa9, 0x4b,
+	0xcb, 0x48, 0xd6, 0xcf, 0xd3, 0xf9, 0x83, 0x59, 0xac, 0x65, 0xb6, 0x21, 0xe2, 0x51, 0x31, 0xfd,
+	0xd6, 0x87, 0xfd, 0x16, 0x3e, 0x0f, 0xef, 0xed, 0xac, 0xfb, 0x0c, 0x52, 0x29, 0x9c, 0x30, 0xc2,
+	0xad, 0x7d, 0x7c, 0xbf, 0xf1, 0x80, 0x43, 0x07, 0x2d, 0x24, 0x3d, 0x82, 0x81, 0x54, 0x76, 0x19,
+	0x16, 0xfb, 0x57, 0x17, 0x9e, 0xe4, 0x41, 0x42, 0x17, 0x70, 0xcf, 0xde, 0x68, 0xb7, 0x5c, 0x17,
+	0xa5, 0x12, 0xee, 0xaa, 0x51, 0x36, 0x2c, 0x9b, 0xce, 0xb3, 0x9d, 0xa9, 0x5b, 0x3a, 0x3e, 0x89,
+	0xc0, 0x45, 0xfb, 0xed, 0x6b, 0x0b, 0x85, 0xfc, 0x2d, 0x36, 0x09, 0x91, 0xc7, 0x1e, 0x3d, 0xef,
+	0xca, 0x7d, 0x05, 0x89, 0x6f, 0xcc, 0xb2, 0xcf, 0xff, 0xaf, 0xe2, 0x6c, 0xf4, 0xf3, 0xd7, 0x8f,
+	0xa7, 0x03, 0xbf, 0x36, 0x8f, 0x6a, 0x7a, 0x02, 0x89, 0xcf, 0x62, 0xd9, 0x17, 0x12, 0xe2, 0xd1,
+	0xad, 0x78, 0x17, 0x9e, 0x3a, 0x4b, 0xfc, 0xd4, 0x1d, 0x1e, 0x85, 0xf4, 0x2d, 0xa4, 0x81, 0x5e,
+	0x35, 0x78, 0x65, 0x2c, 0xfb, 0x1a, 0xe7, 0x1e, 0xed, 0xcc, 0xbd, 0x0b, 0x7c, 0x37, 0x0c, 0xe5,
+	0x1f, 0x68, 0xfa, 0x06, 0x26, 0x5b, 0x87, 0xb0, 0xf4, 0xc5, 0xf6, 0x19, 0x0f, 0x6e, 0x65, 0x8f,
+	0xb2, 0xf6, 0x90, 0x9f, 0xf6, 0xc2, 0xcf, 0x7b, 0xfa, 0x3b, 0x00, 0x00, 0xff, 0xff, 0x24, 0xce,
+	0xf3, 0x88, 0x19, 0x03, 0x00, 0x00,
+}
diff --git a/netopeer/voltha-grpc-client/voltha/meta/meta.pb.go b/netopeer/voltha-grpc-client/voltha/meta/meta.pb.go
new file mode 100644
index 0000000..f4ab63c
--- /dev/null
+++ b/netopeer/voltha-grpc-client/voltha/meta/meta.pb.go
@@ -0,0 +1,120 @@
+// Code generated by protoc-gen-go.
+// source: meta.proto
+// DO NOT EDIT!
+
+/*
+Package voltha is a generated protocol buffer package.
+
+It is generated from these files:
+	meta.proto
+
+It has these top-level messages:
+	ChildNode
+*/
+package meta
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+import google_protobuf "github.com/golang/protobuf/protoc-gen-go/descriptor"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+type Access int32
+
+const (
+	// read-write, stored attribute
+	Access_CONFIG Access = 0
+	// read-only field, stored with the model, covered by its hash
+	Access_READ_ONLY Access = 1
+	// A read-only attribute that is not stored in the model, not covered
+	// by its hash, its value is filled real-time upon each request.
+	Access_REAL_TIME Access = 2
+)
+
+var Access_name = map[int32]string{
+	0: "CONFIG",
+	1: "READ_ONLY",
+	2: "REAL_TIME",
+}
+var Access_value = map[string]int32{
+	"CONFIG":    0,
+	"READ_ONLY": 1,
+	"REAL_TIME": 2,
+}
+
+func (x Access) String() string {
+	return proto.EnumName(Access_name, int32(x))
+}
+func (Access) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
+
+type ChildNode struct {
+	Key string `protobuf:"bytes,1,opt,name=key" json:"key,omitempty"`
+}
+
+func (m *ChildNode) Reset()                    { *m = ChildNode{} }
+func (m *ChildNode) String() string            { return proto.CompactTextString(m) }
+func (*ChildNode) ProtoMessage()               {}
+func (*ChildNode) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
+
+func (m *ChildNode) GetKey() string {
+	if m != nil {
+		return m.Key
+	}
+	return ""
+}
+
+var E_ChildNode = &proto.ExtensionDesc{
+	ExtendedType:  (*google_protobuf.FieldOptions)(nil),
+	ExtensionType: (*ChildNode)(nil),
+	Field:         7761772,
+	Name:          "voltha.child_node",
+	Tag:           "bytes,7761772,opt,name=child_node,json=childNode",
+	Filename:      "meta.proto",
+}
+
+var E_Access = &proto.ExtensionDesc{
+	ExtendedType:  (*google_protobuf.FieldOptions)(nil),
+	ExtensionType: (*Access)(nil),
+	Field:         7761773,
+	Name:          "voltha.access",
+	Tag:           "varint,7761773,opt,name=access,enum=voltha.Access",
+	Filename:      "meta.proto",
+}
+
+func init() {
+	proto.RegisterType((*ChildNode)(nil), "voltha.ChildNode")
+	proto.RegisterEnum("voltha.Access", Access_name, Access_value)
+	proto.RegisterExtension(E_ChildNode)
+	proto.RegisterExtension(E_Access)
+}
+
+func init() { proto.RegisterFile("meta.proto", fileDescriptor0) }
+
+var fileDescriptor0 = []byte{
+	// 229 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xe2, 0xca, 0x4d, 0x2d, 0x49,
+	0xd4, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x62, 0x2b, 0xcb, 0xcf, 0x29, 0xc9, 0x48, 0x94, 0x52,
+	0x48, 0xcf, 0xcf, 0x4f, 0xcf, 0x49, 0xd5, 0x07, 0x8b, 0x26, 0x95, 0xa6, 0xe9, 0xa7, 0xa4, 0x16,
+	0x27, 0x17, 0x65, 0x16, 0x94, 0xe4, 0x17, 0x41, 0x54, 0x2a, 0xc9, 0x72, 0x71, 0x3a, 0x67, 0x64,
+	0xe6, 0xa4, 0xf8, 0xe5, 0xa7, 0xa4, 0x0a, 0x09, 0x70, 0x31, 0x67, 0xa7, 0x56, 0x4a, 0x30, 0x2a,
+	0x30, 0x6a, 0x70, 0x06, 0x81, 0x98, 0x5a, 0x46, 0x5c, 0x6c, 0x8e, 0xc9, 0xc9, 0xa9, 0xc5, 0xc5,
+	0x42, 0x5c, 0x5c, 0x6c, 0xce, 0xfe, 0x7e, 0x6e, 0x9e, 0xee, 0x02, 0x0c, 0x42, 0xbc, 0x5c, 0x9c,
+	0x41, 0xae, 0x8e, 0x2e, 0xf1, 0xfe, 0x7e, 0x3e, 0x91, 0x02, 0x8c, 0x50, 0xae, 0x4f, 0x7c, 0x88,
+	0xa7, 0xaf, 0xab, 0x00, 0x93, 0x55, 0x10, 0x17, 0x57, 0x32, 0xc8, 0xc8, 0xf8, 0x3c, 0x90, 0x99,
+	0xb2, 0x7a, 0x10, 0x37, 0xe8, 0xc1, 0xdc, 0xa0, 0xe7, 0x96, 0x99, 0x9a, 0x93, 0xe2, 0x5f, 0x50,
+	0x92, 0x99, 0x9f, 0x57, 0x2c, 0xf1, 0xe6, 0xde, 0x4d, 0x66, 0x05, 0x46, 0x0d, 0x6e, 0x23, 0x41,
+	0x3d, 0x88, 0x9b, 0xf5, 0xe0, 0xce, 0x09, 0xe2, 0x4c, 0x86, 0x31, 0xad, 0x3c, 0xb8, 0xd8, 0x12,
+	0x21, 0xee, 0x20, 0x60, 0xde, 0x5b, 0x88, 0x79, 0x7c, 0x46, 0x7c, 0x30, 0xf3, 0x20, 0xee, 0x0f,
+	0x82, 0xea, 0x4f, 0x62, 0x03, 0xeb, 0x33, 0x06, 0x04, 0x00, 0x00, 0xff, 0xff, 0x55, 0xcc, 0xf1,
+	0x90, 0x2f, 0x01, 0x00, 0x00,
+}
diff --git a/netopeer/voltha-grpc-client/voltha/openflow_13/openflow_13.pb.go b/netopeer/voltha-grpc-client/voltha/openflow_13/openflow_13.pb.go
new file mode 100644
index 0000000..4be77bd
--- /dev/null
+++ b/netopeer/voltha-grpc-client/voltha/openflow_13/openflow_13.pb.go
@@ -0,0 +1,8597 @@
+// Code generated by protoc-gen-go.
+// source: openflow_13.proto
+// DO NOT EDIT!
+
+/*
+Package openflow_13 is a generated protocol buffer package.
+
+It is generated from these files:
+	openflow_13.proto
+
+It has these top-level messages:
+	OfpHeader
+	OfpHelloElemHeader
+	OfpHelloElemVersionbitmap
+	OfpHello
+	OfpSwitchConfig
+	OfpTableMod
+	OfpPort
+	OfpSwitchFeatures
+	OfpPortStatus
+	OfpPortMod
+	OfpMatch
+	OfpOxmField
+	OfpOxmOfbField
+	OfpOxmExperimenterField
+	OfpAction
+	OfpActionOutput
+	OfpActionMplsTtl
+	OfpActionPush
+	OfpActionPopMpls
+	OfpActionGroup
+	OfpActionNwTtl
+	OfpActionSetField
+	OfpActionExperimenter
+	OfpInstruction
+	OfpInstructionGotoTable
+	OfpInstructionWriteMetadata
+	OfpInstructionActions
+	OfpInstructionMeter
+	OfpInstructionExperimenter
+	OfpFlowMod
+	OfpBucket
+	OfpGroupMod
+	OfpPacketOut
+	OfpPacketIn
+	OfpFlowRemoved
+	OfpMeterBandHeader
+	OfpMeterBandDrop
+	OfpMeterBandDscpRemark
+	OfpMeterBandExperimenter
+	OfpMeterMod
+	OfpErrorMsg
+	OfpErrorExperimenterMsg
+	OfpMultipartRequest
+	OfpMultipartReply
+	OfpDesc
+	OfpFlowStatsRequest
+	OfpFlowStats
+	OfpAggregateStatsRequest
+	OfpAggregateStatsReply
+	OfpTableFeatureProperty
+	OfpTableFeaturePropInstructions
+	OfpTableFeaturePropNextTables
+	OfpTableFeaturePropActions
+	OfpTableFeaturePropOxm
+	OfpTableFeaturePropExperimenter
+	OfpTableFeatures
+	OfpTableStats
+	OfpPortStatsRequest
+	OfpPortStats
+	OfpGroupStatsRequest
+	OfpBucketCounter
+	OfpGroupStats
+	OfpGroupDesc
+	OfpGroupEntry
+	OfpGroupFeatures
+	OfpMeterMultipartRequest
+	OfpMeterBandStats
+	OfpMeterStats
+	OfpMeterConfig
+	OfpMeterFeatures
+	OfpExperimenterMultipartHeader
+	OfpExperimenterHeader
+	OfpQueuePropHeader
+	OfpQueuePropMinRate
+	OfpQueuePropMaxRate
+	OfpQueuePropExperimenter
+	OfpPacketQueue
+	OfpQueueGetConfigRequest
+	OfpQueueGetConfigReply
+	OfpActionSetQueue
+	OfpQueueStatsRequest
+	OfpQueueStats
+	OfpRoleRequest
+	OfpAsyncConfig
+	FlowTableUpdate
+	FlowGroupTableUpdate
+	Flows
+	FlowGroups
+	PacketIn
+	PacketOut
+	ChangeEvent
+*/
+package openflow_13
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+import voltha "github.com/opencord/voltha/netconf/translator/voltha/yang_options"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+// InlineNode from public import yang_options.proto
+type InlineNode voltha.InlineNode
+
+func (m *InlineNode) Reset()          { (*voltha.InlineNode)(m).Reset() }
+func (m *InlineNode) String() string  { return (*voltha.InlineNode)(m).String() }
+func (*InlineNode) ProtoMessage()     {}
+func (m *InlineNode) GetId() string   { return (*voltha.InlineNode)(m).GetId() }
+func (m *InlineNode) GetType() string { return (*voltha.InlineNode)(m).GetType() }
+
+// RpcReturnDef from public import yang_options.proto
+type RpcReturnDef voltha.RpcReturnDef
+
+func (m *RpcReturnDef) Reset()                   { (*voltha.RpcReturnDef)(m).Reset() }
+func (m *RpcReturnDef) String() string           { return (*voltha.RpcReturnDef)(m).String() }
+func (*RpcReturnDef) ProtoMessage()              {}
+func (m *RpcReturnDef) GetXmlTag() string        { return (*voltha.RpcReturnDef)(m).GetXmlTag() }
+func (m *RpcReturnDef) GetListItemsName() string { return (*voltha.RpcReturnDef)(m).GetListItemsName() }
+
+// MessageParserOption from public import yang_options.proto
+type MessageParserOption voltha.MessageParserOption
+
+var MessageParserOption_name = voltha.MessageParserOption_name
+var MessageParserOption_value = voltha.MessageParserOption_value
+
+func (x MessageParserOption) String() string { return (voltha.MessageParserOption)(x).String() }
+
+const MessageParserOption_MOVE_TO_PARENT_LEVEL = MessageParserOption(voltha.MessageParserOption_MOVE_TO_PARENT_LEVEL)
+const MessageParserOption_CREATE_BOTH_GROUPING_AND_CONTAINER = MessageParserOption(voltha.MessageParserOption_CREATE_BOTH_GROUPING_AND_CONTAINER)
+
+// yang_child_rule from public import yang_options.proto
+var E_YangChildRule = voltha.E_YangChildRule
+
+// yang_message_rule from public import yang_options.proto
+var E_YangMessageRule = voltha.E_YangMessageRule
+
+// yang_inline_node from public import yang_options.proto
+var E_YangInlineNode = voltha.E_YangInlineNode
+
+// yang_xml_tag from public import yang_options.proto
+var E_YangXmlTag = voltha.E_YangXmlTag
+
+// Port numbering. Ports are numbered starting from 1.
+type OfpPortNo int32
+
+const (
+	OfpPortNo_OFPP_INVALID OfpPortNo = 0
+	// Maximum number of physical and logical switch ports.
+	OfpPortNo_OFPP_MAX OfpPortNo = 2147483392
+	// Reserved OpenFlow Port (fake output "ports").
+	OfpPortNo_OFPP_IN_PORT    OfpPortNo = 2147483640
+	OfpPortNo_OFPP_TABLE      OfpPortNo = 2147483641
+	OfpPortNo_OFPP_NORMAL     OfpPortNo = 2147483642
+	OfpPortNo_OFPP_FLOOD      OfpPortNo = 2147483643
+	OfpPortNo_OFPP_ALL        OfpPortNo = 2147483644
+	OfpPortNo_OFPP_CONTROLLER OfpPortNo = 2147483645
+	OfpPortNo_OFPP_LOCAL      OfpPortNo = 2147483646
+	OfpPortNo_OFPP_ANY        OfpPortNo = 2147483647
+)
+
+var OfpPortNo_name = map[int32]string{
+	0:          "OFPP_INVALID",
+	2147483392: "OFPP_MAX",
+	2147483640: "OFPP_IN_PORT",
+	2147483641: "OFPP_TABLE",
+	2147483642: "OFPP_NORMAL",
+	2147483643: "OFPP_FLOOD",
+	2147483644: "OFPP_ALL",
+	2147483645: "OFPP_CONTROLLER",
+	2147483646: "OFPP_LOCAL",
+	2147483647: "OFPP_ANY",
+}
+var OfpPortNo_value = map[string]int32{
+	"OFPP_INVALID":    0,
+	"OFPP_MAX":        2147483392,
+	"OFPP_IN_PORT":    2147483640,
+	"OFPP_TABLE":      2147483641,
+	"OFPP_NORMAL":     2147483642,
+	"OFPP_FLOOD":      2147483643,
+	"OFPP_ALL":        2147483644,
+	"OFPP_CONTROLLER": 2147483645,
+	"OFPP_LOCAL":      2147483646,
+	"OFPP_ANY":        2147483647,
+}
+
+func (x OfpPortNo) String() string {
+	return proto.EnumName(OfpPortNo_name, int32(x))
+}
+func (OfpPortNo) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
+
+type OfpType int32
+
+const (
+	// Immutable messages.
+	OfpType_OFPT_HELLO        OfpType = 0
+	OfpType_OFPT_ERROR        OfpType = 1
+	OfpType_OFPT_ECHO_REQUEST OfpType = 2
+	OfpType_OFPT_ECHO_REPLY   OfpType = 3
+	OfpType_OFPT_EXPERIMENTER OfpType = 4
+	// Switch configuration messages.
+	OfpType_OFPT_FEATURES_REQUEST   OfpType = 5
+	OfpType_OFPT_FEATURES_REPLY     OfpType = 6
+	OfpType_OFPT_GET_CONFIG_REQUEST OfpType = 7
+	OfpType_OFPT_GET_CONFIG_REPLY   OfpType = 8
+	OfpType_OFPT_SET_CONFIG         OfpType = 9
+	// Asynchronous messages.
+	OfpType_OFPT_PACKET_IN    OfpType = 10
+	OfpType_OFPT_FLOW_REMOVED OfpType = 11
+	OfpType_OFPT_PORT_STATUS  OfpType = 12
+	// Controller command messages.
+	OfpType_OFPT_PACKET_OUT OfpType = 13
+	OfpType_OFPT_FLOW_MOD   OfpType = 14
+	OfpType_OFPT_GROUP_MOD  OfpType = 15
+	OfpType_OFPT_PORT_MOD   OfpType = 16
+	OfpType_OFPT_TABLE_MOD  OfpType = 17
+	// Multipart messages.
+	OfpType_OFPT_MULTIPART_REQUEST OfpType = 18
+	OfpType_OFPT_MULTIPART_REPLY   OfpType = 19
+	// Barrier messages.
+	OfpType_OFPT_BARRIER_REQUEST OfpType = 20
+	OfpType_OFPT_BARRIER_REPLY   OfpType = 21
+	// Queue Configuration messages.
+	OfpType_OFPT_QUEUE_GET_CONFIG_REQUEST OfpType = 22
+	OfpType_OFPT_QUEUE_GET_CONFIG_REPLY   OfpType = 23
+	// Controller role change request messages.
+	OfpType_OFPT_ROLE_REQUEST OfpType = 24
+	OfpType_OFPT_ROLE_REPLY   OfpType = 25
+	// Asynchronous message configuration.
+	OfpType_OFPT_GET_ASYNC_REQUEST OfpType = 26
+	OfpType_OFPT_GET_ASYNC_REPLY   OfpType = 27
+	OfpType_OFPT_SET_ASYNC         OfpType = 28
+	// Meters and rate limiters configuration messages.
+	OfpType_OFPT_METER_MOD OfpType = 29
+)
+
+var OfpType_name = map[int32]string{
+	0:  "OFPT_HELLO",
+	1:  "OFPT_ERROR",
+	2:  "OFPT_ECHO_REQUEST",
+	3:  "OFPT_ECHO_REPLY",
+	4:  "OFPT_EXPERIMENTER",
+	5:  "OFPT_FEATURES_REQUEST",
+	6:  "OFPT_FEATURES_REPLY",
+	7:  "OFPT_GET_CONFIG_REQUEST",
+	8:  "OFPT_GET_CONFIG_REPLY",
+	9:  "OFPT_SET_CONFIG",
+	10: "OFPT_PACKET_IN",
+	11: "OFPT_FLOW_REMOVED",
+	12: "OFPT_PORT_STATUS",
+	13: "OFPT_PACKET_OUT",
+	14: "OFPT_FLOW_MOD",
+	15: "OFPT_GROUP_MOD",
+	16: "OFPT_PORT_MOD",
+	17: "OFPT_TABLE_MOD",
+	18: "OFPT_MULTIPART_REQUEST",
+	19: "OFPT_MULTIPART_REPLY",
+	20: "OFPT_BARRIER_REQUEST",
+	21: "OFPT_BARRIER_REPLY",
+	22: "OFPT_QUEUE_GET_CONFIG_REQUEST",
+	23: "OFPT_QUEUE_GET_CONFIG_REPLY",
+	24: "OFPT_ROLE_REQUEST",
+	25: "OFPT_ROLE_REPLY",
+	26: "OFPT_GET_ASYNC_REQUEST",
+	27: "OFPT_GET_ASYNC_REPLY",
+	28: "OFPT_SET_ASYNC",
+	29: "OFPT_METER_MOD",
+}
+var OfpType_value = map[string]int32{
+	"OFPT_HELLO":                    0,
+	"OFPT_ERROR":                    1,
+	"OFPT_ECHO_REQUEST":             2,
+	"OFPT_ECHO_REPLY":               3,
+	"OFPT_EXPERIMENTER":             4,
+	"OFPT_FEATURES_REQUEST":         5,
+	"OFPT_FEATURES_REPLY":           6,
+	"OFPT_GET_CONFIG_REQUEST":       7,
+	"OFPT_GET_CONFIG_REPLY":         8,
+	"OFPT_SET_CONFIG":               9,
+	"OFPT_PACKET_IN":                10,
+	"OFPT_FLOW_REMOVED":             11,
+	"OFPT_PORT_STATUS":              12,
+	"OFPT_PACKET_OUT":               13,
+	"OFPT_FLOW_MOD":                 14,
+	"OFPT_GROUP_MOD":                15,
+	"OFPT_PORT_MOD":                 16,
+	"OFPT_TABLE_MOD":                17,
+	"OFPT_MULTIPART_REQUEST":        18,
+	"OFPT_MULTIPART_REPLY":          19,
+	"OFPT_BARRIER_REQUEST":          20,
+	"OFPT_BARRIER_REPLY":            21,
+	"OFPT_QUEUE_GET_CONFIG_REQUEST": 22,
+	"OFPT_QUEUE_GET_CONFIG_REPLY":   23,
+	"OFPT_ROLE_REQUEST":             24,
+	"OFPT_ROLE_REPLY":               25,
+	"OFPT_GET_ASYNC_REQUEST":        26,
+	"OFPT_GET_ASYNC_REPLY":          27,
+	"OFPT_SET_ASYNC":                28,
+	"OFPT_METER_MOD":                29,
+}
+
+func (x OfpType) String() string {
+	return proto.EnumName(OfpType_name, int32(x))
+}
+func (OfpType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
+
+// Hello elements types.
+type OfpHelloElemType int32
+
+const (
+	OfpHelloElemType_OFPHET_INVALID       OfpHelloElemType = 0
+	OfpHelloElemType_OFPHET_VERSIONBITMAP OfpHelloElemType = 1
+)
+
+var OfpHelloElemType_name = map[int32]string{
+	0: "OFPHET_INVALID",
+	1: "OFPHET_VERSIONBITMAP",
+}
+var OfpHelloElemType_value = map[string]int32{
+	"OFPHET_INVALID":       0,
+	"OFPHET_VERSIONBITMAP": 1,
+}
+
+func (x OfpHelloElemType) String() string {
+	return proto.EnumName(OfpHelloElemType_name, int32(x))
+}
+func (OfpHelloElemType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }
+
+type OfpConfigFlags int32
+
+const (
+	// Handling of IP fragments.
+	OfpConfigFlags_OFPC_FRAG_NORMAL OfpConfigFlags = 0
+	OfpConfigFlags_OFPC_FRAG_DROP   OfpConfigFlags = 1
+	OfpConfigFlags_OFPC_FRAG_REASM  OfpConfigFlags = 2
+	OfpConfigFlags_OFPC_FRAG_MASK   OfpConfigFlags = 3
+)
+
+var OfpConfigFlags_name = map[int32]string{
+	0: "OFPC_FRAG_NORMAL",
+	1: "OFPC_FRAG_DROP",
+	2: "OFPC_FRAG_REASM",
+	3: "OFPC_FRAG_MASK",
+}
+var OfpConfigFlags_value = map[string]int32{
+	"OFPC_FRAG_NORMAL": 0,
+	"OFPC_FRAG_DROP":   1,
+	"OFPC_FRAG_REASM":  2,
+	"OFPC_FRAG_MASK":   3,
+}
+
+func (x OfpConfigFlags) String() string {
+	return proto.EnumName(OfpConfigFlags_name, int32(x))
+}
+func (OfpConfigFlags) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{3} }
+
+// Flags to configure the table. Reserved for future use.
+type OfpTableConfig int32
+
+const (
+	OfpTableConfig_OFPTC_INVALID         OfpTableConfig = 0
+	OfpTableConfig_OFPTC_DEPRECATED_MASK OfpTableConfig = 3
+)
+
+var OfpTableConfig_name = map[int32]string{
+	0: "OFPTC_INVALID",
+	3: "OFPTC_DEPRECATED_MASK",
+}
+var OfpTableConfig_value = map[string]int32{
+	"OFPTC_INVALID":         0,
+	"OFPTC_DEPRECATED_MASK": 3,
+}
+
+func (x OfpTableConfig) String() string {
+	return proto.EnumName(OfpTableConfig_name, int32(x))
+}
+func (OfpTableConfig) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{4} }
+
+// Table numbering. Tables can use any number up to OFPT_MAX.
+type OfpTable int32
+
+const (
+	OfpTable_OFPTT_INVALID OfpTable = 0
+	// Last usable table number.
+	OfpTable_OFPTT_MAX OfpTable = 254
+	// Fake tables.
+	OfpTable_OFPTT_ALL OfpTable = 255
+)
+
+var OfpTable_name = map[int32]string{
+	0:   "OFPTT_INVALID",
+	254: "OFPTT_MAX",
+	255: "OFPTT_ALL",
+}
+var OfpTable_value = map[string]int32{
+	"OFPTT_INVALID": 0,
+	"OFPTT_MAX":     254,
+	"OFPTT_ALL":     255,
+}
+
+func (x OfpTable) String() string {
+	return proto.EnumName(OfpTable_name, int32(x))
+}
+func (OfpTable) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{5} }
+
+// Capabilities supported by the datapath.
+type OfpCapabilities int32
+
+const (
+	OfpCapabilities_OFPC_INVALID      OfpCapabilities = 0
+	OfpCapabilities_OFPC_FLOW_STATS   OfpCapabilities = 1
+	OfpCapabilities_OFPC_TABLE_STATS  OfpCapabilities = 2
+	OfpCapabilities_OFPC_PORT_STATS   OfpCapabilities = 4
+	OfpCapabilities_OFPC_GROUP_STATS  OfpCapabilities = 8
+	OfpCapabilities_OFPC_IP_REASM     OfpCapabilities = 32
+	OfpCapabilities_OFPC_QUEUE_STATS  OfpCapabilities = 64
+	OfpCapabilities_OFPC_PORT_BLOCKED OfpCapabilities = 256
+)
+
+var OfpCapabilities_name = map[int32]string{
+	0:   "OFPC_INVALID",
+	1:   "OFPC_FLOW_STATS",
+	2:   "OFPC_TABLE_STATS",
+	4:   "OFPC_PORT_STATS",
+	8:   "OFPC_GROUP_STATS",
+	32:  "OFPC_IP_REASM",
+	64:  "OFPC_QUEUE_STATS",
+	256: "OFPC_PORT_BLOCKED",
+}
+var OfpCapabilities_value = map[string]int32{
+	"OFPC_INVALID":      0,
+	"OFPC_FLOW_STATS":   1,
+	"OFPC_TABLE_STATS":  2,
+	"OFPC_PORT_STATS":   4,
+	"OFPC_GROUP_STATS":  8,
+	"OFPC_IP_REASM":     32,
+	"OFPC_QUEUE_STATS":  64,
+	"OFPC_PORT_BLOCKED": 256,
+}
+
+func (x OfpCapabilities) String() string {
+	return proto.EnumName(OfpCapabilities_name, int32(x))
+}
+func (OfpCapabilities) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{6} }
+
+// Flags to indicate behavior of the physical port.  These flags are
+// used in ofp_port to describe the current configuration.  They are
+// used in the ofp_port_mod message to configure the port's behavior.
+type OfpPortConfig int32
+
+const (
+	OfpPortConfig_OFPPC_INVALID      OfpPortConfig = 0
+	OfpPortConfig_OFPPC_PORT_DOWN    OfpPortConfig = 1
+	OfpPortConfig_OFPPC_NO_RECV      OfpPortConfig = 4
+	OfpPortConfig_OFPPC_NO_FWD       OfpPortConfig = 32
+	OfpPortConfig_OFPPC_NO_PACKET_IN OfpPortConfig = 64
+)
+
+var OfpPortConfig_name = map[int32]string{
+	0:  "OFPPC_INVALID",
+	1:  "OFPPC_PORT_DOWN",
+	4:  "OFPPC_NO_RECV",
+	32: "OFPPC_NO_FWD",
+	64: "OFPPC_NO_PACKET_IN",
+}
+var OfpPortConfig_value = map[string]int32{
+	"OFPPC_INVALID":      0,
+	"OFPPC_PORT_DOWN":    1,
+	"OFPPC_NO_RECV":      4,
+	"OFPPC_NO_FWD":       32,
+	"OFPPC_NO_PACKET_IN": 64,
+}
+
+func (x OfpPortConfig) String() string {
+	return proto.EnumName(OfpPortConfig_name, int32(x))
+}
+func (OfpPortConfig) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{7} }
+
+// Current state of the physical port.  These are not configurable from
+// the controller.
+type OfpPortState int32
+
+const (
+	OfpPortState_OFPPS_INVALID   OfpPortState = 0
+	OfpPortState_OFPPS_LINK_DOWN OfpPortState = 1
+	OfpPortState_OFPPS_BLOCKED   OfpPortState = 2
+	OfpPortState_OFPPS_LIVE      OfpPortState = 4
+)
+
+var OfpPortState_name = map[int32]string{
+	0: "OFPPS_INVALID",
+	1: "OFPPS_LINK_DOWN",
+	2: "OFPPS_BLOCKED",
+	4: "OFPPS_LIVE",
+}
+var OfpPortState_value = map[string]int32{
+	"OFPPS_INVALID":   0,
+	"OFPPS_LINK_DOWN": 1,
+	"OFPPS_BLOCKED":   2,
+	"OFPPS_LIVE":      4,
+}
+
+func (x OfpPortState) String() string {
+	return proto.EnumName(OfpPortState_name, int32(x))
+}
+func (OfpPortState) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{8} }
+
+// Features of ports available in a datapath.
+type OfpPortFeatures int32
+
+const (
+	OfpPortFeatures_OFPPF_INVALID    OfpPortFeatures = 0
+	OfpPortFeatures_OFPPF_10MB_HD    OfpPortFeatures = 1
+	OfpPortFeatures_OFPPF_10MB_FD    OfpPortFeatures = 2
+	OfpPortFeatures_OFPPF_100MB_HD   OfpPortFeatures = 4
+	OfpPortFeatures_OFPPF_100MB_FD   OfpPortFeatures = 8
+	OfpPortFeatures_OFPPF_1GB_HD     OfpPortFeatures = 16
+	OfpPortFeatures_OFPPF_1GB_FD     OfpPortFeatures = 32
+	OfpPortFeatures_OFPPF_10GB_FD    OfpPortFeatures = 64
+	OfpPortFeatures_OFPPF_40GB_FD    OfpPortFeatures = 128
+	OfpPortFeatures_OFPPF_100GB_FD   OfpPortFeatures = 256
+	OfpPortFeatures_OFPPF_1TB_FD     OfpPortFeatures = 512
+	OfpPortFeatures_OFPPF_OTHER      OfpPortFeatures = 1024
+	OfpPortFeatures_OFPPF_COPPER     OfpPortFeatures = 2048
+	OfpPortFeatures_OFPPF_FIBER      OfpPortFeatures = 4096
+	OfpPortFeatures_OFPPF_AUTONEG    OfpPortFeatures = 8192
+	OfpPortFeatures_OFPPF_PAUSE      OfpPortFeatures = 16384
+	OfpPortFeatures_OFPPF_PAUSE_ASYM OfpPortFeatures = 32768
+)
+
+var OfpPortFeatures_name = map[int32]string{
+	0:     "OFPPF_INVALID",
+	1:     "OFPPF_10MB_HD",
+	2:     "OFPPF_10MB_FD",
+	4:     "OFPPF_100MB_HD",
+	8:     "OFPPF_100MB_FD",
+	16:    "OFPPF_1GB_HD",
+	32:    "OFPPF_1GB_FD",
+	64:    "OFPPF_10GB_FD",
+	128:   "OFPPF_40GB_FD",
+	256:   "OFPPF_100GB_FD",
+	512:   "OFPPF_1TB_FD",
+	1024:  "OFPPF_OTHER",
+	2048:  "OFPPF_COPPER",
+	4096:  "OFPPF_FIBER",
+	8192:  "OFPPF_AUTONEG",
+	16384: "OFPPF_PAUSE",
+	32768: "OFPPF_PAUSE_ASYM",
+}
+var OfpPortFeatures_value = map[string]int32{
+	"OFPPF_INVALID":    0,
+	"OFPPF_10MB_HD":    1,
+	"OFPPF_10MB_FD":    2,
+	"OFPPF_100MB_HD":   4,
+	"OFPPF_100MB_FD":   8,
+	"OFPPF_1GB_HD":     16,
+	"OFPPF_1GB_FD":     32,
+	"OFPPF_10GB_FD":    64,
+	"OFPPF_40GB_FD":    128,
+	"OFPPF_100GB_FD":   256,
+	"OFPPF_1TB_FD":     512,
+	"OFPPF_OTHER":      1024,
+	"OFPPF_COPPER":     2048,
+	"OFPPF_FIBER":      4096,
+	"OFPPF_AUTONEG":    8192,
+	"OFPPF_PAUSE":      16384,
+	"OFPPF_PAUSE_ASYM": 32768,
+}
+
+func (x OfpPortFeatures) String() string {
+	return proto.EnumName(OfpPortFeatures_name, int32(x))
+}
+func (OfpPortFeatures) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{9} }
+
+// What changed about the physical port
+type OfpPortReason int32
+
+const (
+	OfpPortReason_OFPPR_ADD    OfpPortReason = 0
+	OfpPortReason_OFPPR_DELETE OfpPortReason = 1
+	OfpPortReason_OFPPR_MODIFY OfpPortReason = 2
+)
+
+var OfpPortReason_name = map[int32]string{
+	0: "OFPPR_ADD",
+	1: "OFPPR_DELETE",
+	2: "OFPPR_MODIFY",
+}
+var OfpPortReason_value = map[string]int32{
+	"OFPPR_ADD":    0,
+	"OFPPR_DELETE": 1,
+	"OFPPR_MODIFY": 2,
+}
+
+func (x OfpPortReason) String() string {
+	return proto.EnumName(OfpPortReason_name, int32(x))
+}
+func (OfpPortReason) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{10} }
+
+// The match type indicates the match structure (set of fields that compose the
+// match) in use. The match type is placed in the type field at the beginning
+// of all match structures. The "OpenFlow Extensible Match" type corresponds
+// to OXM TLV format described below and must be supported by all OpenFlow
+// switches. Extensions that define other match types may be published on the
+// ONF wiki. Support for extensions is optional.
+type OfpMatchType int32
+
+const (
+	OfpMatchType_OFPMT_STANDARD OfpMatchType = 0
+	OfpMatchType_OFPMT_OXM      OfpMatchType = 1
+)
+
+var OfpMatchType_name = map[int32]string{
+	0: "OFPMT_STANDARD",
+	1: "OFPMT_OXM",
+}
+var OfpMatchType_value = map[string]int32{
+	"OFPMT_STANDARD": 0,
+	"OFPMT_OXM":      1,
+}
+
+func (x OfpMatchType) String() string {
+	return proto.EnumName(OfpMatchType_name, int32(x))
+}
+func (OfpMatchType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{11} }
+
+// OXM Class IDs.
+// The high order bit differentiate reserved classes from member classes.
+// Classes 0x0000 to 0x7FFF are member classes, allocated by ONF.
+// Classes 0x8000 to 0xFFFE are reserved classes, reserved for standardisation.
+type OfpOxmClass int32
+
+const (
+	OfpOxmClass_OFPXMC_NXM_0          OfpOxmClass = 0
+	OfpOxmClass_OFPXMC_NXM_1          OfpOxmClass = 1
+	OfpOxmClass_OFPXMC_OPENFLOW_BASIC OfpOxmClass = 32768
+	OfpOxmClass_OFPXMC_EXPERIMENTER   OfpOxmClass = 65535
+)
+
+var OfpOxmClass_name = map[int32]string{
+	0:     "OFPXMC_NXM_0",
+	1:     "OFPXMC_NXM_1",
+	32768: "OFPXMC_OPENFLOW_BASIC",
+	65535: "OFPXMC_EXPERIMENTER",
+}
+var OfpOxmClass_value = map[string]int32{
+	"OFPXMC_NXM_0":          0,
+	"OFPXMC_NXM_1":          1,
+	"OFPXMC_OPENFLOW_BASIC": 32768,
+	"OFPXMC_EXPERIMENTER":   65535,
+}
+
+func (x OfpOxmClass) String() string {
+	return proto.EnumName(OfpOxmClass_name, int32(x))
+}
+func (OfpOxmClass) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{12} }
+
+// OXM Flow field types for OpenFlow basic class.
+type OxmOfbFieldTypes int32
+
+const (
+	OxmOfbFieldTypes_OFPXMT_OFB_IN_PORT        OxmOfbFieldTypes = 0
+	OxmOfbFieldTypes_OFPXMT_OFB_IN_PHY_PORT    OxmOfbFieldTypes = 1
+	OxmOfbFieldTypes_OFPXMT_OFB_METADATA       OxmOfbFieldTypes = 2
+	OxmOfbFieldTypes_OFPXMT_OFB_ETH_DST        OxmOfbFieldTypes = 3
+	OxmOfbFieldTypes_OFPXMT_OFB_ETH_SRC        OxmOfbFieldTypes = 4
+	OxmOfbFieldTypes_OFPXMT_OFB_ETH_TYPE       OxmOfbFieldTypes = 5
+	OxmOfbFieldTypes_OFPXMT_OFB_VLAN_VID       OxmOfbFieldTypes = 6
+	OxmOfbFieldTypes_OFPXMT_OFB_VLAN_PCP       OxmOfbFieldTypes = 7
+	OxmOfbFieldTypes_OFPXMT_OFB_IP_DSCP        OxmOfbFieldTypes = 8
+	OxmOfbFieldTypes_OFPXMT_OFB_IP_ECN         OxmOfbFieldTypes = 9
+	OxmOfbFieldTypes_OFPXMT_OFB_IP_PROTO       OxmOfbFieldTypes = 10
+	OxmOfbFieldTypes_OFPXMT_OFB_IPV4_SRC       OxmOfbFieldTypes = 11
+	OxmOfbFieldTypes_OFPXMT_OFB_IPV4_DST       OxmOfbFieldTypes = 12
+	OxmOfbFieldTypes_OFPXMT_OFB_TCP_SRC        OxmOfbFieldTypes = 13
+	OxmOfbFieldTypes_OFPXMT_OFB_TCP_DST        OxmOfbFieldTypes = 14
+	OxmOfbFieldTypes_OFPXMT_OFB_UDP_SRC        OxmOfbFieldTypes = 15
+	OxmOfbFieldTypes_OFPXMT_OFB_UDP_DST        OxmOfbFieldTypes = 16
+	OxmOfbFieldTypes_OFPXMT_OFB_SCTP_SRC       OxmOfbFieldTypes = 17
+	OxmOfbFieldTypes_OFPXMT_OFB_SCTP_DST       OxmOfbFieldTypes = 18
+	OxmOfbFieldTypes_OFPXMT_OFB_ICMPV4_TYPE    OxmOfbFieldTypes = 19
+	OxmOfbFieldTypes_OFPXMT_OFB_ICMPV4_CODE    OxmOfbFieldTypes = 20
+	OxmOfbFieldTypes_OFPXMT_OFB_ARP_OP         OxmOfbFieldTypes = 21
+	OxmOfbFieldTypes_OFPXMT_OFB_ARP_SPA        OxmOfbFieldTypes = 22
+	OxmOfbFieldTypes_OFPXMT_OFB_ARP_TPA        OxmOfbFieldTypes = 23
+	OxmOfbFieldTypes_OFPXMT_OFB_ARP_SHA        OxmOfbFieldTypes = 24
+	OxmOfbFieldTypes_OFPXMT_OFB_ARP_THA        OxmOfbFieldTypes = 25
+	OxmOfbFieldTypes_OFPXMT_OFB_IPV6_SRC       OxmOfbFieldTypes = 26
+	OxmOfbFieldTypes_OFPXMT_OFB_IPV6_DST       OxmOfbFieldTypes = 27
+	OxmOfbFieldTypes_OFPXMT_OFB_IPV6_FLABEL    OxmOfbFieldTypes = 28
+	OxmOfbFieldTypes_OFPXMT_OFB_ICMPV6_TYPE    OxmOfbFieldTypes = 29
+	OxmOfbFieldTypes_OFPXMT_OFB_ICMPV6_CODE    OxmOfbFieldTypes = 30
+	OxmOfbFieldTypes_OFPXMT_OFB_IPV6_ND_TARGET OxmOfbFieldTypes = 31
+	OxmOfbFieldTypes_OFPXMT_OFB_IPV6_ND_SLL    OxmOfbFieldTypes = 32
+	OxmOfbFieldTypes_OFPXMT_OFB_IPV6_ND_TLL    OxmOfbFieldTypes = 33
+	OxmOfbFieldTypes_OFPXMT_OFB_MPLS_LABEL     OxmOfbFieldTypes = 34
+	OxmOfbFieldTypes_OFPXMT_OFB_MPLS_TC        OxmOfbFieldTypes = 35
+	OxmOfbFieldTypes_OFPXMT_OFB_MPLS_BOS       OxmOfbFieldTypes = 36
+	OxmOfbFieldTypes_OFPXMT_OFB_PBB_ISID       OxmOfbFieldTypes = 37
+	OxmOfbFieldTypes_OFPXMT_OFB_TUNNEL_ID      OxmOfbFieldTypes = 38
+	OxmOfbFieldTypes_OFPXMT_OFB_IPV6_EXTHDR    OxmOfbFieldTypes = 39
+)
+
+var OxmOfbFieldTypes_name = map[int32]string{
+	0:  "OFPXMT_OFB_IN_PORT",
+	1:  "OFPXMT_OFB_IN_PHY_PORT",
+	2:  "OFPXMT_OFB_METADATA",
+	3:  "OFPXMT_OFB_ETH_DST",
+	4:  "OFPXMT_OFB_ETH_SRC",
+	5:  "OFPXMT_OFB_ETH_TYPE",
+	6:  "OFPXMT_OFB_VLAN_VID",
+	7:  "OFPXMT_OFB_VLAN_PCP",
+	8:  "OFPXMT_OFB_IP_DSCP",
+	9:  "OFPXMT_OFB_IP_ECN",
+	10: "OFPXMT_OFB_IP_PROTO",
+	11: "OFPXMT_OFB_IPV4_SRC",
+	12: "OFPXMT_OFB_IPV4_DST",
+	13: "OFPXMT_OFB_TCP_SRC",
+	14: "OFPXMT_OFB_TCP_DST",
+	15: "OFPXMT_OFB_UDP_SRC",
+	16: "OFPXMT_OFB_UDP_DST",
+	17: "OFPXMT_OFB_SCTP_SRC",
+	18: "OFPXMT_OFB_SCTP_DST",
+	19: "OFPXMT_OFB_ICMPV4_TYPE",
+	20: "OFPXMT_OFB_ICMPV4_CODE",
+	21: "OFPXMT_OFB_ARP_OP",
+	22: "OFPXMT_OFB_ARP_SPA",
+	23: "OFPXMT_OFB_ARP_TPA",
+	24: "OFPXMT_OFB_ARP_SHA",
+	25: "OFPXMT_OFB_ARP_THA",
+	26: "OFPXMT_OFB_IPV6_SRC",
+	27: "OFPXMT_OFB_IPV6_DST",
+	28: "OFPXMT_OFB_IPV6_FLABEL",
+	29: "OFPXMT_OFB_ICMPV6_TYPE",
+	30: "OFPXMT_OFB_ICMPV6_CODE",
+	31: "OFPXMT_OFB_IPV6_ND_TARGET",
+	32: "OFPXMT_OFB_IPV6_ND_SLL",
+	33: "OFPXMT_OFB_IPV6_ND_TLL",
+	34: "OFPXMT_OFB_MPLS_LABEL",
+	35: "OFPXMT_OFB_MPLS_TC",
+	36: "OFPXMT_OFB_MPLS_BOS",
+	37: "OFPXMT_OFB_PBB_ISID",
+	38: "OFPXMT_OFB_TUNNEL_ID",
+	39: "OFPXMT_OFB_IPV6_EXTHDR",
+}
+var OxmOfbFieldTypes_value = map[string]int32{
+	"OFPXMT_OFB_IN_PORT":        0,
+	"OFPXMT_OFB_IN_PHY_PORT":    1,
+	"OFPXMT_OFB_METADATA":       2,
+	"OFPXMT_OFB_ETH_DST":        3,
+	"OFPXMT_OFB_ETH_SRC":        4,
+	"OFPXMT_OFB_ETH_TYPE":       5,
+	"OFPXMT_OFB_VLAN_VID":       6,
+	"OFPXMT_OFB_VLAN_PCP":       7,
+	"OFPXMT_OFB_IP_DSCP":        8,
+	"OFPXMT_OFB_IP_ECN":         9,
+	"OFPXMT_OFB_IP_PROTO":       10,
+	"OFPXMT_OFB_IPV4_SRC":       11,
+	"OFPXMT_OFB_IPV4_DST":       12,
+	"OFPXMT_OFB_TCP_SRC":        13,
+	"OFPXMT_OFB_TCP_DST":        14,
+	"OFPXMT_OFB_UDP_SRC":        15,
+	"OFPXMT_OFB_UDP_DST":        16,
+	"OFPXMT_OFB_SCTP_SRC":       17,
+	"OFPXMT_OFB_SCTP_DST":       18,
+	"OFPXMT_OFB_ICMPV4_TYPE":    19,
+	"OFPXMT_OFB_ICMPV4_CODE":    20,
+	"OFPXMT_OFB_ARP_OP":         21,
+	"OFPXMT_OFB_ARP_SPA":        22,
+	"OFPXMT_OFB_ARP_TPA":        23,
+	"OFPXMT_OFB_ARP_SHA":        24,
+	"OFPXMT_OFB_ARP_THA":        25,
+	"OFPXMT_OFB_IPV6_SRC":       26,
+	"OFPXMT_OFB_IPV6_DST":       27,
+	"OFPXMT_OFB_IPV6_FLABEL":    28,
+	"OFPXMT_OFB_ICMPV6_TYPE":    29,
+	"OFPXMT_OFB_ICMPV6_CODE":    30,
+	"OFPXMT_OFB_IPV6_ND_TARGET": 31,
+	"OFPXMT_OFB_IPV6_ND_SLL":    32,
+	"OFPXMT_OFB_IPV6_ND_TLL":    33,
+	"OFPXMT_OFB_MPLS_LABEL":     34,
+	"OFPXMT_OFB_MPLS_TC":        35,
+	"OFPXMT_OFB_MPLS_BOS":       36,
+	"OFPXMT_OFB_PBB_ISID":       37,
+	"OFPXMT_OFB_TUNNEL_ID":      38,
+	"OFPXMT_OFB_IPV6_EXTHDR":    39,
+}
+
+func (x OxmOfbFieldTypes) String() string {
+	return proto.EnumName(OxmOfbFieldTypes_name, int32(x))
+}
+func (OxmOfbFieldTypes) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{13} }
+
+// The VLAN id is 12-bits, so we can use the entire 16 bits to indicate
+// special conditions.
+type OfpVlanId int32
+
+const (
+	OfpVlanId_OFPVID_NONE    OfpVlanId = 0
+	OfpVlanId_OFPVID_PRESENT OfpVlanId = 4096
+)
+
+var OfpVlanId_name = map[int32]string{
+	0:    "OFPVID_NONE",
+	4096: "OFPVID_PRESENT",
+}
+var OfpVlanId_value = map[string]int32{
+	"OFPVID_NONE":    0,
+	"OFPVID_PRESENT": 4096,
+}
+
+func (x OfpVlanId) String() string {
+	return proto.EnumName(OfpVlanId_name, int32(x))
+}
+func (OfpVlanId) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{14} }
+
+// Bit definitions for IPv6 Extension Header pseudo-field.
+type OfpIpv6ExthdrFlags int32
+
+const (
+	OfpIpv6ExthdrFlags_OFPIEH_INVALID OfpIpv6ExthdrFlags = 0
+	OfpIpv6ExthdrFlags_OFPIEH_NONEXT  OfpIpv6ExthdrFlags = 1
+	OfpIpv6ExthdrFlags_OFPIEH_ESP     OfpIpv6ExthdrFlags = 2
+	OfpIpv6ExthdrFlags_OFPIEH_AUTH    OfpIpv6ExthdrFlags = 4
+	OfpIpv6ExthdrFlags_OFPIEH_DEST    OfpIpv6ExthdrFlags = 8
+	OfpIpv6ExthdrFlags_OFPIEH_FRAG    OfpIpv6ExthdrFlags = 16
+	OfpIpv6ExthdrFlags_OFPIEH_ROUTER  OfpIpv6ExthdrFlags = 32
+	OfpIpv6ExthdrFlags_OFPIEH_HOP     OfpIpv6ExthdrFlags = 64
+	OfpIpv6ExthdrFlags_OFPIEH_UNREP   OfpIpv6ExthdrFlags = 128
+	OfpIpv6ExthdrFlags_OFPIEH_UNSEQ   OfpIpv6ExthdrFlags = 256
+)
+
+var OfpIpv6ExthdrFlags_name = map[int32]string{
+	0:   "OFPIEH_INVALID",
+	1:   "OFPIEH_NONEXT",
+	2:   "OFPIEH_ESP",
+	4:   "OFPIEH_AUTH",
+	8:   "OFPIEH_DEST",
+	16:  "OFPIEH_FRAG",
+	32:  "OFPIEH_ROUTER",
+	64:  "OFPIEH_HOP",
+	128: "OFPIEH_UNREP",
+	256: "OFPIEH_UNSEQ",
+}
+var OfpIpv6ExthdrFlags_value = map[string]int32{
+	"OFPIEH_INVALID": 0,
+	"OFPIEH_NONEXT":  1,
+	"OFPIEH_ESP":     2,
+	"OFPIEH_AUTH":    4,
+	"OFPIEH_DEST":    8,
+	"OFPIEH_FRAG":    16,
+	"OFPIEH_ROUTER":  32,
+	"OFPIEH_HOP":     64,
+	"OFPIEH_UNREP":   128,
+	"OFPIEH_UNSEQ":   256,
+}
+
+func (x OfpIpv6ExthdrFlags) String() string {
+	return proto.EnumName(OfpIpv6ExthdrFlags_name, int32(x))
+}
+func (OfpIpv6ExthdrFlags) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{15} }
+
+type OfpActionType int32
+
+const (
+	OfpActionType_OFPAT_OUTPUT       OfpActionType = 0
+	OfpActionType_OFPAT_COPY_TTL_OUT OfpActionType = 11
+	OfpActionType_OFPAT_COPY_TTL_IN  OfpActionType = 12
+	OfpActionType_OFPAT_SET_MPLS_TTL OfpActionType = 15
+	OfpActionType_OFPAT_DEC_MPLS_TTL OfpActionType = 16
+	OfpActionType_OFPAT_PUSH_VLAN    OfpActionType = 17
+	OfpActionType_OFPAT_POP_VLAN     OfpActionType = 18
+	OfpActionType_OFPAT_PUSH_MPLS    OfpActionType = 19
+	OfpActionType_OFPAT_POP_MPLS     OfpActionType = 20
+	OfpActionType_OFPAT_SET_QUEUE    OfpActionType = 21
+	OfpActionType_OFPAT_GROUP        OfpActionType = 22
+	OfpActionType_OFPAT_SET_NW_TTL   OfpActionType = 23
+	OfpActionType_OFPAT_DEC_NW_TTL   OfpActionType = 24
+	OfpActionType_OFPAT_SET_FIELD    OfpActionType = 25
+	OfpActionType_OFPAT_PUSH_PBB     OfpActionType = 26
+	OfpActionType_OFPAT_POP_PBB      OfpActionType = 27
+	OfpActionType_OFPAT_EXPERIMENTER OfpActionType = 65535
+)
+
+var OfpActionType_name = map[int32]string{
+	0:     "OFPAT_OUTPUT",
+	11:    "OFPAT_COPY_TTL_OUT",
+	12:    "OFPAT_COPY_TTL_IN",
+	15:    "OFPAT_SET_MPLS_TTL",
+	16:    "OFPAT_DEC_MPLS_TTL",
+	17:    "OFPAT_PUSH_VLAN",
+	18:    "OFPAT_POP_VLAN",
+	19:    "OFPAT_PUSH_MPLS",
+	20:    "OFPAT_POP_MPLS",
+	21:    "OFPAT_SET_QUEUE",
+	22:    "OFPAT_GROUP",
+	23:    "OFPAT_SET_NW_TTL",
+	24:    "OFPAT_DEC_NW_TTL",
+	25:    "OFPAT_SET_FIELD",
+	26:    "OFPAT_PUSH_PBB",
+	27:    "OFPAT_POP_PBB",
+	65535: "OFPAT_EXPERIMENTER",
+}
+var OfpActionType_value = map[string]int32{
+	"OFPAT_OUTPUT":       0,
+	"OFPAT_COPY_TTL_OUT": 11,
+	"OFPAT_COPY_TTL_IN":  12,
+	"OFPAT_SET_MPLS_TTL": 15,
+	"OFPAT_DEC_MPLS_TTL": 16,
+	"OFPAT_PUSH_VLAN":    17,
+	"OFPAT_POP_VLAN":     18,
+	"OFPAT_PUSH_MPLS":    19,
+	"OFPAT_POP_MPLS":     20,
+	"OFPAT_SET_QUEUE":    21,
+	"OFPAT_GROUP":        22,
+	"OFPAT_SET_NW_TTL":   23,
+	"OFPAT_DEC_NW_TTL":   24,
+	"OFPAT_SET_FIELD":    25,
+	"OFPAT_PUSH_PBB":     26,
+	"OFPAT_POP_PBB":      27,
+	"OFPAT_EXPERIMENTER": 65535,
+}
+
+func (x OfpActionType) String() string {
+	return proto.EnumName(OfpActionType_name, int32(x))
+}
+func (OfpActionType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{16} }
+
+type OfpControllerMaxLen int32
+
+const (
+	OfpControllerMaxLen_OFPCML_INVALID   OfpControllerMaxLen = 0
+	OfpControllerMaxLen_OFPCML_MAX       OfpControllerMaxLen = 65509
+	OfpControllerMaxLen_OFPCML_NO_BUFFER OfpControllerMaxLen = 65535
+)
+
+var OfpControllerMaxLen_name = map[int32]string{
+	0:     "OFPCML_INVALID",
+	65509: "OFPCML_MAX",
+	65535: "OFPCML_NO_BUFFER",
+}
+var OfpControllerMaxLen_value = map[string]int32{
+	"OFPCML_INVALID":   0,
+	"OFPCML_MAX":       65509,
+	"OFPCML_NO_BUFFER": 65535,
+}
+
+func (x OfpControllerMaxLen) String() string {
+	return proto.EnumName(OfpControllerMaxLen_name, int32(x))
+}
+func (OfpControllerMaxLen) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{17} }
+
+type OfpInstructionType int32
+
+const (
+	OfpInstructionType_OFPIT_INVALID        OfpInstructionType = 0
+	OfpInstructionType_OFPIT_GOTO_TABLE     OfpInstructionType = 1
+	OfpInstructionType_OFPIT_WRITE_METADATA OfpInstructionType = 2
+	OfpInstructionType_OFPIT_WRITE_ACTIONS  OfpInstructionType = 3
+	OfpInstructionType_OFPIT_APPLY_ACTIONS  OfpInstructionType = 4
+	OfpInstructionType_OFPIT_CLEAR_ACTIONS  OfpInstructionType = 5
+	OfpInstructionType_OFPIT_METER          OfpInstructionType = 6
+	OfpInstructionType_OFPIT_EXPERIMENTER   OfpInstructionType = 65535
+)
+
+var OfpInstructionType_name = map[int32]string{
+	0:     "OFPIT_INVALID",
+	1:     "OFPIT_GOTO_TABLE",
+	2:     "OFPIT_WRITE_METADATA",
+	3:     "OFPIT_WRITE_ACTIONS",
+	4:     "OFPIT_APPLY_ACTIONS",
+	5:     "OFPIT_CLEAR_ACTIONS",
+	6:     "OFPIT_METER",
+	65535: "OFPIT_EXPERIMENTER",
+}
+var OfpInstructionType_value = map[string]int32{
+	"OFPIT_INVALID":        0,
+	"OFPIT_GOTO_TABLE":     1,
+	"OFPIT_WRITE_METADATA": 2,
+	"OFPIT_WRITE_ACTIONS":  3,
+	"OFPIT_APPLY_ACTIONS":  4,
+	"OFPIT_CLEAR_ACTIONS":  5,
+	"OFPIT_METER":          6,
+	"OFPIT_EXPERIMENTER":   65535,
+}
+
+func (x OfpInstructionType) String() string {
+	return proto.EnumName(OfpInstructionType_name, int32(x))
+}
+func (OfpInstructionType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{18} }
+
+type OfpFlowModCommand int32
+
+const (
+	OfpFlowModCommand_OFPFC_ADD           OfpFlowModCommand = 0
+	OfpFlowModCommand_OFPFC_MODIFY        OfpFlowModCommand = 1
+	OfpFlowModCommand_OFPFC_MODIFY_STRICT OfpFlowModCommand = 2
+	OfpFlowModCommand_OFPFC_DELETE        OfpFlowModCommand = 3
+	OfpFlowModCommand_OFPFC_DELETE_STRICT OfpFlowModCommand = 4
+)
+
+var OfpFlowModCommand_name = map[int32]string{
+	0: "OFPFC_ADD",
+	1: "OFPFC_MODIFY",
+	2: "OFPFC_MODIFY_STRICT",
+	3: "OFPFC_DELETE",
+	4: "OFPFC_DELETE_STRICT",
+}
+var OfpFlowModCommand_value = map[string]int32{
+	"OFPFC_ADD":           0,
+	"OFPFC_MODIFY":        1,
+	"OFPFC_MODIFY_STRICT": 2,
+	"OFPFC_DELETE":        3,
+	"OFPFC_DELETE_STRICT": 4,
+}
+
+func (x OfpFlowModCommand) String() string {
+	return proto.EnumName(OfpFlowModCommand_name, int32(x))
+}
+func (OfpFlowModCommand) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{19} }
+
+type OfpFlowModFlags int32
+
+const (
+	OfpFlowModFlags_OFPFF_INVALID       OfpFlowModFlags = 0
+	OfpFlowModFlags_OFPFF_SEND_FLOW_REM OfpFlowModFlags = 1
+	OfpFlowModFlags_OFPFF_CHECK_OVERLAP OfpFlowModFlags = 2
+	OfpFlowModFlags_OFPFF_RESET_COUNTS  OfpFlowModFlags = 4
+	OfpFlowModFlags_OFPFF_NO_PKT_COUNTS OfpFlowModFlags = 8
+	OfpFlowModFlags_OFPFF_NO_BYT_COUNTS OfpFlowModFlags = 16
+)
+
+var OfpFlowModFlags_name = map[int32]string{
+	0:  "OFPFF_INVALID",
+	1:  "OFPFF_SEND_FLOW_REM",
+	2:  "OFPFF_CHECK_OVERLAP",
+	4:  "OFPFF_RESET_COUNTS",
+	8:  "OFPFF_NO_PKT_COUNTS",
+	16: "OFPFF_NO_BYT_COUNTS",
+}
+var OfpFlowModFlags_value = map[string]int32{
+	"OFPFF_INVALID":       0,
+	"OFPFF_SEND_FLOW_REM": 1,
+	"OFPFF_CHECK_OVERLAP": 2,
+	"OFPFF_RESET_COUNTS":  4,
+	"OFPFF_NO_PKT_COUNTS": 8,
+	"OFPFF_NO_BYT_COUNTS": 16,
+}
+
+func (x OfpFlowModFlags) String() string {
+	return proto.EnumName(OfpFlowModFlags_name, int32(x))
+}
+func (OfpFlowModFlags) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{20} }
+
+// Group numbering. Groups can use any number up to OFPG_MAX.
+type OfpGroup int32
+
+const (
+	OfpGroup_OFPG_INVALID OfpGroup = 0
+	// Last usable group number.
+	OfpGroup_OFPG_MAX OfpGroup = 2147483392
+	// Fake groups.
+	OfpGroup_OFPG_ALL OfpGroup = 2147483644
+	OfpGroup_OFPG_ANY OfpGroup = 2147483647
+)
+
+var OfpGroup_name = map[int32]string{
+	0:          "OFPG_INVALID",
+	2147483392: "OFPG_MAX",
+	2147483644: "OFPG_ALL",
+	2147483647: "OFPG_ANY",
+}
+var OfpGroup_value = map[string]int32{
+	"OFPG_INVALID": 0,
+	"OFPG_MAX":     2147483392,
+	"OFPG_ALL":     2147483644,
+	"OFPG_ANY":     2147483647,
+}
+
+func (x OfpGroup) String() string {
+	return proto.EnumName(OfpGroup_name, int32(x))
+}
+func (OfpGroup) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{21} }
+
+// Group commands
+type OfpGroupModCommand int32
+
+const (
+	OfpGroupModCommand_OFPGC_ADD    OfpGroupModCommand = 0
+	OfpGroupModCommand_OFPGC_MODIFY OfpGroupModCommand = 1
+	OfpGroupModCommand_OFPGC_DELETE OfpGroupModCommand = 2
+)
+
+var OfpGroupModCommand_name = map[int32]string{
+	0: "OFPGC_ADD",
+	1: "OFPGC_MODIFY",
+	2: "OFPGC_DELETE",
+}
+var OfpGroupModCommand_value = map[string]int32{
+	"OFPGC_ADD":    0,
+	"OFPGC_MODIFY": 1,
+	"OFPGC_DELETE": 2,
+}
+
+func (x OfpGroupModCommand) String() string {
+	return proto.EnumName(OfpGroupModCommand_name, int32(x))
+}
+func (OfpGroupModCommand) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{22} }
+
+// Group types.  Values in the range [128; 255] are reserved for experimental
+// use.
+type OfpGroupType int32
+
+const (
+	OfpGroupType_OFPGT_ALL      OfpGroupType = 0
+	OfpGroupType_OFPGT_SELECT   OfpGroupType = 1
+	OfpGroupType_OFPGT_INDIRECT OfpGroupType = 2
+	OfpGroupType_OFPGT_FF       OfpGroupType = 3
+)
+
+var OfpGroupType_name = map[int32]string{
+	0: "OFPGT_ALL",
+	1: "OFPGT_SELECT",
+	2: "OFPGT_INDIRECT",
+	3: "OFPGT_FF",
+}
+var OfpGroupType_value = map[string]int32{
+	"OFPGT_ALL":      0,
+	"OFPGT_SELECT":   1,
+	"OFPGT_INDIRECT": 2,
+	"OFPGT_FF":       3,
+}
+
+func (x OfpGroupType) String() string {
+	return proto.EnumName(OfpGroupType_name, int32(x))
+}
+func (OfpGroupType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{23} }
+
+// Why is this packet being sent to the controller?
+type OfpPacketInReason int32
+
+const (
+	OfpPacketInReason_OFPR_NO_MATCH    OfpPacketInReason = 0
+	OfpPacketInReason_OFPR_ACTION      OfpPacketInReason = 1
+	OfpPacketInReason_OFPR_INVALID_TTL OfpPacketInReason = 2
+)
+
+var OfpPacketInReason_name = map[int32]string{
+	0: "OFPR_NO_MATCH",
+	1: "OFPR_ACTION",
+	2: "OFPR_INVALID_TTL",
+}
+var OfpPacketInReason_value = map[string]int32{
+	"OFPR_NO_MATCH":    0,
+	"OFPR_ACTION":      1,
+	"OFPR_INVALID_TTL": 2,
+}
+
+func (x OfpPacketInReason) String() string {
+	return proto.EnumName(OfpPacketInReason_name, int32(x))
+}
+func (OfpPacketInReason) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{24} }
+
+// Why was this flow removed?
+type OfpFlowRemovedReason int32
+
+const (
+	OfpFlowRemovedReason_OFPRR_IDLE_TIMEOUT OfpFlowRemovedReason = 0
+	OfpFlowRemovedReason_OFPRR_HARD_TIMEOUT OfpFlowRemovedReason = 1
+	OfpFlowRemovedReason_OFPRR_DELETE       OfpFlowRemovedReason = 2
+	OfpFlowRemovedReason_OFPRR_GROUP_DELETE OfpFlowRemovedReason = 3
+	OfpFlowRemovedReason_OFPRR_METER_DELETE OfpFlowRemovedReason = 4
+)
+
+var OfpFlowRemovedReason_name = map[int32]string{
+	0: "OFPRR_IDLE_TIMEOUT",
+	1: "OFPRR_HARD_TIMEOUT",
+	2: "OFPRR_DELETE",
+	3: "OFPRR_GROUP_DELETE",
+	4: "OFPRR_METER_DELETE",
+}
+var OfpFlowRemovedReason_value = map[string]int32{
+	"OFPRR_IDLE_TIMEOUT": 0,
+	"OFPRR_HARD_TIMEOUT": 1,
+	"OFPRR_DELETE":       2,
+	"OFPRR_GROUP_DELETE": 3,
+	"OFPRR_METER_DELETE": 4,
+}
+
+func (x OfpFlowRemovedReason) String() string {
+	return proto.EnumName(OfpFlowRemovedReason_name, int32(x))
+}
+func (OfpFlowRemovedReason) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{25} }
+
+// Meter numbering. Flow meters can use any number up to OFPM_MAX.
+type OfpMeter int32
+
+const (
+	OfpMeter_OFPM_ZERO OfpMeter = 0
+	// Last usable meter.
+	OfpMeter_OFPM_MAX OfpMeter = 2147418112
+	// Virtual meters.
+	OfpMeter_OFPM_SLOWPATH   OfpMeter = 2147483645
+	OfpMeter_OFPM_CONTROLLER OfpMeter = 2147483646
+	OfpMeter_OFPM_ALL        OfpMeter = 2147483647
+)
+
+var OfpMeter_name = map[int32]string{
+	0:          "OFPM_ZERO",
+	2147418112: "OFPM_MAX",
+	2147483645: "OFPM_SLOWPATH",
+	2147483646: "OFPM_CONTROLLER",
+	2147483647: "OFPM_ALL",
+}
+var OfpMeter_value = map[string]int32{
+	"OFPM_ZERO":       0,
+	"OFPM_MAX":        2147418112,
+	"OFPM_SLOWPATH":   2147483645,
+	"OFPM_CONTROLLER": 2147483646,
+	"OFPM_ALL":        2147483647,
+}
+
+func (x OfpMeter) String() string {
+	return proto.EnumName(OfpMeter_name, int32(x))
+}
+func (OfpMeter) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{26} }
+
+// Meter band types
+type OfpMeterBandType int32
+
+const (
+	OfpMeterBandType_OFPMBT_INVALID      OfpMeterBandType = 0
+	OfpMeterBandType_OFPMBT_DROP         OfpMeterBandType = 1
+	OfpMeterBandType_OFPMBT_DSCP_REMARK  OfpMeterBandType = 2
+	OfpMeterBandType_OFPMBT_EXPERIMENTER OfpMeterBandType = 65535
+)
+
+var OfpMeterBandType_name = map[int32]string{
+	0:     "OFPMBT_INVALID",
+	1:     "OFPMBT_DROP",
+	2:     "OFPMBT_DSCP_REMARK",
+	65535: "OFPMBT_EXPERIMENTER",
+}
+var OfpMeterBandType_value = map[string]int32{
+	"OFPMBT_INVALID":      0,
+	"OFPMBT_DROP":         1,
+	"OFPMBT_DSCP_REMARK":  2,
+	"OFPMBT_EXPERIMENTER": 65535,
+}
+
+func (x OfpMeterBandType) String() string {
+	return proto.EnumName(OfpMeterBandType_name, int32(x))
+}
+func (OfpMeterBandType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{27} }
+
+// Meter commands
+type OfpMeterModCommand int32
+
+const (
+	OfpMeterModCommand_OFPMC_ADD    OfpMeterModCommand = 0
+	OfpMeterModCommand_OFPMC_MODIFY OfpMeterModCommand = 1
+	OfpMeterModCommand_OFPMC_DELETE OfpMeterModCommand = 2
+)
+
+var OfpMeterModCommand_name = map[int32]string{
+	0: "OFPMC_ADD",
+	1: "OFPMC_MODIFY",
+	2: "OFPMC_DELETE",
+}
+var OfpMeterModCommand_value = map[string]int32{
+	"OFPMC_ADD":    0,
+	"OFPMC_MODIFY": 1,
+	"OFPMC_DELETE": 2,
+}
+
+func (x OfpMeterModCommand) String() string {
+	return proto.EnumName(OfpMeterModCommand_name, int32(x))
+}
+func (OfpMeterModCommand) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{28} }
+
+// Meter configuration flags
+type OfpMeterFlags int32
+
+const (
+	OfpMeterFlags_OFPMF_INVALID OfpMeterFlags = 0
+	OfpMeterFlags_OFPMF_KBPS    OfpMeterFlags = 1
+	OfpMeterFlags_OFPMF_PKTPS   OfpMeterFlags = 2
+	OfpMeterFlags_OFPMF_BURST   OfpMeterFlags = 4
+	OfpMeterFlags_OFPMF_STATS   OfpMeterFlags = 8
+)
+
+var OfpMeterFlags_name = map[int32]string{
+	0: "OFPMF_INVALID",
+	1: "OFPMF_KBPS",
+	2: "OFPMF_PKTPS",
+	4: "OFPMF_BURST",
+	8: "OFPMF_STATS",
+}
+var OfpMeterFlags_value = map[string]int32{
+	"OFPMF_INVALID": 0,
+	"OFPMF_KBPS":    1,
+	"OFPMF_PKTPS":   2,
+	"OFPMF_BURST":   4,
+	"OFPMF_STATS":   8,
+}
+
+func (x OfpMeterFlags) String() string {
+	return proto.EnumName(OfpMeterFlags_name, int32(x))
+}
+func (OfpMeterFlags) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{29} }
+
+// Values for 'type' in ofp_error_message.  These values are immutable: they
+// will not change in future versions of the protocol (although new values may
+// be added).
+type OfpErrorType int32
+
+const (
+	OfpErrorType_OFPET_HELLO_FAILED          OfpErrorType = 0
+	OfpErrorType_OFPET_BAD_REQUEST           OfpErrorType = 1
+	OfpErrorType_OFPET_BAD_ACTION            OfpErrorType = 2
+	OfpErrorType_OFPET_BAD_INSTRUCTION       OfpErrorType = 3
+	OfpErrorType_OFPET_BAD_MATCH             OfpErrorType = 4
+	OfpErrorType_OFPET_FLOW_MOD_FAILED       OfpErrorType = 5
+	OfpErrorType_OFPET_GROUP_MOD_FAILED      OfpErrorType = 6
+	OfpErrorType_OFPET_PORT_MOD_FAILED       OfpErrorType = 7
+	OfpErrorType_OFPET_TABLE_MOD_FAILED      OfpErrorType = 8
+	OfpErrorType_OFPET_QUEUE_OP_FAILED       OfpErrorType = 9
+	OfpErrorType_OFPET_SWITCH_CONFIG_FAILED  OfpErrorType = 10
+	OfpErrorType_OFPET_ROLE_REQUEST_FAILED   OfpErrorType = 11
+	OfpErrorType_OFPET_METER_MOD_FAILED      OfpErrorType = 12
+	OfpErrorType_OFPET_TABLE_FEATURES_FAILED OfpErrorType = 13
+	OfpErrorType_OFPET_EXPERIMENTER          OfpErrorType = 65535
+)
+
+var OfpErrorType_name = map[int32]string{
+	0:     "OFPET_HELLO_FAILED",
+	1:     "OFPET_BAD_REQUEST",
+	2:     "OFPET_BAD_ACTION",
+	3:     "OFPET_BAD_INSTRUCTION",
+	4:     "OFPET_BAD_MATCH",
+	5:     "OFPET_FLOW_MOD_FAILED",
+	6:     "OFPET_GROUP_MOD_FAILED",
+	7:     "OFPET_PORT_MOD_FAILED",
+	8:     "OFPET_TABLE_MOD_FAILED",
+	9:     "OFPET_QUEUE_OP_FAILED",
+	10:    "OFPET_SWITCH_CONFIG_FAILED",
+	11:    "OFPET_ROLE_REQUEST_FAILED",
+	12:    "OFPET_METER_MOD_FAILED",
+	13:    "OFPET_TABLE_FEATURES_FAILED",
+	65535: "OFPET_EXPERIMENTER",
+}
+var OfpErrorType_value = map[string]int32{
+	"OFPET_HELLO_FAILED":          0,
+	"OFPET_BAD_REQUEST":           1,
+	"OFPET_BAD_ACTION":            2,
+	"OFPET_BAD_INSTRUCTION":       3,
+	"OFPET_BAD_MATCH":             4,
+	"OFPET_FLOW_MOD_FAILED":       5,
+	"OFPET_GROUP_MOD_FAILED":      6,
+	"OFPET_PORT_MOD_FAILED":       7,
+	"OFPET_TABLE_MOD_FAILED":      8,
+	"OFPET_QUEUE_OP_FAILED":       9,
+	"OFPET_SWITCH_CONFIG_FAILED":  10,
+	"OFPET_ROLE_REQUEST_FAILED":   11,
+	"OFPET_METER_MOD_FAILED":      12,
+	"OFPET_TABLE_FEATURES_FAILED": 13,
+	"OFPET_EXPERIMENTER":          65535,
+}
+
+func (x OfpErrorType) String() string {
+	return proto.EnumName(OfpErrorType_name, int32(x))
+}
+func (OfpErrorType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{30} }
+
+// ofp_error_msg 'code' values for OFPET_HELLO_FAILED.  'data' contains an
+// ASCII text string that may give failure details.
+type OfpHelloFailedCode int32
+
+const (
+	OfpHelloFailedCode_OFPHFC_INCOMPATIBLE OfpHelloFailedCode = 0
+	OfpHelloFailedCode_OFPHFC_EPERM        OfpHelloFailedCode = 1
+)
+
+var OfpHelloFailedCode_name = map[int32]string{
+	0: "OFPHFC_INCOMPATIBLE",
+	1: "OFPHFC_EPERM",
+}
+var OfpHelloFailedCode_value = map[string]int32{
+	"OFPHFC_INCOMPATIBLE": 0,
+	"OFPHFC_EPERM":        1,
+}
+
+func (x OfpHelloFailedCode) String() string {
+	return proto.EnumName(OfpHelloFailedCode_name, int32(x))
+}
+func (OfpHelloFailedCode) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{31} }
+
+// ofp_error_msg 'code' values for OFPET_BAD_REQUEST.  'data' contains at least
+// the first 64 bytes of the failed request.
+type OfpBadRequestCode int32
+
+const (
+	OfpBadRequestCode_OFPBRC_BAD_VERSION               OfpBadRequestCode = 0
+	OfpBadRequestCode_OFPBRC_BAD_TYPE                  OfpBadRequestCode = 1
+	OfpBadRequestCode_OFPBRC_BAD_MULTIPART             OfpBadRequestCode = 2
+	OfpBadRequestCode_OFPBRC_BAD_EXPERIMENTER          OfpBadRequestCode = 3
+	OfpBadRequestCode_OFPBRC_BAD_EXP_TYPE              OfpBadRequestCode = 4
+	OfpBadRequestCode_OFPBRC_EPERM                     OfpBadRequestCode = 5
+	OfpBadRequestCode_OFPBRC_BAD_LEN                   OfpBadRequestCode = 6
+	OfpBadRequestCode_OFPBRC_BUFFER_EMPTY              OfpBadRequestCode = 7
+	OfpBadRequestCode_OFPBRC_BUFFER_UNKNOWN            OfpBadRequestCode = 8
+	OfpBadRequestCode_OFPBRC_BAD_TABLE_ID              OfpBadRequestCode = 9
+	OfpBadRequestCode_OFPBRC_IS_SLAVE                  OfpBadRequestCode = 10
+	OfpBadRequestCode_OFPBRC_BAD_PORT                  OfpBadRequestCode = 11
+	OfpBadRequestCode_OFPBRC_BAD_PACKET                OfpBadRequestCode = 12
+	OfpBadRequestCode_OFPBRC_MULTIPART_BUFFER_OVERFLOW OfpBadRequestCode = 13
+)
+
+var OfpBadRequestCode_name = map[int32]string{
+	0:  "OFPBRC_BAD_VERSION",
+	1:  "OFPBRC_BAD_TYPE",
+	2:  "OFPBRC_BAD_MULTIPART",
+	3:  "OFPBRC_BAD_EXPERIMENTER",
+	4:  "OFPBRC_BAD_EXP_TYPE",
+	5:  "OFPBRC_EPERM",
+	6:  "OFPBRC_BAD_LEN",
+	7:  "OFPBRC_BUFFER_EMPTY",
+	8:  "OFPBRC_BUFFER_UNKNOWN",
+	9:  "OFPBRC_BAD_TABLE_ID",
+	10: "OFPBRC_IS_SLAVE",
+	11: "OFPBRC_BAD_PORT",
+	12: "OFPBRC_BAD_PACKET",
+	13: "OFPBRC_MULTIPART_BUFFER_OVERFLOW",
+}
+var OfpBadRequestCode_value = map[string]int32{
+	"OFPBRC_BAD_VERSION":               0,
+	"OFPBRC_BAD_TYPE":                  1,
+	"OFPBRC_BAD_MULTIPART":             2,
+	"OFPBRC_BAD_EXPERIMENTER":          3,
+	"OFPBRC_BAD_EXP_TYPE":              4,
+	"OFPBRC_EPERM":                     5,
+	"OFPBRC_BAD_LEN":                   6,
+	"OFPBRC_BUFFER_EMPTY":              7,
+	"OFPBRC_BUFFER_UNKNOWN":            8,
+	"OFPBRC_BAD_TABLE_ID":              9,
+	"OFPBRC_IS_SLAVE":                  10,
+	"OFPBRC_BAD_PORT":                  11,
+	"OFPBRC_BAD_PACKET":                12,
+	"OFPBRC_MULTIPART_BUFFER_OVERFLOW": 13,
+}
+
+func (x OfpBadRequestCode) String() string {
+	return proto.EnumName(OfpBadRequestCode_name, int32(x))
+}
+func (OfpBadRequestCode) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{32} }
+
+// ofp_error_msg 'code' values for OFPET_BAD_ACTION.  'data' contains at least
+// the first 64 bytes of the failed request.
+type OfpBadActionCode int32
+
+const (
+	OfpBadActionCode_OFPBAC_BAD_TYPE           OfpBadActionCode = 0
+	OfpBadActionCode_OFPBAC_BAD_LEN            OfpBadActionCode = 1
+	OfpBadActionCode_OFPBAC_BAD_EXPERIMENTER   OfpBadActionCode = 2
+	OfpBadActionCode_OFPBAC_BAD_EXP_TYPE       OfpBadActionCode = 3
+	OfpBadActionCode_OFPBAC_BAD_OUT_PORT       OfpBadActionCode = 4
+	OfpBadActionCode_OFPBAC_BAD_ARGUMENT       OfpBadActionCode = 5
+	OfpBadActionCode_OFPBAC_EPERM              OfpBadActionCode = 6
+	OfpBadActionCode_OFPBAC_TOO_MANY           OfpBadActionCode = 7
+	OfpBadActionCode_OFPBAC_BAD_QUEUE          OfpBadActionCode = 8
+	OfpBadActionCode_OFPBAC_BAD_OUT_GROUP      OfpBadActionCode = 9
+	OfpBadActionCode_OFPBAC_MATCH_INCONSISTENT OfpBadActionCode = 10
+	OfpBadActionCode_OFPBAC_UNSUPPORTED_ORDER  OfpBadActionCode = 11
+	OfpBadActionCode_OFPBAC_BAD_TAG            OfpBadActionCode = 12
+	OfpBadActionCode_OFPBAC_BAD_SET_TYPE       OfpBadActionCode = 13
+	OfpBadActionCode_OFPBAC_BAD_SET_LEN        OfpBadActionCode = 14
+	OfpBadActionCode_OFPBAC_BAD_SET_ARGUMENT   OfpBadActionCode = 15
+)
+
+var OfpBadActionCode_name = map[int32]string{
+	0:  "OFPBAC_BAD_TYPE",
+	1:  "OFPBAC_BAD_LEN",
+	2:  "OFPBAC_BAD_EXPERIMENTER",
+	3:  "OFPBAC_BAD_EXP_TYPE",
+	4:  "OFPBAC_BAD_OUT_PORT",
+	5:  "OFPBAC_BAD_ARGUMENT",
+	6:  "OFPBAC_EPERM",
+	7:  "OFPBAC_TOO_MANY",
+	8:  "OFPBAC_BAD_QUEUE",
+	9:  "OFPBAC_BAD_OUT_GROUP",
+	10: "OFPBAC_MATCH_INCONSISTENT",
+	11: "OFPBAC_UNSUPPORTED_ORDER",
+	12: "OFPBAC_BAD_TAG",
+	13: "OFPBAC_BAD_SET_TYPE",
+	14: "OFPBAC_BAD_SET_LEN",
+	15: "OFPBAC_BAD_SET_ARGUMENT",
+}
+var OfpBadActionCode_value = map[string]int32{
+	"OFPBAC_BAD_TYPE":           0,
+	"OFPBAC_BAD_LEN":            1,
+	"OFPBAC_BAD_EXPERIMENTER":   2,
+	"OFPBAC_BAD_EXP_TYPE":       3,
+	"OFPBAC_BAD_OUT_PORT":       4,
+	"OFPBAC_BAD_ARGUMENT":       5,
+	"OFPBAC_EPERM":              6,
+	"OFPBAC_TOO_MANY":           7,
+	"OFPBAC_BAD_QUEUE":          8,
+	"OFPBAC_BAD_OUT_GROUP":      9,
+	"OFPBAC_MATCH_INCONSISTENT": 10,
+	"OFPBAC_UNSUPPORTED_ORDER":  11,
+	"OFPBAC_BAD_TAG":            12,
+	"OFPBAC_BAD_SET_TYPE":       13,
+	"OFPBAC_BAD_SET_LEN":        14,
+	"OFPBAC_BAD_SET_ARGUMENT":   15,
+}
+
+func (x OfpBadActionCode) String() string {
+	return proto.EnumName(OfpBadActionCode_name, int32(x))
+}
+func (OfpBadActionCode) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{33} }
+
+// ofp_error_msg 'code' values for OFPET_BAD_INSTRUCTION.  'data' contains at
+// least the first 64 bytes of the failed request.
+type OfpBadInstructionCode int32
+
+const (
+	OfpBadInstructionCode_OFPBIC_UNKNOWN_INST        OfpBadInstructionCode = 0
+	OfpBadInstructionCode_OFPBIC_UNSUP_INST          OfpBadInstructionCode = 1
+	OfpBadInstructionCode_OFPBIC_BAD_TABLE_ID        OfpBadInstructionCode = 2
+	OfpBadInstructionCode_OFPBIC_UNSUP_METADATA      OfpBadInstructionCode = 3
+	OfpBadInstructionCode_OFPBIC_UNSUP_METADATA_MASK OfpBadInstructionCode = 4
+	OfpBadInstructionCode_OFPBIC_BAD_EXPERIMENTER    OfpBadInstructionCode = 5
+	OfpBadInstructionCode_OFPBIC_BAD_EXP_TYPE        OfpBadInstructionCode = 6
+	OfpBadInstructionCode_OFPBIC_BAD_LEN             OfpBadInstructionCode = 7
+	OfpBadInstructionCode_OFPBIC_EPERM               OfpBadInstructionCode = 8
+)
+
+var OfpBadInstructionCode_name = map[int32]string{
+	0: "OFPBIC_UNKNOWN_INST",
+	1: "OFPBIC_UNSUP_INST",
+	2: "OFPBIC_BAD_TABLE_ID",
+	3: "OFPBIC_UNSUP_METADATA",
+	4: "OFPBIC_UNSUP_METADATA_MASK",
+	5: "OFPBIC_BAD_EXPERIMENTER",
+	6: "OFPBIC_BAD_EXP_TYPE",
+	7: "OFPBIC_BAD_LEN",
+	8: "OFPBIC_EPERM",
+}
+var OfpBadInstructionCode_value = map[string]int32{
+	"OFPBIC_UNKNOWN_INST":        0,
+	"OFPBIC_UNSUP_INST":          1,
+	"OFPBIC_BAD_TABLE_ID":        2,
+	"OFPBIC_UNSUP_METADATA":      3,
+	"OFPBIC_UNSUP_METADATA_MASK": 4,
+	"OFPBIC_BAD_EXPERIMENTER":    5,
+	"OFPBIC_BAD_EXP_TYPE":        6,
+	"OFPBIC_BAD_LEN":             7,
+	"OFPBIC_EPERM":               8,
+}
+
+func (x OfpBadInstructionCode) String() string {
+	return proto.EnumName(OfpBadInstructionCode_name, int32(x))
+}
+func (OfpBadInstructionCode) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{34} }
+
+// ofp_error_msg 'code' values for OFPET_BAD_MATCH.  'data' contains at least
+// the first 64 bytes of the failed request.
+type OfpBadMatchCode int32
+
+const (
+	OfpBadMatchCode_OFPBMC_BAD_TYPE         OfpBadMatchCode = 0
+	OfpBadMatchCode_OFPBMC_BAD_LEN          OfpBadMatchCode = 1
+	OfpBadMatchCode_OFPBMC_BAD_TAG          OfpBadMatchCode = 2
+	OfpBadMatchCode_OFPBMC_BAD_DL_ADDR_MASK OfpBadMatchCode = 3
+	OfpBadMatchCode_OFPBMC_BAD_NW_ADDR_MASK OfpBadMatchCode = 4
+	OfpBadMatchCode_OFPBMC_BAD_WILDCARDS    OfpBadMatchCode = 5
+	OfpBadMatchCode_OFPBMC_BAD_FIELD        OfpBadMatchCode = 6
+	OfpBadMatchCode_OFPBMC_BAD_VALUE        OfpBadMatchCode = 7
+	OfpBadMatchCode_OFPBMC_BAD_MASK         OfpBadMatchCode = 8
+	OfpBadMatchCode_OFPBMC_BAD_PREREQ       OfpBadMatchCode = 9
+	OfpBadMatchCode_OFPBMC_DUP_FIELD        OfpBadMatchCode = 10
+	OfpBadMatchCode_OFPBMC_EPERM            OfpBadMatchCode = 11
+)
+
+var OfpBadMatchCode_name = map[int32]string{
+	0:  "OFPBMC_BAD_TYPE",
+	1:  "OFPBMC_BAD_LEN",
+	2:  "OFPBMC_BAD_TAG",
+	3:  "OFPBMC_BAD_DL_ADDR_MASK",
+	4:  "OFPBMC_BAD_NW_ADDR_MASK",
+	5:  "OFPBMC_BAD_WILDCARDS",
+	6:  "OFPBMC_BAD_FIELD",
+	7:  "OFPBMC_BAD_VALUE",
+	8:  "OFPBMC_BAD_MASK",
+	9:  "OFPBMC_BAD_PREREQ",
+	10: "OFPBMC_DUP_FIELD",
+	11: "OFPBMC_EPERM",
+}
+var OfpBadMatchCode_value = map[string]int32{
+	"OFPBMC_BAD_TYPE":         0,
+	"OFPBMC_BAD_LEN":          1,
+	"OFPBMC_BAD_TAG":          2,
+	"OFPBMC_BAD_DL_ADDR_MASK": 3,
+	"OFPBMC_BAD_NW_ADDR_MASK": 4,
+	"OFPBMC_BAD_WILDCARDS":    5,
+	"OFPBMC_BAD_FIELD":        6,
+	"OFPBMC_BAD_VALUE":        7,
+	"OFPBMC_BAD_MASK":         8,
+	"OFPBMC_BAD_PREREQ":       9,
+	"OFPBMC_DUP_FIELD":        10,
+	"OFPBMC_EPERM":            11,
+}
+
+func (x OfpBadMatchCode) String() string {
+	return proto.EnumName(OfpBadMatchCode_name, int32(x))
+}
+func (OfpBadMatchCode) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{35} }
+
+// ofp_error_msg 'code' values for OFPET_FLOW_MOD_FAILED.  'data' contains
+// at least the first 64 bytes of the failed request.
+type OfpFlowModFailedCode int32
+
+const (
+	OfpFlowModFailedCode_OFPFMFC_UNKNOWN      OfpFlowModFailedCode = 0
+	OfpFlowModFailedCode_OFPFMFC_TABLE_FULL   OfpFlowModFailedCode = 1
+	OfpFlowModFailedCode_OFPFMFC_BAD_TABLE_ID OfpFlowModFailedCode = 2
+	OfpFlowModFailedCode_OFPFMFC_OVERLAP      OfpFlowModFailedCode = 3
+	OfpFlowModFailedCode_OFPFMFC_EPERM        OfpFlowModFailedCode = 4
+	OfpFlowModFailedCode_OFPFMFC_BAD_TIMEOUT  OfpFlowModFailedCode = 5
+	OfpFlowModFailedCode_OFPFMFC_BAD_COMMAND  OfpFlowModFailedCode = 6
+	OfpFlowModFailedCode_OFPFMFC_BAD_FLAGS    OfpFlowModFailedCode = 7
+)
+
+var OfpFlowModFailedCode_name = map[int32]string{
+	0: "OFPFMFC_UNKNOWN",
+	1: "OFPFMFC_TABLE_FULL",
+	2: "OFPFMFC_BAD_TABLE_ID",
+	3: "OFPFMFC_OVERLAP",
+	4: "OFPFMFC_EPERM",
+	5: "OFPFMFC_BAD_TIMEOUT",
+	6: "OFPFMFC_BAD_COMMAND",
+	7: "OFPFMFC_BAD_FLAGS",
+}
+var OfpFlowModFailedCode_value = map[string]int32{
+	"OFPFMFC_UNKNOWN":      0,
+	"OFPFMFC_TABLE_FULL":   1,
+	"OFPFMFC_BAD_TABLE_ID": 2,
+	"OFPFMFC_OVERLAP":      3,
+	"OFPFMFC_EPERM":        4,
+	"OFPFMFC_BAD_TIMEOUT":  5,
+	"OFPFMFC_BAD_COMMAND":  6,
+	"OFPFMFC_BAD_FLAGS":    7,
+}
+
+func (x OfpFlowModFailedCode) String() string {
+	return proto.EnumName(OfpFlowModFailedCode_name, int32(x))
+}
+func (OfpFlowModFailedCode) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{36} }
+
+// ofp_error_msg 'code' values for OFPET_GROUP_MOD_FAILED.  'data' contains
+// at least the first 64 bytes of the failed request.
+type OfpGroupModFailedCode int32
+
+const (
+	OfpGroupModFailedCode_OFPGMFC_GROUP_EXISTS         OfpGroupModFailedCode = 0
+	OfpGroupModFailedCode_OFPGMFC_INVALID_GROUP        OfpGroupModFailedCode = 1
+	OfpGroupModFailedCode_OFPGMFC_WEIGHT_UNSUPPORTED   OfpGroupModFailedCode = 2
+	OfpGroupModFailedCode_OFPGMFC_OUT_OF_GROUPS        OfpGroupModFailedCode = 3
+	OfpGroupModFailedCode_OFPGMFC_OUT_OF_BUCKETS       OfpGroupModFailedCode = 4
+	OfpGroupModFailedCode_OFPGMFC_CHAINING_UNSUPPORTED OfpGroupModFailedCode = 5
+	OfpGroupModFailedCode_OFPGMFC_WATCH_UNSUPPORTED    OfpGroupModFailedCode = 6
+	OfpGroupModFailedCode_OFPGMFC_LOOP                 OfpGroupModFailedCode = 7
+	OfpGroupModFailedCode_OFPGMFC_UNKNOWN_GROUP        OfpGroupModFailedCode = 8
+	OfpGroupModFailedCode_OFPGMFC_CHAINED_GROUP        OfpGroupModFailedCode = 9
+	OfpGroupModFailedCode_OFPGMFC_BAD_TYPE             OfpGroupModFailedCode = 10
+	OfpGroupModFailedCode_OFPGMFC_BAD_COMMAND          OfpGroupModFailedCode = 11
+	OfpGroupModFailedCode_OFPGMFC_BAD_BUCKET           OfpGroupModFailedCode = 12
+	OfpGroupModFailedCode_OFPGMFC_BAD_WATCH            OfpGroupModFailedCode = 13
+	OfpGroupModFailedCode_OFPGMFC_EPERM                OfpGroupModFailedCode = 14
+)
+
+var OfpGroupModFailedCode_name = map[int32]string{
+	0:  "OFPGMFC_GROUP_EXISTS",
+	1:  "OFPGMFC_INVALID_GROUP",
+	2:  "OFPGMFC_WEIGHT_UNSUPPORTED",
+	3:  "OFPGMFC_OUT_OF_GROUPS",
+	4:  "OFPGMFC_OUT_OF_BUCKETS",
+	5:  "OFPGMFC_CHAINING_UNSUPPORTED",
+	6:  "OFPGMFC_WATCH_UNSUPPORTED",
+	7:  "OFPGMFC_LOOP",
+	8:  "OFPGMFC_UNKNOWN_GROUP",
+	9:  "OFPGMFC_CHAINED_GROUP",
+	10: "OFPGMFC_BAD_TYPE",
+	11: "OFPGMFC_BAD_COMMAND",
+	12: "OFPGMFC_BAD_BUCKET",
+	13: "OFPGMFC_BAD_WATCH",
+	14: "OFPGMFC_EPERM",
+}
+var OfpGroupModFailedCode_value = map[string]int32{
+	"OFPGMFC_GROUP_EXISTS":         0,
+	"OFPGMFC_INVALID_GROUP":        1,
+	"OFPGMFC_WEIGHT_UNSUPPORTED":   2,
+	"OFPGMFC_OUT_OF_GROUPS":        3,
+	"OFPGMFC_OUT_OF_BUCKETS":       4,
+	"OFPGMFC_CHAINING_UNSUPPORTED": 5,
+	"OFPGMFC_WATCH_UNSUPPORTED":    6,
+	"OFPGMFC_LOOP":                 7,
+	"OFPGMFC_UNKNOWN_GROUP":        8,
+	"OFPGMFC_CHAINED_GROUP":        9,
+	"OFPGMFC_BAD_TYPE":             10,
+	"OFPGMFC_BAD_COMMAND":          11,
+	"OFPGMFC_BAD_BUCKET":           12,
+	"OFPGMFC_BAD_WATCH":            13,
+	"OFPGMFC_EPERM":                14,
+}
+
+func (x OfpGroupModFailedCode) String() string {
+	return proto.EnumName(OfpGroupModFailedCode_name, int32(x))
+}
+func (OfpGroupModFailedCode) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{37} }
+
+// ofp_error_msg 'code' values for OFPET_PORT_MOD_FAILED.  'data' contains
+// at least the first 64 bytes of the failed request.
+type OfpPortModFailedCode int32
+
+const (
+	OfpPortModFailedCode_OFPPMFC_BAD_PORT      OfpPortModFailedCode = 0
+	OfpPortModFailedCode_OFPPMFC_BAD_HW_ADDR   OfpPortModFailedCode = 1
+	OfpPortModFailedCode_OFPPMFC_BAD_CONFIG    OfpPortModFailedCode = 2
+	OfpPortModFailedCode_OFPPMFC_BAD_ADVERTISE OfpPortModFailedCode = 3
+	OfpPortModFailedCode_OFPPMFC_EPERM         OfpPortModFailedCode = 4
+)
+
+var OfpPortModFailedCode_name = map[int32]string{
+	0: "OFPPMFC_BAD_PORT",
+	1: "OFPPMFC_BAD_HW_ADDR",
+	2: "OFPPMFC_BAD_CONFIG",
+	3: "OFPPMFC_BAD_ADVERTISE",
+	4: "OFPPMFC_EPERM",
+}
+var OfpPortModFailedCode_value = map[string]int32{
+	"OFPPMFC_BAD_PORT":      0,
+	"OFPPMFC_BAD_HW_ADDR":   1,
+	"OFPPMFC_BAD_CONFIG":    2,
+	"OFPPMFC_BAD_ADVERTISE": 3,
+	"OFPPMFC_EPERM":         4,
+}
+
+func (x OfpPortModFailedCode) String() string {
+	return proto.EnumName(OfpPortModFailedCode_name, int32(x))
+}
+func (OfpPortModFailedCode) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{38} }
+
+// ofp_error_msg 'code' values for OFPET_TABLE_MOD_FAILED.  'data' contains
+// at least the first 64 bytes of the failed request.
+type OfpTableModFailedCode int32
+
+const (
+	OfpTableModFailedCode_OFPTMFC_BAD_TABLE  OfpTableModFailedCode = 0
+	OfpTableModFailedCode_OFPTMFC_BAD_CONFIG OfpTableModFailedCode = 1
+	OfpTableModFailedCode_OFPTMFC_EPERM      OfpTableModFailedCode = 2
+)
+
+var OfpTableModFailedCode_name = map[int32]string{
+	0: "OFPTMFC_BAD_TABLE",
+	1: "OFPTMFC_BAD_CONFIG",
+	2: "OFPTMFC_EPERM",
+}
+var OfpTableModFailedCode_value = map[string]int32{
+	"OFPTMFC_BAD_TABLE":  0,
+	"OFPTMFC_BAD_CONFIG": 1,
+	"OFPTMFC_EPERM":      2,
+}
+
+func (x OfpTableModFailedCode) String() string {
+	return proto.EnumName(OfpTableModFailedCode_name, int32(x))
+}
+func (OfpTableModFailedCode) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{39} }
+
+// ofp_error msg 'code' values for OFPET_QUEUE_OP_FAILED. 'data' contains
+// at least the first 64 bytes of the failed request
+type OfpQueueOpFailedCode int32
+
+const (
+	OfpQueueOpFailedCode_OFPQOFC_BAD_PORT  OfpQueueOpFailedCode = 0
+	OfpQueueOpFailedCode_OFPQOFC_BAD_QUEUE OfpQueueOpFailedCode = 1
+	OfpQueueOpFailedCode_OFPQOFC_EPERM     OfpQueueOpFailedCode = 2
+)
+
+var OfpQueueOpFailedCode_name = map[int32]string{
+	0: "OFPQOFC_BAD_PORT",
+	1: "OFPQOFC_BAD_QUEUE",
+	2: "OFPQOFC_EPERM",
+}
+var OfpQueueOpFailedCode_value = map[string]int32{
+	"OFPQOFC_BAD_PORT":  0,
+	"OFPQOFC_BAD_QUEUE": 1,
+	"OFPQOFC_EPERM":     2,
+}
+
+func (x OfpQueueOpFailedCode) String() string {
+	return proto.EnumName(OfpQueueOpFailedCode_name, int32(x))
+}
+func (OfpQueueOpFailedCode) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{40} }
+
+// ofp_error_msg 'code' values for OFPET_SWITCH_CONFIG_FAILED. 'data' contains
+// at least the first 64 bytes of the failed request.
+type OfpSwitchConfigFailedCode int32
+
+const (
+	OfpSwitchConfigFailedCode_OFPSCFC_BAD_FLAGS OfpSwitchConfigFailedCode = 0
+	OfpSwitchConfigFailedCode_OFPSCFC_BAD_LEN   OfpSwitchConfigFailedCode = 1
+	OfpSwitchConfigFailedCode_OFPSCFC_EPERM     OfpSwitchConfigFailedCode = 2
+)
+
+var OfpSwitchConfigFailedCode_name = map[int32]string{
+	0: "OFPSCFC_BAD_FLAGS",
+	1: "OFPSCFC_BAD_LEN",
+	2: "OFPSCFC_EPERM",
+}
+var OfpSwitchConfigFailedCode_value = map[string]int32{
+	"OFPSCFC_BAD_FLAGS": 0,
+	"OFPSCFC_BAD_LEN":   1,
+	"OFPSCFC_EPERM":     2,
+}
+
+func (x OfpSwitchConfigFailedCode) String() string {
+	return proto.EnumName(OfpSwitchConfigFailedCode_name, int32(x))
+}
+func (OfpSwitchConfigFailedCode) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{41} }
+
+// ofp_error_msg 'code' values for OFPET_ROLE_REQUEST_FAILED. 'data' contains
+// at least the first 64 bytes of the failed request.
+type OfpRoleRequestFailedCode int32
+
+const (
+	OfpRoleRequestFailedCode_OFPRRFC_STALE    OfpRoleRequestFailedCode = 0
+	OfpRoleRequestFailedCode_OFPRRFC_UNSUP    OfpRoleRequestFailedCode = 1
+	OfpRoleRequestFailedCode_OFPRRFC_BAD_ROLE OfpRoleRequestFailedCode = 2
+)
+
+var OfpRoleRequestFailedCode_name = map[int32]string{
+	0: "OFPRRFC_STALE",
+	1: "OFPRRFC_UNSUP",
+	2: "OFPRRFC_BAD_ROLE",
+}
+var OfpRoleRequestFailedCode_value = map[string]int32{
+	"OFPRRFC_STALE":    0,
+	"OFPRRFC_UNSUP":    1,
+	"OFPRRFC_BAD_ROLE": 2,
+}
+
+func (x OfpRoleRequestFailedCode) String() string {
+	return proto.EnumName(OfpRoleRequestFailedCode_name, int32(x))
+}
+func (OfpRoleRequestFailedCode) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{42} }
+
+// ofp_error_msg 'code' values for OFPET_METER_MOD_FAILED.  'data' contains
+// at least the first 64 bytes of the failed request.
+type OfpMeterModFailedCode int32
+
+const (
+	OfpMeterModFailedCode_OFPMMFC_UNKNOWN        OfpMeterModFailedCode = 0
+	OfpMeterModFailedCode_OFPMMFC_METER_EXISTS   OfpMeterModFailedCode = 1
+	OfpMeterModFailedCode_OFPMMFC_INVALID_METER  OfpMeterModFailedCode = 2
+	OfpMeterModFailedCode_OFPMMFC_UNKNOWN_METER  OfpMeterModFailedCode = 3
+	OfpMeterModFailedCode_OFPMMFC_BAD_COMMAND    OfpMeterModFailedCode = 4
+	OfpMeterModFailedCode_OFPMMFC_BAD_FLAGS      OfpMeterModFailedCode = 5
+	OfpMeterModFailedCode_OFPMMFC_BAD_RATE       OfpMeterModFailedCode = 6
+	OfpMeterModFailedCode_OFPMMFC_BAD_BURST      OfpMeterModFailedCode = 7
+	OfpMeterModFailedCode_OFPMMFC_BAD_BAND       OfpMeterModFailedCode = 8
+	OfpMeterModFailedCode_OFPMMFC_BAD_BAND_VALUE OfpMeterModFailedCode = 9
+	OfpMeterModFailedCode_OFPMMFC_OUT_OF_METERS  OfpMeterModFailedCode = 10
+	OfpMeterModFailedCode_OFPMMFC_OUT_OF_BANDS   OfpMeterModFailedCode = 11
+)
+
+var OfpMeterModFailedCode_name = map[int32]string{
+	0:  "OFPMMFC_UNKNOWN",
+	1:  "OFPMMFC_METER_EXISTS",
+	2:  "OFPMMFC_INVALID_METER",
+	3:  "OFPMMFC_UNKNOWN_METER",
+	4:  "OFPMMFC_BAD_COMMAND",
+	5:  "OFPMMFC_BAD_FLAGS",
+	6:  "OFPMMFC_BAD_RATE",
+	7:  "OFPMMFC_BAD_BURST",
+	8:  "OFPMMFC_BAD_BAND",
+	9:  "OFPMMFC_BAD_BAND_VALUE",
+	10: "OFPMMFC_OUT_OF_METERS",
+	11: "OFPMMFC_OUT_OF_BANDS",
+}
+var OfpMeterModFailedCode_value = map[string]int32{
+	"OFPMMFC_UNKNOWN":        0,
+	"OFPMMFC_METER_EXISTS":   1,
+	"OFPMMFC_INVALID_METER":  2,
+	"OFPMMFC_UNKNOWN_METER":  3,
+	"OFPMMFC_BAD_COMMAND":    4,
+	"OFPMMFC_BAD_FLAGS":      5,
+	"OFPMMFC_BAD_RATE":       6,
+	"OFPMMFC_BAD_BURST":      7,
+	"OFPMMFC_BAD_BAND":       8,
+	"OFPMMFC_BAD_BAND_VALUE": 9,
+	"OFPMMFC_OUT_OF_METERS":  10,
+	"OFPMMFC_OUT_OF_BANDS":   11,
+}
+
+func (x OfpMeterModFailedCode) String() string {
+	return proto.EnumName(OfpMeterModFailedCode_name, int32(x))
+}
+func (OfpMeterModFailedCode) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{43} }
+
+// ofp_error_msg 'code' values for OFPET_TABLE_FEATURES_FAILED. 'data' contains
+// at least the first 64 bytes of the failed request.
+type OfpTableFeaturesFailedCode int32
+
+const (
+	OfpTableFeaturesFailedCode_OFPTFFC_BAD_TABLE    OfpTableFeaturesFailedCode = 0
+	OfpTableFeaturesFailedCode_OFPTFFC_BAD_METADATA OfpTableFeaturesFailedCode = 1
+	OfpTableFeaturesFailedCode_OFPTFFC_BAD_TYPE     OfpTableFeaturesFailedCode = 2
+	OfpTableFeaturesFailedCode_OFPTFFC_BAD_LEN      OfpTableFeaturesFailedCode = 3
+	OfpTableFeaturesFailedCode_OFPTFFC_BAD_ARGUMENT OfpTableFeaturesFailedCode = 4
+	OfpTableFeaturesFailedCode_OFPTFFC_EPERM        OfpTableFeaturesFailedCode = 5
+)
+
+var OfpTableFeaturesFailedCode_name = map[int32]string{
+	0: "OFPTFFC_BAD_TABLE",
+	1: "OFPTFFC_BAD_METADATA",
+	2: "OFPTFFC_BAD_TYPE",
+	3: "OFPTFFC_BAD_LEN",
+	4: "OFPTFFC_BAD_ARGUMENT",
+	5: "OFPTFFC_EPERM",
+}
+var OfpTableFeaturesFailedCode_value = map[string]int32{
+	"OFPTFFC_BAD_TABLE":    0,
+	"OFPTFFC_BAD_METADATA": 1,
+	"OFPTFFC_BAD_TYPE":     2,
+	"OFPTFFC_BAD_LEN":      3,
+	"OFPTFFC_BAD_ARGUMENT": 4,
+	"OFPTFFC_EPERM":        5,
+}
+
+func (x OfpTableFeaturesFailedCode) String() string {
+	return proto.EnumName(OfpTableFeaturesFailedCode_name, int32(x))
+}
+func (OfpTableFeaturesFailedCode) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{44} }
+
+type OfpMultipartType int32
+
+const (
+	// Description of this OpenFlow switch.
+	// The request body is empty.
+	// The reply body is struct ofp_desc.
+	OfpMultipartType_OFPMP_DESC OfpMultipartType = 0
+	// Individual flow statistics.
+	// The request body is struct ofp_flow_stats_request.
+	// The reply body is an array of struct ofp_flow_stats.
+	OfpMultipartType_OFPMP_FLOW OfpMultipartType = 1
+	// Aggregate flow statistics.
+	// The request body is struct ofp_aggregate_stats_request.
+	// The reply body is struct ofp_aggregate_stats_reply.
+	OfpMultipartType_OFPMP_AGGREGATE OfpMultipartType = 2
+	// Flow table statistics.
+	// The request body is empty.
+	// The reply body is an array of struct ofp_table_stats.
+	OfpMultipartType_OFPMP_TABLE OfpMultipartType = 3
+	// Port statistics.
+	// The request body is struct ofp_port_stats_request.
+	// The reply body is an array of struct ofp_port_stats.
+	OfpMultipartType_OFPMP_PORT_STATS OfpMultipartType = 4
+	// Queue statistics for a port
+	// The request body is struct ofp_queue_stats_request.
+	// The reply body is an array of struct ofp_queue_stats
+	OfpMultipartType_OFPMP_QUEUE OfpMultipartType = 5
+	// Group counter statistics.
+	// The request body is struct ofp_group_stats_request.
+	// The reply is an array of struct ofp_group_stats.
+	OfpMultipartType_OFPMP_GROUP OfpMultipartType = 6
+	// Group description.
+	// The request body is empty.
+	// The reply body is an array of struct ofp_group_desc.
+	OfpMultipartType_OFPMP_GROUP_DESC OfpMultipartType = 7
+	// Group features.
+	// The request body is empty.
+	// The reply body is struct ofp_group_features.
+	OfpMultipartType_OFPMP_GROUP_FEATURES OfpMultipartType = 8
+	// Meter statistics.
+	// The request body is struct ofp_meter_multipart_requests.
+	// The reply body is an array of struct ofp_meter_stats.
+	OfpMultipartType_OFPMP_METER OfpMultipartType = 9
+	// Meter configuration.
+	// The request body is struct ofp_meter_multipart_requests.
+	// The reply body is an array of struct ofp_meter_config.
+	OfpMultipartType_OFPMP_METER_CONFIG OfpMultipartType = 10
+	// Meter features.
+	// The request body is empty.
+	// The reply body is struct ofp_meter_features.
+	OfpMultipartType_OFPMP_METER_FEATURES OfpMultipartType = 11
+	// Table features.
+	// The request body is either empty or contains an array of
+	// struct ofp_table_features containing the controller's
+	// desired view of the switch. If the switch is unable to
+	// set the specified view an error is returned.
+	// The reply body is an array of struct ofp_table_features.
+	OfpMultipartType_OFPMP_TABLE_FEATURES OfpMultipartType = 12
+	// Port description.
+	// The request body is empty.
+	// The reply body is an array of struct ofp_port.
+	OfpMultipartType_OFPMP_PORT_DESC OfpMultipartType = 13
+	// Experimenter extension.
+	// The request and reply bodies begin with
+	// struct ofp_experimenter_multipart_header.
+	// The request and reply bodies are otherwise experimenter-defined.
+	OfpMultipartType_OFPMP_EXPERIMENTER OfpMultipartType = 65535
+)
+
+var OfpMultipartType_name = map[int32]string{
+	0:     "OFPMP_DESC",
+	1:     "OFPMP_FLOW",
+	2:     "OFPMP_AGGREGATE",
+	3:     "OFPMP_TABLE",
+	4:     "OFPMP_PORT_STATS",
+	5:     "OFPMP_QUEUE",
+	6:     "OFPMP_GROUP",
+	7:     "OFPMP_GROUP_DESC",
+	8:     "OFPMP_GROUP_FEATURES",
+	9:     "OFPMP_METER",
+	10:    "OFPMP_METER_CONFIG",
+	11:    "OFPMP_METER_FEATURES",
+	12:    "OFPMP_TABLE_FEATURES",
+	13:    "OFPMP_PORT_DESC",
+	65535: "OFPMP_EXPERIMENTER",
+}
+var OfpMultipartType_value = map[string]int32{
+	"OFPMP_DESC":           0,
+	"OFPMP_FLOW":           1,
+	"OFPMP_AGGREGATE":      2,
+	"OFPMP_TABLE":          3,
+	"OFPMP_PORT_STATS":     4,
+	"OFPMP_QUEUE":          5,
+	"OFPMP_GROUP":          6,
+	"OFPMP_GROUP_DESC":     7,
+	"OFPMP_GROUP_FEATURES": 8,
+	"OFPMP_METER":          9,
+	"OFPMP_METER_CONFIG":   10,
+	"OFPMP_METER_FEATURES": 11,
+	"OFPMP_TABLE_FEATURES": 12,
+	"OFPMP_PORT_DESC":      13,
+	"OFPMP_EXPERIMENTER":   65535,
+}
+
+func (x OfpMultipartType) String() string {
+	return proto.EnumName(OfpMultipartType_name, int32(x))
+}
+func (OfpMultipartType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{45} }
+
+type OfpMultipartRequestFlags int32
+
+const (
+	OfpMultipartRequestFlags_OFPMPF_REQ_INVALID OfpMultipartRequestFlags = 0
+	OfpMultipartRequestFlags_OFPMPF_REQ_MORE    OfpMultipartRequestFlags = 1
+)
+
+var OfpMultipartRequestFlags_name = map[int32]string{
+	0: "OFPMPF_REQ_INVALID",
+	1: "OFPMPF_REQ_MORE",
+}
+var OfpMultipartRequestFlags_value = map[string]int32{
+	"OFPMPF_REQ_INVALID": 0,
+	"OFPMPF_REQ_MORE":    1,
+}
+
+func (x OfpMultipartRequestFlags) String() string {
+	return proto.EnumName(OfpMultipartRequestFlags_name, int32(x))
+}
+func (OfpMultipartRequestFlags) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{46} }
+
+type OfpMultipartReplyFlags int32
+
+const (
+	OfpMultipartReplyFlags_OFPMPF_REPLY_INVALID OfpMultipartReplyFlags = 0
+	OfpMultipartReplyFlags_OFPMPF_REPLY_MORE    OfpMultipartReplyFlags = 1
+)
+
+var OfpMultipartReplyFlags_name = map[int32]string{
+	0: "OFPMPF_REPLY_INVALID",
+	1: "OFPMPF_REPLY_MORE",
+}
+var OfpMultipartReplyFlags_value = map[string]int32{
+	"OFPMPF_REPLY_INVALID": 0,
+	"OFPMPF_REPLY_MORE":    1,
+}
+
+func (x OfpMultipartReplyFlags) String() string {
+	return proto.EnumName(OfpMultipartReplyFlags_name, int32(x))
+}
+func (OfpMultipartReplyFlags) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{47} }
+
+// Table Feature property types.
+// Low order bit cleared indicates a property for a regular Flow Entry.
+// Low order bit set indicates a property for the Table-Miss Flow Entry.
+type OfpTableFeaturePropType int32
+
+const (
+	OfpTableFeaturePropType_OFPTFPT_INSTRUCTIONS        OfpTableFeaturePropType = 0
+	OfpTableFeaturePropType_OFPTFPT_INSTRUCTIONS_MISS   OfpTableFeaturePropType = 1
+	OfpTableFeaturePropType_OFPTFPT_NEXT_TABLES         OfpTableFeaturePropType = 2
+	OfpTableFeaturePropType_OFPTFPT_NEXT_TABLES_MISS    OfpTableFeaturePropType = 3
+	OfpTableFeaturePropType_OFPTFPT_WRITE_ACTIONS       OfpTableFeaturePropType = 4
+	OfpTableFeaturePropType_OFPTFPT_WRITE_ACTIONS_MISS  OfpTableFeaturePropType = 5
+	OfpTableFeaturePropType_OFPTFPT_APPLY_ACTIONS       OfpTableFeaturePropType = 6
+	OfpTableFeaturePropType_OFPTFPT_APPLY_ACTIONS_MISS  OfpTableFeaturePropType = 7
+	OfpTableFeaturePropType_OFPTFPT_MATCH               OfpTableFeaturePropType = 8
+	OfpTableFeaturePropType_OFPTFPT_WILDCARDS           OfpTableFeaturePropType = 10
+	OfpTableFeaturePropType_OFPTFPT_WRITE_SETFIELD      OfpTableFeaturePropType = 12
+	OfpTableFeaturePropType_OFPTFPT_WRITE_SETFIELD_MISS OfpTableFeaturePropType = 13
+	OfpTableFeaturePropType_OFPTFPT_APPLY_SETFIELD      OfpTableFeaturePropType = 14
+	OfpTableFeaturePropType_OFPTFPT_APPLY_SETFIELD_MISS OfpTableFeaturePropType = 15
+	OfpTableFeaturePropType_OFPTFPT_EXPERIMENTER        OfpTableFeaturePropType = 65534
+	OfpTableFeaturePropType_OFPTFPT_EXPERIMENTER_MISS   OfpTableFeaturePropType = 65535
+)
+
+var OfpTableFeaturePropType_name = map[int32]string{
+	0:     "OFPTFPT_INSTRUCTIONS",
+	1:     "OFPTFPT_INSTRUCTIONS_MISS",
+	2:     "OFPTFPT_NEXT_TABLES",
+	3:     "OFPTFPT_NEXT_TABLES_MISS",
+	4:     "OFPTFPT_WRITE_ACTIONS",
+	5:     "OFPTFPT_WRITE_ACTIONS_MISS",
+	6:     "OFPTFPT_APPLY_ACTIONS",
+	7:     "OFPTFPT_APPLY_ACTIONS_MISS",
+	8:     "OFPTFPT_MATCH",
+	10:    "OFPTFPT_WILDCARDS",
+	12:    "OFPTFPT_WRITE_SETFIELD",
+	13:    "OFPTFPT_WRITE_SETFIELD_MISS",
+	14:    "OFPTFPT_APPLY_SETFIELD",
+	15:    "OFPTFPT_APPLY_SETFIELD_MISS",
+	65534: "OFPTFPT_EXPERIMENTER",
+	65535: "OFPTFPT_EXPERIMENTER_MISS",
+}
+var OfpTableFeaturePropType_value = map[string]int32{
+	"OFPTFPT_INSTRUCTIONS":        0,
+	"OFPTFPT_INSTRUCTIONS_MISS":   1,
+	"OFPTFPT_NEXT_TABLES":         2,
+	"OFPTFPT_NEXT_TABLES_MISS":    3,
+	"OFPTFPT_WRITE_ACTIONS":       4,
+	"OFPTFPT_WRITE_ACTIONS_MISS":  5,
+	"OFPTFPT_APPLY_ACTIONS":       6,
+	"OFPTFPT_APPLY_ACTIONS_MISS":  7,
+	"OFPTFPT_MATCH":               8,
+	"OFPTFPT_WILDCARDS":           10,
+	"OFPTFPT_WRITE_SETFIELD":      12,
+	"OFPTFPT_WRITE_SETFIELD_MISS": 13,
+	"OFPTFPT_APPLY_SETFIELD":      14,
+	"OFPTFPT_APPLY_SETFIELD_MISS": 15,
+	"OFPTFPT_EXPERIMENTER":        65534,
+	"OFPTFPT_EXPERIMENTER_MISS":   65535,
+}
+
+func (x OfpTableFeaturePropType) String() string {
+	return proto.EnumName(OfpTableFeaturePropType_name, int32(x))
+}
+func (OfpTableFeaturePropType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{48} }
+
+// Group configuration flags
+type OfpGroupCapabilities int32
+
+const (
+	OfpGroupCapabilities_OFPGFC_INVALID         OfpGroupCapabilities = 0
+	OfpGroupCapabilities_OFPGFC_SELECT_WEIGHT   OfpGroupCapabilities = 1
+	OfpGroupCapabilities_OFPGFC_SELECT_LIVENESS OfpGroupCapabilities = 2
+	OfpGroupCapabilities_OFPGFC_CHAINING        OfpGroupCapabilities = 4
+	OfpGroupCapabilities_OFPGFC_CHAINING_CHECKS OfpGroupCapabilities = 8
+)
+
+var OfpGroupCapabilities_name = map[int32]string{
+	0: "OFPGFC_INVALID",
+	1: "OFPGFC_SELECT_WEIGHT",
+	2: "OFPGFC_SELECT_LIVENESS",
+	4: "OFPGFC_CHAINING",
+	8: "OFPGFC_CHAINING_CHECKS",
+}
+var OfpGroupCapabilities_value = map[string]int32{
+	"OFPGFC_INVALID":         0,
+	"OFPGFC_SELECT_WEIGHT":   1,
+	"OFPGFC_SELECT_LIVENESS": 2,
+	"OFPGFC_CHAINING":        4,
+	"OFPGFC_CHAINING_CHECKS": 8,
+}
+
+func (x OfpGroupCapabilities) String() string {
+	return proto.EnumName(OfpGroupCapabilities_name, int32(x))
+}
+func (OfpGroupCapabilities) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{49} }
+
+type OfpQueueProperties int32
+
+const (
+	OfpQueueProperties_OFPQT_INVALID      OfpQueueProperties = 0
+	OfpQueueProperties_OFPQT_MIN_RATE     OfpQueueProperties = 1
+	OfpQueueProperties_OFPQT_MAX_RATE     OfpQueueProperties = 2
+	OfpQueueProperties_OFPQT_EXPERIMENTER OfpQueueProperties = 65535
+)
+
+var OfpQueueProperties_name = map[int32]string{
+	0:     "OFPQT_INVALID",
+	1:     "OFPQT_MIN_RATE",
+	2:     "OFPQT_MAX_RATE",
+	65535: "OFPQT_EXPERIMENTER",
+}
+var OfpQueueProperties_value = map[string]int32{
+	"OFPQT_INVALID":      0,
+	"OFPQT_MIN_RATE":     1,
+	"OFPQT_MAX_RATE":     2,
+	"OFPQT_EXPERIMENTER": 65535,
+}
+
+func (x OfpQueueProperties) String() string {
+	return proto.EnumName(OfpQueueProperties_name, int32(x))
+}
+func (OfpQueueProperties) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{50} }
+
+// Controller roles.
+type OfpControllerRole int32
+
+const (
+	OfpControllerRole_OFPCR_ROLE_NOCHANGE OfpControllerRole = 0
+	OfpControllerRole_OFPCR_ROLE_EQUAL    OfpControllerRole = 1
+	OfpControllerRole_OFPCR_ROLE_MASTER   OfpControllerRole = 2
+	OfpControllerRole_OFPCR_ROLE_SLAVE    OfpControllerRole = 3
+)
+
+var OfpControllerRole_name = map[int32]string{
+	0: "OFPCR_ROLE_NOCHANGE",
+	1: "OFPCR_ROLE_EQUAL",
+	2: "OFPCR_ROLE_MASTER",
+	3: "OFPCR_ROLE_SLAVE",
+}
+var OfpControllerRole_value = map[string]int32{
+	"OFPCR_ROLE_NOCHANGE": 0,
+	"OFPCR_ROLE_EQUAL":    1,
+	"OFPCR_ROLE_MASTER":   2,
+	"OFPCR_ROLE_SLAVE":    3,
+}
+
+func (x OfpControllerRole) String() string {
+	return proto.EnumName(OfpControllerRole_name, int32(x))
+}
+func (OfpControllerRole) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{51} }
+
+// Header on all OpenFlow packets.
+type OfpHeader struct {
+	Version uint32  `protobuf:"varint,1,opt,name=version" json:"version,omitempty"`
+	Type    OfpType `protobuf:"varint,2,opt,name=type,enum=openflow_13.OfpType" json:"type,omitempty"`
+	Xid     uint32  `protobuf:"varint,3,opt,name=xid" json:"xid,omitempty"`
+}
+
+func (m *OfpHeader) Reset()                    { *m = OfpHeader{} }
+func (m *OfpHeader) String() string            { return proto.CompactTextString(m) }
+func (*OfpHeader) ProtoMessage()               {}
+func (*OfpHeader) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
+
+func (m *OfpHeader) GetVersion() uint32 {
+	if m != nil {
+		return m.Version
+	}
+	return 0
+}
+
+func (m *OfpHeader) GetType() OfpType {
+	if m != nil {
+		return m.Type
+	}
+	return OfpType_OFPT_HELLO
+}
+
+func (m *OfpHeader) GetXid() uint32 {
+	if m != nil {
+		return m.Xid
+	}
+	return 0
+}
+
+// Common header for all Hello Elements
+type OfpHelloElemHeader struct {
+	Type OfpHelloElemType `protobuf:"varint,1,opt,name=type,enum=openflow_13.OfpHelloElemType" json:"type,omitempty"`
+	// Types that are valid to be assigned to Element:
+	//	*OfpHelloElemHeader_Versionbitmap
+	Element isOfpHelloElemHeader_Element `protobuf_oneof:"element"`
+}
+
+func (m *OfpHelloElemHeader) Reset()                    { *m = OfpHelloElemHeader{} }
+func (m *OfpHelloElemHeader) String() string            { return proto.CompactTextString(m) }
+func (*OfpHelloElemHeader) ProtoMessage()               {}
+func (*OfpHelloElemHeader) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
+
+type isOfpHelloElemHeader_Element interface {
+	isOfpHelloElemHeader_Element()
+}
+
+type OfpHelloElemHeader_Versionbitmap struct {
+	Versionbitmap *OfpHelloElemVersionbitmap `protobuf:"bytes,2,opt,name=versionbitmap,oneof"`
+}
+
+func (*OfpHelloElemHeader_Versionbitmap) isOfpHelloElemHeader_Element() {}
+
+func (m *OfpHelloElemHeader) GetElement() isOfpHelloElemHeader_Element {
+	if m != nil {
+		return m.Element
+	}
+	return nil
+}
+
+func (m *OfpHelloElemHeader) GetType() OfpHelloElemType {
+	if m != nil {
+		return m.Type
+	}
+	return OfpHelloElemType_OFPHET_INVALID
+}
+
+func (m *OfpHelloElemHeader) GetVersionbitmap() *OfpHelloElemVersionbitmap {
+	if x, ok := m.GetElement().(*OfpHelloElemHeader_Versionbitmap); ok {
+		return x.Versionbitmap
+	}
+	return nil
+}
+
+// XXX_OneofFuncs is for the internal use of the proto package.
+func (*OfpHelloElemHeader) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
+	return _OfpHelloElemHeader_OneofMarshaler, _OfpHelloElemHeader_OneofUnmarshaler, _OfpHelloElemHeader_OneofSizer, []interface{}{
+		(*OfpHelloElemHeader_Versionbitmap)(nil),
+	}
+}
+
+func _OfpHelloElemHeader_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
+	m := msg.(*OfpHelloElemHeader)
+	// element
+	switch x := m.Element.(type) {
+	case *OfpHelloElemHeader_Versionbitmap:
+		b.EncodeVarint(2<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.Versionbitmap); err != nil {
+			return err
+		}
+	case nil:
+	default:
+		return fmt.Errorf("OfpHelloElemHeader.Element has unexpected type %T", x)
+	}
+	return nil
+}
+
+func _OfpHelloElemHeader_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
+	m := msg.(*OfpHelloElemHeader)
+	switch tag {
+	case 2: // element.versionbitmap
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(OfpHelloElemVersionbitmap)
+		err := b.DecodeMessage(msg)
+		m.Element = &OfpHelloElemHeader_Versionbitmap{msg}
+		return true, err
+	default:
+		return false, nil
+	}
+}
+
+func _OfpHelloElemHeader_OneofSizer(msg proto.Message) (n int) {
+	m := msg.(*OfpHelloElemHeader)
+	// element
+	switch x := m.Element.(type) {
+	case *OfpHelloElemHeader_Versionbitmap:
+		s := proto.Size(x.Versionbitmap)
+		n += proto.SizeVarint(2<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case nil:
+	default:
+		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
+	}
+	return n
+}
+
+// Version bitmap Hello Element
+type OfpHelloElemVersionbitmap struct {
+	Bitmaps []uint32 `protobuf:"varint,2,rep,packed,name=bitmaps" json:"bitmaps,omitempty"`
+}
+
+func (m *OfpHelloElemVersionbitmap) Reset()                    { *m = OfpHelloElemVersionbitmap{} }
+func (m *OfpHelloElemVersionbitmap) String() string            { return proto.CompactTextString(m) }
+func (*OfpHelloElemVersionbitmap) ProtoMessage()               {}
+func (*OfpHelloElemVersionbitmap) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }
+
+func (m *OfpHelloElemVersionbitmap) GetBitmaps() []uint32 {
+	if m != nil {
+		return m.Bitmaps
+	}
+	return nil
+}
+
+// OFPT_HELLO.  This message includes zero or more hello elements having
+// variable size. Unknown elements types must be ignored/skipped, to allow
+// for future extensions.
+type OfpHello struct {
+	// Hello element list
+	Elements []*OfpHelloElemHeader `protobuf:"bytes,1,rep,name=elements" json:"elements,omitempty"`
+}
+
+func (m *OfpHello) Reset()                    { *m = OfpHello{} }
+func (m *OfpHello) String() string            { return proto.CompactTextString(m) }
+func (*OfpHello) ProtoMessage()               {}
+func (*OfpHello) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} }
+
+func (m *OfpHello) GetElements() []*OfpHelloElemHeader {
+	if m != nil {
+		return m.Elements
+	}
+	return nil
+}
+
+// Switch configuration.
+type OfpSwitchConfig struct {
+	// ofp_header header;
+	Flags       uint32 `protobuf:"varint,1,opt,name=flags" json:"flags,omitempty"`
+	MissSendLen uint32 `protobuf:"varint,2,opt,name=miss_send_len,json=missSendLen" json:"miss_send_len,omitempty"`
+}
+
+func (m *OfpSwitchConfig) Reset()                    { *m = OfpSwitchConfig{} }
+func (m *OfpSwitchConfig) String() string            { return proto.CompactTextString(m) }
+func (*OfpSwitchConfig) ProtoMessage()               {}
+func (*OfpSwitchConfig) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} }
+
+func (m *OfpSwitchConfig) GetFlags() uint32 {
+	if m != nil {
+		return m.Flags
+	}
+	return 0
+}
+
+func (m *OfpSwitchConfig) GetMissSendLen() uint32 {
+	if m != nil {
+		return m.MissSendLen
+	}
+	return 0
+}
+
+// Configure/Modify behavior of a flow table
+type OfpTableMod struct {
+	// ofp_header header;
+	TableId uint32 `protobuf:"varint,1,opt,name=table_id,json=tableId" json:"table_id,omitempty"`
+	Config  uint32 `protobuf:"varint,2,opt,name=config" json:"config,omitempty"`
+}
+
+func (m *OfpTableMod) Reset()                    { *m = OfpTableMod{} }
+func (m *OfpTableMod) String() string            { return proto.CompactTextString(m) }
+func (*OfpTableMod) ProtoMessage()               {}
+func (*OfpTableMod) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5} }
+
+func (m *OfpTableMod) GetTableId() uint32 {
+	if m != nil {
+		return m.TableId
+	}
+	return 0
+}
+
+func (m *OfpTableMod) GetConfig() uint32 {
+	if m != nil {
+		return m.Config
+	}
+	return 0
+}
+
+// Description of a port
+type OfpPort struct {
+	PortNo uint32   `protobuf:"varint,1,opt,name=port_no,json=portNo" json:"port_no,omitempty"`
+	HwAddr []uint32 `protobuf:"varint,2,rep,packed,name=hw_addr,json=hwAddr" json:"hw_addr,omitempty"`
+	Name   string   `protobuf:"bytes,3,opt,name=name" json:"name,omitempty"`
+	Config uint32   `protobuf:"varint,4,opt,name=config" json:"config,omitempty"`
+	State  uint32   `protobuf:"varint,5,opt,name=state" json:"state,omitempty"`
+	// Bitmaps of OFPPF_* that describe features.  All bits zeroed if
+	// unsupported or unavailable.
+	Curr       uint32 `protobuf:"varint,6,opt,name=curr" json:"curr,omitempty"`
+	Advertised uint32 `protobuf:"varint,7,opt,name=advertised" json:"advertised,omitempty"`
+	Supported  uint32 `protobuf:"varint,8,opt,name=supported" json:"supported,omitempty"`
+	Peer       uint32 `protobuf:"varint,9,opt,name=peer" json:"peer,omitempty"`
+	CurrSpeed  uint32 `protobuf:"varint,10,opt,name=curr_speed,json=currSpeed" json:"curr_speed,omitempty"`
+	MaxSpeed   uint32 `protobuf:"varint,11,opt,name=max_speed,json=maxSpeed" json:"max_speed,omitempty"`
+}
+
+func (m *OfpPort) Reset()                    { *m = OfpPort{} }
+func (m *OfpPort) String() string            { return proto.CompactTextString(m) }
+func (*OfpPort) ProtoMessage()               {}
+func (*OfpPort) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{6} }
+
+func (m *OfpPort) GetPortNo() uint32 {
+	if m != nil {
+		return m.PortNo
+	}
+	return 0
+}
+
+func (m *OfpPort) GetHwAddr() []uint32 {
+	if m != nil {
+		return m.HwAddr
+	}
+	return nil
+}
+
+func (m *OfpPort) GetName() string {
+	if m != nil {
+		return m.Name
+	}
+	return ""
+}
+
+func (m *OfpPort) GetConfig() uint32 {
+	if m != nil {
+		return m.Config
+	}
+	return 0
+}
+
+func (m *OfpPort) GetState() uint32 {
+	if m != nil {
+		return m.State
+	}
+	return 0
+}
+
+func (m *OfpPort) GetCurr() uint32 {
+	if m != nil {
+		return m.Curr
+	}
+	return 0
+}
+
+func (m *OfpPort) GetAdvertised() uint32 {
+	if m != nil {
+		return m.Advertised
+	}
+	return 0
+}
+
+func (m *OfpPort) GetSupported() uint32 {
+	if m != nil {
+		return m.Supported
+	}
+	return 0
+}
+
+func (m *OfpPort) GetPeer() uint32 {
+	if m != nil {
+		return m.Peer
+	}
+	return 0
+}
+
+func (m *OfpPort) GetCurrSpeed() uint32 {
+	if m != nil {
+		return m.CurrSpeed
+	}
+	return 0
+}
+
+func (m *OfpPort) GetMaxSpeed() uint32 {
+	if m != nil {
+		return m.MaxSpeed
+	}
+	return 0
+}
+
+// Switch features.
+type OfpSwitchFeatures struct {
+	// ofp_header header;
+	DatapathId  uint64 `protobuf:"varint,1,opt,name=datapath_id,json=datapathId" json:"datapath_id,omitempty"`
+	NBuffers    uint32 `protobuf:"varint,2,opt,name=n_buffers,json=nBuffers" json:"n_buffers,omitempty"`
+	NTables     uint32 `protobuf:"varint,3,opt,name=n_tables,json=nTables" json:"n_tables,omitempty"`
+	AuxiliaryId uint32 `protobuf:"varint,4,opt,name=auxiliary_id,json=auxiliaryId" json:"auxiliary_id,omitempty"`
+	// Features.
+	Capabilities uint32 `protobuf:"varint,5,opt,name=capabilities" json:"capabilities,omitempty"`
+}
+
+func (m *OfpSwitchFeatures) Reset()                    { *m = OfpSwitchFeatures{} }
+func (m *OfpSwitchFeatures) String() string            { return proto.CompactTextString(m) }
+func (*OfpSwitchFeatures) ProtoMessage()               {}
+func (*OfpSwitchFeatures) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7} }
+
+func (m *OfpSwitchFeatures) GetDatapathId() uint64 {
+	if m != nil {
+		return m.DatapathId
+	}
+	return 0
+}
+
+func (m *OfpSwitchFeatures) GetNBuffers() uint32 {
+	if m != nil {
+		return m.NBuffers
+	}
+	return 0
+}
+
+func (m *OfpSwitchFeatures) GetNTables() uint32 {
+	if m != nil {
+		return m.NTables
+	}
+	return 0
+}
+
+func (m *OfpSwitchFeatures) GetAuxiliaryId() uint32 {
+	if m != nil {
+		return m.AuxiliaryId
+	}
+	return 0
+}
+
+func (m *OfpSwitchFeatures) GetCapabilities() uint32 {
+	if m != nil {
+		return m.Capabilities
+	}
+	return 0
+}
+
+// A physical port has changed in the datapath
+type OfpPortStatus struct {
+	// ofp_header header;
+	Reason OfpPortReason `protobuf:"varint,1,opt,name=reason,enum=openflow_13.OfpPortReason" json:"reason,omitempty"`
+	Desc   *OfpPort      `protobuf:"bytes,2,opt,name=desc" json:"desc,omitempty"`
+}
+
+func (m *OfpPortStatus) Reset()                    { *m = OfpPortStatus{} }
+func (m *OfpPortStatus) String() string            { return proto.CompactTextString(m) }
+func (*OfpPortStatus) ProtoMessage()               {}
+func (*OfpPortStatus) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{8} }
+
+func (m *OfpPortStatus) GetReason() OfpPortReason {
+	if m != nil {
+		return m.Reason
+	}
+	return OfpPortReason_OFPPR_ADD
+}
+
+func (m *OfpPortStatus) GetDesc() *OfpPort {
+	if m != nil {
+		return m.Desc
+	}
+	return nil
+}
+
+// Modify behavior of the physical port
+type OfpPortMod struct {
+	// ofp_header header;
+	PortNo uint32   `protobuf:"varint,1,opt,name=port_no,json=portNo" json:"port_no,omitempty"`
+	HwAddr []uint32 `protobuf:"varint,2,rep,packed,name=hw_addr,json=hwAddr" json:"hw_addr,omitempty"`
+	// The hardware address is not
+	// configurable.  This is used to
+	// sanity-check the request, so it must
+	// be the same as returned in an
+	// ofp_port struct.
+	Config    uint32 `protobuf:"varint,3,opt,name=config" json:"config,omitempty"`
+	Mask      uint32 `protobuf:"varint,4,opt,name=mask" json:"mask,omitempty"`
+	Advertise uint32 `protobuf:"varint,5,opt,name=advertise" json:"advertise,omitempty"`
+}
+
+func (m *OfpPortMod) Reset()                    { *m = OfpPortMod{} }
+func (m *OfpPortMod) String() string            { return proto.CompactTextString(m) }
+func (*OfpPortMod) ProtoMessage()               {}
+func (*OfpPortMod) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{9} }
+
+func (m *OfpPortMod) GetPortNo() uint32 {
+	if m != nil {
+		return m.PortNo
+	}
+	return 0
+}
+
+func (m *OfpPortMod) GetHwAddr() []uint32 {
+	if m != nil {
+		return m.HwAddr
+	}
+	return nil
+}
+
+func (m *OfpPortMod) GetConfig() uint32 {
+	if m != nil {
+		return m.Config
+	}
+	return 0
+}
+
+func (m *OfpPortMod) GetMask() uint32 {
+	if m != nil {
+		return m.Mask
+	}
+	return 0
+}
+
+func (m *OfpPortMod) GetAdvertise() uint32 {
+	if m != nil {
+		return m.Advertise
+	}
+	return 0
+}
+
+// Fields to match against flows
+type OfpMatch struct {
+	Type      OfpMatchType   `protobuf:"varint,1,opt,name=type,enum=openflow_13.OfpMatchType" json:"type,omitempty"`
+	OxmFields []*OfpOxmField `protobuf:"bytes,2,rep,name=oxm_fields,json=oxmFields" json:"oxm_fields,omitempty"`
+}
+
+func (m *OfpMatch) Reset()                    { *m = OfpMatch{} }
+func (m *OfpMatch) String() string            { return proto.CompactTextString(m) }
+func (*OfpMatch) ProtoMessage()               {}
+func (*OfpMatch) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{10} }
+
+func (m *OfpMatch) GetType() OfpMatchType {
+	if m != nil {
+		return m.Type
+	}
+	return OfpMatchType_OFPMT_STANDARD
+}
+
+func (m *OfpMatch) GetOxmFields() []*OfpOxmField {
+	if m != nil {
+		return m.OxmFields
+	}
+	return nil
+}
+
+// OXM Flow match fields
+type OfpOxmField struct {
+	OxmClass OfpOxmClass `protobuf:"varint,1,opt,name=oxm_class,json=oxmClass,enum=openflow_13.OfpOxmClass" json:"oxm_class,omitempty"`
+	// Types that are valid to be assigned to Field:
+	//	*OfpOxmField_OfbField
+	//	*OfpOxmField_ExperimenterField
+	Field isOfpOxmField_Field `protobuf_oneof:"field"`
+}
+
+func (m *OfpOxmField) Reset()                    { *m = OfpOxmField{} }
+func (m *OfpOxmField) String() string            { return proto.CompactTextString(m) }
+func (*OfpOxmField) ProtoMessage()               {}
+func (*OfpOxmField) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{11} }
+
+type isOfpOxmField_Field interface {
+	isOfpOxmField_Field()
+}
+
+type OfpOxmField_OfbField struct {
+	OfbField *OfpOxmOfbField `protobuf:"bytes,4,opt,name=ofb_field,json=ofbField,oneof"`
+}
+type OfpOxmField_ExperimenterField struct {
+	ExperimenterField *OfpOxmExperimenterField `protobuf:"bytes,5,opt,name=experimenter_field,json=experimenterField,oneof"`
+}
+
+func (*OfpOxmField_OfbField) isOfpOxmField_Field()          {}
+func (*OfpOxmField_ExperimenterField) isOfpOxmField_Field() {}
+
+func (m *OfpOxmField) GetField() isOfpOxmField_Field {
+	if m != nil {
+		return m.Field
+	}
+	return nil
+}
+
+func (m *OfpOxmField) GetOxmClass() OfpOxmClass {
+	if m != nil {
+		return m.OxmClass
+	}
+	return OfpOxmClass_OFPXMC_NXM_0
+}
+
+func (m *OfpOxmField) GetOfbField() *OfpOxmOfbField {
+	if x, ok := m.GetField().(*OfpOxmField_OfbField); ok {
+		return x.OfbField
+	}
+	return nil
+}
+
+func (m *OfpOxmField) GetExperimenterField() *OfpOxmExperimenterField {
+	if x, ok := m.GetField().(*OfpOxmField_ExperimenterField); ok {
+		return x.ExperimenterField
+	}
+	return nil
+}
+
+// XXX_OneofFuncs is for the internal use of the proto package.
+func (*OfpOxmField) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
+	return _OfpOxmField_OneofMarshaler, _OfpOxmField_OneofUnmarshaler, _OfpOxmField_OneofSizer, []interface{}{
+		(*OfpOxmField_OfbField)(nil),
+		(*OfpOxmField_ExperimenterField)(nil),
+	}
+}
+
+func _OfpOxmField_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
+	m := msg.(*OfpOxmField)
+	// field
+	switch x := m.Field.(type) {
+	case *OfpOxmField_OfbField:
+		b.EncodeVarint(4<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.OfbField); err != nil {
+			return err
+		}
+	case *OfpOxmField_ExperimenterField:
+		b.EncodeVarint(5<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.ExperimenterField); err != nil {
+			return err
+		}
+	case nil:
+	default:
+		return fmt.Errorf("OfpOxmField.Field has unexpected type %T", x)
+	}
+	return nil
+}
+
+func _OfpOxmField_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
+	m := msg.(*OfpOxmField)
+	switch tag {
+	case 4: // field.ofb_field
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(OfpOxmOfbField)
+		err := b.DecodeMessage(msg)
+		m.Field = &OfpOxmField_OfbField{msg}
+		return true, err
+	case 5: // field.experimenter_field
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(OfpOxmExperimenterField)
+		err := b.DecodeMessage(msg)
+		m.Field = &OfpOxmField_ExperimenterField{msg}
+		return true, err
+	default:
+		return false, nil
+	}
+}
+
+func _OfpOxmField_OneofSizer(msg proto.Message) (n int) {
+	m := msg.(*OfpOxmField)
+	// field
+	switch x := m.Field.(type) {
+	case *OfpOxmField_OfbField:
+		s := proto.Size(x.OfbField)
+		n += proto.SizeVarint(4<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case *OfpOxmField_ExperimenterField:
+		s := proto.Size(x.ExperimenterField)
+		n += proto.SizeVarint(5<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case nil:
+	default:
+		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
+	}
+	return n
+}
+
+// OXM OpenFlow Basic Match Field
+type OfpOxmOfbField struct {
+	Type    OxmOfbFieldTypes `protobuf:"varint,1,opt,name=type,enum=openflow_13.OxmOfbFieldTypes" json:"type,omitempty"`
+	HasMask bool             `protobuf:"varint,2,opt,name=has_mask,json=hasMask" json:"has_mask,omitempty"`
+	// Types that are valid to be assigned to Value:
+	//	*OfpOxmOfbField_Port
+	//	*OfpOxmOfbField_PhysicalPort
+	//	*OfpOxmOfbField_TableMetadata
+	//	*OfpOxmOfbField_EthDst
+	//	*OfpOxmOfbField_EthSrc
+	//	*OfpOxmOfbField_EthType
+	//	*OfpOxmOfbField_VlanVid
+	//	*OfpOxmOfbField_VlanPcp
+	//	*OfpOxmOfbField_IpDscp
+	//	*OfpOxmOfbField_IpEcn
+	//	*OfpOxmOfbField_IpProto
+	//	*OfpOxmOfbField_Ipv4Src
+	//	*OfpOxmOfbField_Ipv4Dst
+	//	*OfpOxmOfbField_TcpSrc
+	//	*OfpOxmOfbField_TcpDst
+	//	*OfpOxmOfbField_UdpSrc
+	//	*OfpOxmOfbField_UdpDst
+	//	*OfpOxmOfbField_SctpSrc
+	//	*OfpOxmOfbField_SctpDst
+	//	*OfpOxmOfbField_Icmpv4Type
+	//	*OfpOxmOfbField_Icmpv4Code
+	//	*OfpOxmOfbField_ArpOp
+	//	*OfpOxmOfbField_ArpSpa
+	//	*OfpOxmOfbField_ArpTpa
+	//	*OfpOxmOfbField_ArpSha
+	//	*OfpOxmOfbField_ArpTha
+	//	*OfpOxmOfbField_Ipv6Src
+	//	*OfpOxmOfbField_Ipv6Dst
+	//	*OfpOxmOfbField_Ipv6Flabel
+	//	*OfpOxmOfbField_Icmpv6Type
+	//	*OfpOxmOfbField_Icmpv6Code
+	//	*OfpOxmOfbField_Ipv6NdTarget
+	//	*OfpOxmOfbField_Ipv6NdSsl
+	//	*OfpOxmOfbField_Ipv6NdTll
+	//	*OfpOxmOfbField_MplsLabel
+	//	*OfpOxmOfbField_MplsTc
+	//	*OfpOxmOfbField_MplsBos
+	//	*OfpOxmOfbField_PbbIsid
+	//	*OfpOxmOfbField_TunnelId
+	//	*OfpOxmOfbField_Ipv6Exthdr
+	Value isOfpOxmOfbField_Value `protobuf_oneof:"value"`
+	// Optional mask values (must be present when has_mask is true
+	//
+	// Types that are valid to be assigned to Mask:
+	//	*OfpOxmOfbField_TableMetadataMask
+	//	*OfpOxmOfbField_EthDstMask
+	//	*OfpOxmOfbField_EthSrcMask
+	//	*OfpOxmOfbField_VlanVidMask
+	//	*OfpOxmOfbField_Ipv4SrcMask
+	//	*OfpOxmOfbField_Ipv4DstMask
+	//	*OfpOxmOfbField_ArpSpaMask
+	//	*OfpOxmOfbField_ArpTpaMask
+	//	*OfpOxmOfbField_Ipv6SrcMask
+	//	*OfpOxmOfbField_Ipv6DstMask
+	//	*OfpOxmOfbField_Ipv6FlabelMask
+	//	*OfpOxmOfbField_PbbIsidMask
+	//	*OfpOxmOfbField_TunnelIdMask
+	//	*OfpOxmOfbField_Ipv6ExthdrMask
+	Mask isOfpOxmOfbField_Mask `protobuf_oneof:"mask"`
+}
+
+func (m *OfpOxmOfbField) Reset()                    { *m = OfpOxmOfbField{} }
+func (m *OfpOxmOfbField) String() string            { return proto.CompactTextString(m) }
+func (*OfpOxmOfbField) ProtoMessage()               {}
+func (*OfpOxmOfbField) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{12} }
+
+type isOfpOxmOfbField_Value interface {
+	isOfpOxmOfbField_Value()
+}
+type isOfpOxmOfbField_Mask interface {
+	isOfpOxmOfbField_Mask()
+}
+
+type OfpOxmOfbField_Port struct {
+	Port uint32 `protobuf:"varint,3,opt,name=port,oneof"`
+}
+type OfpOxmOfbField_PhysicalPort struct {
+	PhysicalPort uint32 `protobuf:"varint,4,opt,name=physical_port,json=physicalPort,oneof"`
+}
+type OfpOxmOfbField_TableMetadata struct {
+	TableMetadata uint64 `protobuf:"varint,5,opt,name=table_metadata,json=tableMetadata,oneof"`
+}
+type OfpOxmOfbField_EthDst struct {
+	EthDst []byte `protobuf:"bytes,6,opt,name=eth_dst,json=ethDst,proto3,oneof"`
+}
+type OfpOxmOfbField_EthSrc struct {
+	EthSrc []byte `protobuf:"bytes,7,opt,name=eth_src,json=ethSrc,proto3,oneof"`
+}
+type OfpOxmOfbField_EthType struct {
+	EthType uint32 `protobuf:"varint,8,opt,name=eth_type,json=ethType,oneof"`
+}
+type OfpOxmOfbField_VlanVid struct {
+	VlanVid uint32 `protobuf:"varint,9,opt,name=vlan_vid,json=vlanVid,oneof"`
+}
+type OfpOxmOfbField_VlanPcp struct {
+	VlanPcp uint32 `protobuf:"varint,10,opt,name=vlan_pcp,json=vlanPcp,oneof"`
+}
+type OfpOxmOfbField_IpDscp struct {
+	IpDscp uint32 `protobuf:"varint,11,opt,name=ip_dscp,json=ipDscp,oneof"`
+}
+type OfpOxmOfbField_IpEcn struct {
+	IpEcn uint32 `protobuf:"varint,12,opt,name=ip_ecn,json=ipEcn,oneof"`
+}
+type OfpOxmOfbField_IpProto struct {
+	IpProto uint32 `protobuf:"varint,13,opt,name=ip_proto,json=ipProto,oneof"`
+}
+type OfpOxmOfbField_Ipv4Src struct {
+	Ipv4Src uint32 `protobuf:"varint,14,opt,name=ipv4_src,json=ipv4Src,oneof"`
+}
+type OfpOxmOfbField_Ipv4Dst struct {
+	Ipv4Dst uint32 `protobuf:"varint,15,opt,name=ipv4_dst,json=ipv4Dst,oneof"`
+}
+type OfpOxmOfbField_TcpSrc struct {
+	TcpSrc uint32 `protobuf:"varint,16,opt,name=tcp_src,json=tcpSrc,oneof"`
+}
+type OfpOxmOfbField_TcpDst struct {
+	TcpDst uint32 `protobuf:"varint,17,opt,name=tcp_dst,json=tcpDst,oneof"`
+}
+type OfpOxmOfbField_UdpSrc struct {
+	UdpSrc uint32 `protobuf:"varint,18,opt,name=udp_src,json=udpSrc,oneof"`
+}
+type OfpOxmOfbField_UdpDst struct {
+	UdpDst uint32 `protobuf:"varint,19,opt,name=udp_dst,json=udpDst,oneof"`
+}
+type OfpOxmOfbField_SctpSrc struct {
+	SctpSrc uint32 `protobuf:"varint,20,opt,name=sctp_src,json=sctpSrc,oneof"`
+}
+type OfpOxmOfbField_SctpDst struct {
+	SctpDst uint32 `protobuf:"varint,21,opt,name=sctp_dst,json=sctpDst,oneof"`
+}
+type OfpOxmOfbField_Icmpv4Type struct {
+	Icmpv4Type uint32 `protobuf:"varint,22,opt,name=icmpv4_type,json=icmpv4Type,oneof"`
+}
+type OfpOxmOfbField_Icmpv4Code struct {
+	Icmpv4Code uint32 `protobuf:"varint,23,opt,name=icmpv4_code,json=icmpv4Code,oneof"`
+}
+type OfpOxmOfbField_ArpOp struct {
+	ArpOp uint32 `protobuf:"varint,24,opt,name=arp_op,json=arpOp,oneof"`
+}
+type OfpOxmOfbField_ArpSpa struct {
+	ArpSpa uint32 `protobuf:"varint,25,opt,name=arp_spa,json=arpSpa,oneof"`
+}
+type OfpOxmOfbField_ArpTpa struct {
+	ArpTpa uint32 `protobuf:"varint,26,opt,name=arp_tpa,json=arpTpa,oneof"`
+}
+type OfpOxmOfbField_ArpSha struct {
+	ArpSha []byte `protobuf:"bytes,27,opt,name=arp_sha,json=arpSha,proto3,oneof"`
+}
+type OfpOxmOfbField_ArpTha struct {
+	ArpTha []byte `protobuf:"bytes,28,opt,name=arp_tha,json=arpTha,proto3,oneof"`
+}
+type OfpOxmOfbField_Ipv6Src struct {
+	Ipv6Src []byte `protobuf:"bytes,29,opt,name=ipv6_src,json=ipv6Src,proto3,oneof"`
+}
+type OfpOxmOfbField_Ipv6Dst struct {
+	Ipv6Dst []byte `protobuf:"bytes,30,opt,name=ipv6_dst,json=ipv6Dst,proto3,oneof"`
+}
+type OfpOxmOfbField_Ipv6Flabel struct {
+	Ipv6Flabel uint32 `protobuf:"varint,31,opt,name=ipv6_flabel,json=ipv6Flabel,oneof"`
+}
+type OfpOxmOfbField_Icmpv6Type struct {
+	Icmpv6Type uint32 `protobuf:"varint,32,opt,name=icmpv6_type,json=icmpv6Type,oneof"`
+}
+type OfpOxmOfbField_Icmpv6Code struct {
+	Icmpv6Code uint32 `protobuf:"varint,33,opt,name=icmpv6_code,json=icmpv6Code,oneof"`
+}
+type OfpOxmOfbField_Ipv6NdTarget struct {
+	Ipv6NdTarget []byte `protobuf:"bytes,34,opt,name=ipv6_nd_target,json=ipv6NdTarget,proto3,oneof"`
+}
+type OfpOxmOfbField_Ipv6NdSsl struct {
+	Ipv6NdSsl []byte `protobuf:"bytes,35,opt,name=ipv6_nd_ssl,json=ipv6NdSsl,proto3,oneof"`
+}
+type OfpOxmOfbField_Ipv6NdTll struct {
+	Ipv6NdTll []byte `protobuf:"bytes,36,opt,name=ipv6_nd_tll,json=ipv6NdTll,proto3,oneof"`
+}
+type OfpOxmOfbField_MplsLabel struct {
+	MplsLabel uint32 `protobuf:"varint,37,opt,name=mpls_label,json=mplsLabel,oneof"`
+}
+type OfpOxmOfbField_MplsTc struct {
+	MplsTc uint32 `protobuf:"varint,38,opt,name=mpls_tc,json=mplsTc,oneof"`
+}
+type OfpOxmOfbField_MplsBos struct {
+	MplsBos uint32 `protobuf:"varint,39,opt,name=mpls_bos,json=mplsBos,oneof"`
+}
+type OfpOxmOfbField_PbbIsid struct {
+	PbbIsid uint32 `protobuf:"varint,40,opt,name=pbb_isid,json=pbbIsid,oneof"`
+}
+type OfpOxmOfbField_TunnelId struct {
+	TunnelId uint64 `protobuf:"varint,41,opt,name=tunnel_id,json=tunnelId,oneof"`
+}
+type OfpOxmOfbField_Ipv6Exthdr struct {
+	Ipv6Exthdr uint32 `protobuf:"varint,42,opt,name=ipv6_exthdr,json=ipv6Exthdr,oneof"`
+}
+type OfpOxmOfbField_TableMetadataMask struct {
+	TableMetadataMask uint64 `protobuf:"varint,105,opt,name=table_metadata_mask,json=tableMetadataMask,oneof"`
+}
+type OfpOxmOfbField_EthDstMask struct {
+	EthDstMask []byte `protobuf:"bytes,106,opt,name=eth_dst_mask,json=ethDstMask,proto3,oneof"`
+}
+type OfpOxmOfbField_EthSrcMask struct {
+	EthSrcMask []byte `protobuf:"bytes,107,opt,name=eth_src_mask,json=ethSrcMask,proto3,oneof"`
+}
+type OfpOxmOfbField_VlanVidMask struct {
+	VlanVidMask uint32 `protobuf:"varint,109,opt,name=vlan_vid_mask,json=vlanVidMask,oneof"`
+}
+type OfpOxmOfbField_Ipv4SrcMask struct {
+	Ipv4SrcMask uint32 `protobuf:"varint,114,opt,name=ipv4_src_mask,json=ipv4SrcMask,oneof"`
+}
+type OfpOxmOfbField_Ipv4DstMask struct {
+	Ipv4DstMask uint32 `protobuf:"varint,115,opt,name=ipv4_dst_mask,json=ipv4DstMask,oneof"`
+}
+type OfpOxmOfbField_ArpSpaMask struct {
+	ArpSpaMask uint32 `protobuf:"varint,125,opt,name=arp_spa_mask,json=arpSpaMask,oneof"`
+}
+type OfpOxmOfbField_ArpTpaMask struct {
+	ArpTpaMask uint32 `protobuf:"varint,126,opt,name=arp_tpa_mask,json=arpTpaMask,oneof"`
+}
+type OfpOxmOfbField_Ipv6SrcMask struct {
+	Ipv6SrcMask []byte `protobuf:"bytes,129,opt,name=ipv6_src_mask,json=ipv6SrcMask,proto3,oneof"`
+}
+type OfpOxmOfbField_Ipv6DstMask struct {
+	Ipv6DstMask []byte `protobuf:"bytes,130,opt,name=ipv6_dst_mask,json=ipv6DstMask,proto3,oneof"`
+}
+type OfpOxmOfbField_Ipv6FlabelMask struct {
+	Ipv6FlabelMask uint32 `protobuf:"varint,131,opt,name=ipv6_flabel_mask,json=ipv6FlabelMask,oneof"`
+}
+type OfpOxmOfbField_PbbIsidMask struct {
+	PbbIsidMask uint32 `protobuf:"varint,140,opt,name=pbb_isid_mask,json=pbbIsidMask,oneof"`
+}
+type OfpOxmOfbField_TunnelIdMask struct {
+	TunnelIdMask uint64 `protobuf:"varint,141,opt,name=tunnel_id_mask,json=tunnelIdMask,oneof"`
+}
+type OfpOxmOfbField_Ipv6ExthdrMask struct {
+	Ipv6ExthdrMask uint32 `protobuf:"varint,142,opt,name=ipv6_exthdr_mask,json=ipv6ExthdrMask,oneof"`
+}
+
+func (*OfpOxmOfbField_Port) isOfpOxmOfbField_Value()             {}
+func (*OfpOxmOfbField_PhysicalPort) isOfpOxmOfbField_Value()     {}
+func (*OfpOxmOfbField_TableMetadata) isOfpOxmOfbField_Value()    {}
+func (*OfpOxmOfbField_EthDst) isOfpOxmOfbField_Value()           {}
+func (*OfpOxmOfbField_EthSrc) isOfpOxmOfbField_Value()           {}
+func (*OfpOxmOfbField_EthType) isOfpOxmOfbField_Value()          {}
+func (*OfpOxmOfbField_VlanVid) isOfpOxmOfbField_Value()          {}
+func (*OfpOxmOfbField_VlanPcp) isOfpOxmOfbField_Value()          {}
+func (*OfpOxmOfbField_IpDscp) isOfpOxmOfbField_Value()           {}
+func (*OfpOxmOfbField_IpEcn) isOfpOxmOfbField_Value()            {}
+func (*OfpOxmOfbField_IpProto) isOfpOxmOfbField_Value()          {}
+func (*OfpOxmOfbField_Ipv4Src) isOfpOxmOfbField_Value()          {}
+func (*OfpOxmOfbField_Ipv4Dst) isOfpOxmOfbField_Value()          {}
+func (*OfpOxmOfbField_TcpSrc) isOfpOxmOfbField_Value()           {}
+func (*OfpOxmOfbField_TcpDst) isOfpOxmOfbField_Value()           {}
+func (*OfpOxmOfbField_UdpSrc) isOfpOxmOfbField_Value()           {}
+func (*OfpOxmOfbField_UdpDst) isOfpOxmOfbField_Value()           {}
+func (*OfpOxmOfbField_SctpSrc) isOfpOxmOfbField_Value()          {}
+func (*OfpOxmOfbField_SctpDst) isOfpOxmOfbField_Value()          {}
+func (*OfpOxmOfbField_Icmpv4Type) isOfpOxmOfbField_Value()       {}
+func (*OfpOxmOfbField_Icmpv4Code) isOfpOxmOfbField_Value()       {}
+func (*OfpOxmOfbField_ArpOp) isOfpOxmOfbField_Value()            {}
+func (*OfpOxmOfbField_ArpSpa) isOfpOxmOfbField_Value()           {}
+func (*OfpOxmOfbField_ArpTpa) isOfpOxmOfbField_Value()           {}
+func (*OfpOxmOfbField_ArpSha) isOfpOxmOfbField_Value()           {}
+func (*OfpOxmOfbField_ArpTha) isOfpOxmOfbField_Value()           {}
+func (*OfpOxmOfbField_Ipv6Src) isOfpOxmOfbField_Value()          {}
+func (*OfpOxmOfbField_Ipv6Dst) isOfpOxmOfbField_Value()          {}
+func (*OfpOxmOfbField_Ipv6Flabel) isOfpOxmOfbField_Value()       {}
+func (*OfpOxmOfbField_Icmpv6Type) isOfpOxmOfbField_Value()       {}
+func (*OfpOxmOfbField_Icmpv6Code) isOfpOxmOfbField_Value()       {}
+func (*OfpOxmOfbField_Ipv6NdTarget) isOfpOxmOfbField_Value()     {}
+func (*OfpOxmOfbField_Ipv6NdSsl) isOfpOxmOfbField_Value()        {}
+func (*OfpOxmOfbField_Ipv6NdTll) isOfpOxmOfbField_Value()        {}
+func (*OfpOxmOfbField_MplsLabel) isOfpOxmOfbField_Value()        {}
+func (*OfpOxmOfbField_MplsTc) isOfpOxmOfbField_Value()           {}
+func (*OfpOxmOfbField_MplsBos) isOfpOxmOfbField_Value()          {}
+func (*OfpOxmOfbField_PbbIsid) isOfpOxmOfbField_Value()          {}
+func (*OfpOxmOfbField_TunnelId) isOfpOxmOfbField_Value()         {}
+func (*OfpOxmOfbField_Ipv6Exthdr) isOfpOxmOfbField_Value()       {}
+func (*OfpOxmOfbField_TableMetadataMask) isOfpOxmOfbField_Mask() {}
+func (*OfpOxmOfbField_EthDstMask) isOfpOxmOfbField_Mask()        {}
+func (*OfpOxmOfbField_EthSrcMask) isOfpOxmOfbField_Mask()        {}
+func (*OfpOxmOfbField_VlanVidMask) isOfpOxmOfbField_Mask()       {}
+func (*OfpOxmOfbField_Ipv4SrcMask) isOfpOxmOfbField_Mask()       {}
+func (*OfpOxmOfbField_Ipv4DstMask) isOfpOxmOfbField_Mask()       {}
+func (*OfpOxmOfbField_ArpSpaMask) isOfpOxmOfbField_Mask()        {}
+func (*OfpOxmOfbField_ArpTpaMask) isOfpOxmOfbField_Mask()        {}
+func (*OfpOxmOfbField_Ipv6SrcMask) isOfpOxmOfbField_Mask()       {}
+func (*OfpOxmOfbField_Ipv6DstMask) isOfpOxmOfbField_Mask()       {}
+func (*OfpOxmOfbField_Ipv6FlabelMask) isOfpOxmOfbField_Mask()    {}
+func (*OfpOxmOfbField_PbbIsidMask) isOfpOxmOfbField_Mask()       {}
+func (*OfpOxmOfbField_TunnelIdMask) isOfpOxmOfbField_Mask()      {}
+func (*OfpOxmOfbField_Ipv6ExthdrMask) isOfpOxmOfbField_Mask()    {}
+
+func (m *OfpOxmOfbField) GetValue() isOfpOxmOfbField_Value {
+	if m != nil {
+		return m.Value
+	}
+	return nil
+}
+func (m *OfpOxmOfbField) GetMask() isOfpOxmOfbField_Mask {
+	if m != nil {
+		return m.Mask
+	}
+	return nil
+}
+
+func (m *OfpOxmOfbField) GetType() OxmOfbFieldTypes {
+	if m != nil {
+		return m.Type
+	}
+	return OxmOfbFieldTypes_OFPXMT_OFB_IN_PORT
+}
+
+func (m *OfpOxmOfbField) GetHasMask() bool {
+	if m != nil {
+		return m.HasMask
+	}
+	return false
+}
+
+func (m *OfpOxmOfbField) GetPort() uint32 {
+	if x, ok := m.GetValue().(*OfpOxmOfbField_Port); ok {
+		return x.Port
+	}
+	return 0
+}
+
+func (m *OfpOxmOfbField) GetPhysicalPort() uint32 {
+	if x, ok := m.GetValue().(*OfpOxmOfbField_PhysicalPort); ok {
+		return x.PhysicalPort
+	}
+	return 0
+}
+
+func (m *OfpOxmOfbField) GetTableMetadata() uint64 {
+	if x, ok := m.GetValue().(*OfpOxmOfbField_TableMetadata); ok {
+		return x.TableMetadata
+	}
+	return 0
+}
+
+func (m *OfpOxmOfbField) GetEthDst() []byte {
+	if x, ok := m.GetValue().(*OfpOxmOfbField_EthDst); ok {
+		return x.EthDst
+	}
+	return nil
+}
+
+func (m *OfpOxmOfbField) GetEthSrc() []byte {
+	if x, ok := m.GetValue().(*OfpOxmOfbField_EthSrc); ok {
+		return x.EthSrc
+	}
+	return nil
+}
+
+func (m *OfpOxmOfbField) GetEthType() uint32 {
+	if x, ok := m.GetValue().(*OfpOxmOfbField_EthType); ok {
+		return x.EthType
+	}
+	return 0
+}
+
+func (m *OfpOxmOfbField) GetVlanVid() uint32 {
+	if x, ok := m.GetValue().(*OfpOxmOfbField_VlanVid); ok {
+		return x.VlanVid
+	}
+	return 0
+}
+
+func (m *OfpOxmOfbField) GetVlanPcp() uint32 {
+	if x, ok := m.GetValue().(*OfpOxmOfbField_VlanPcp); ok {
+		return x.VlanPcp
+	}
+	return 0
+}
+
+func (m *OfpOxmOfbField) GetIpDscp() uint32 {
+	if x, ok := m.GetValue().(*OfpOxmOfbField_IpDscp); ok {
+		return x.IpDscp
+	}
+	return 0
+}
+
+func (m *OfpOxmOfbField) GetIpEcn() uint32 {
+	if x, ok := m.GetValue().(*OfpOxmOfbField_IpEcn); ok {
+		return x.IpEcn
+	}
+	return 0
+}
+
+func (m *OfpOxmOfbField) GetIpProto() uint32 {
+	if x, ok := m.GetValue().(*OfpOxmOfbField_IpProto); ok {
+		return x.IpProto
+	}
+	return 0
+}
+
+func (m *OfpOxmOfbField) GetIpv4Src() uint32 {
+	if x, ok := m.GetValue().(*OfpOxmOfbField_Ipv4Src); ok {
+		return x.Ipv4Src
+	}
+	return 0
+}
+
+func (m *OfpOxmOfbField) GetIpv4Dst() uint32 {
+	if x, ok := m.GetValue().(*OfpOxmOfbField_Ipv4Dst); ok {
+		return x.Ipv4Dst
+	}
+	return 0
+}
+
+func (m *OfpOxmOfbField) GetTcpSrc() uint32 {
+	if x, ok := m.GetValue().(*OfpOxmOfbField_TcpSrc); ok {
+		return x.TcpSrc
+	}
+	return 0
+}
+
+func (m *OfpOxmOfbField) GetTcpDst() uint32 {
+	if x, ok := m.GetValue().(*OfpOxmOfbField_TcpDst); ok {
+		return x.TcpDst
+	}
+	return 0
+}
+
+func (m *OfpOxmOfbField) GetUdpSrc() uint32 {
+	if x, ok := m.GetValue().(*OfpOxmOfbField_UdpSrc); ok {
+		return x.UdpSrc
+	}
+	return 0
+}
+
+func (m *OfpOxmOfbField) GetUdpDst() uint32 {
+	if x, ok := m.GetValue().(*OfpOxmOfbField_UdpDst); ok {
+		return x.UdpDst
+	}
+	return 0
+}
+
+func (m *OfpOxmOfbField) GetSctpSrc() uint32 {
+	if x, ok := m.GetValue().(*OfpOxmOfbField_SctpSrc); ok {
+		return x.SctpSrc
+	}
+	return 0
+}
+
+func (m *OfpOxmOfbField) GetSctpDst() uint32 {
+	if x, ok := m.GetValue().(*OfpOxmOfbField_SctpDst); ok {
+		return x.SctpDst
+	}
+	return 0
+}
+
+func (m *OfpOxmOfbField) GetIcmpv4Type() uint32 {
+	if x, ok := m.GetValue().(*OfpOxmOfbField_Icmpv4Type); ok {
+		return x.Icmpv4Type
+	}
+	return 0
+}
+
+func (m *OfpOxmOfbField) GetIcmpv4Code() uint32 {
+	if x, ok := m.GetValue().(*OfpOxmOfbField_Icmpv4Code); ok {
+		return x.Icmpv4Code
+	}
+	return 0
+}
+
+func (m *OfpOxmOfbField) GetArpOp() uint32 {
+	if x, ok := m.GetValue().(*OfpOxmOfbField_ArpOp); ok {
+		return x.ArpOp
+	}
+	return 0
+}
+
+func (m *OfpOxmOfbField) GetArpSpa() uint32 {
+	if x, ok := m.GetValue().(*OfpOxmOfbField_ArpSpa); ok {
+		return x.ArpSpa
+	}
+	return 0
+}
+
+func (m *OfpOxmOfbField) GetArpTpa() uint32 {
+	if x, ok := m.GetValue().(*OfpOxmOfbField_ArpTpa); ok {
+		return x.ArpTpa
+	}
+	return 0
+}
+
+func (m *OfpOxmOfbField) GetArpSha() []byte {
+	if x, ok := m.GetValue().(*OfpOxmOfbField_ArpSha); ok {
+		return x.ArpSha
+	}
+	return nil
+}
+
+func (m *OfpOxmOfbField) GetArpTha() []byte {
+	if x, ok := m.GetValue().(*OfpOxmOfbField_ArpTha); ok {
+		return x.ArpTha
+	}
+	return nil
+}
+
+func (m *OfpOxmOfbField) GetIpv6Src() []byte {
+	if x, ok := m.GetValue().(*OfpOxmOfbField_Ipv6Src); ok {
+		return x.Ipv6Src
+	}
+	return nil
+}
+
+func (m *OfpOxmOfbField) GetIpv6Dst() []byte {
+	if x, ok := m.GetValue().(*OfpOxmOfbField_Ipv6Dst); ok {
+		return x.Ipv6Dst
+	}
+	return nil
+}
+
+func (m *OfpOxmOfbField) GetIpv6Flabel() uint32 {
+	if x, ok := m.GetValue().(*OfpOxmOfbField_Ipv6Flabel); ok {
+		return x.Ipv6Flabel
+	}
+	return 0
+}
+
+func (m *OfpOxmOfbField) GetIcmpv6Type() uint32 {
+	if x, ok := m.GetValue().(*OfpOxmOfbField_Icmpv6Type); ok {
+		return x.Icmpv6Type
+	}
+	return 0
+}
+
+func (m *OfpOxmOfbField) GetIcmpv6Code() uint32 {
+	if x, ok := m.GetValue().(*OfpOxmOfbField_Icmpv6Code); ok {
+		return x.Icmpv6Code
+	}
+	return 0
+}
+
+func (m *OfpOxmOfbField) GetIpv6NdTarget() []byte {
+	if x, ok := m.GetValue().(*OfpOxmOfbField_Ipv6NdTarget); ok {
+		return x.Ipv6NdTarget
+	}
+	return nil
+}
+
+func (m *OfpOxmOfbField) GetIpv6NdSsl() []byte {
+	if x, ok := m.GetValue().(*OfpOxmOfbField_Ipv6NdSsl); ok {
+		return x.Ipv6NdSsl
+	}
+	return nil
+}
+
+func (m *OfpOxmOfbField) GetIpv6NdTll() []byte {
+	if x, ok := m.GetValue().(*OfpOxmOfbField_Ipv6NdTll); ok {
+		return x.Ipv6NdTll
+	}
+	return nil
+}
+
+func (m *OfpOxmOfbField) GetMplsLabel() uint32 {
+	if x, ok := m.GetValue().(*OfpOxmOfbField_MplsLabel); ok {
+		return x.MplsLabel
+	}
+	return 0
+}
+
+func (m *OfpOxmOfbField) GetMplsTc() uint32 {
+	if x, ok := m.GetValue().(*OfpOxmOfbField_MplsTc); ok {
+		return x.MplsTc
+	}
+	return 0
+}
+
+func (m *OfpOxmOfbField) GetMplsBos() uint32 {
+	if x, ok := m.GetValue().(*OfpOxmOfbField_MplsBos); ok {
+		return x.MplsBos
+	}
+	return 0
+}
+
+func (m *OfpOxmOfbField) GetPbbIsid() uint32 {
+	if x, ok := m.GetValue().(*OfpOxmOfbField_PbbIsid); ok {
+		return x.PbbIsid
+	}
+	return 0
+}
+
+func (m *OfpOxmOfbField) GetTunnelId() uint64 {
+	if x, ok := m.GetValue().(*OfpOxmOfbField_TunnelId); ok {
+		return x.TunnelId
+	}
+	return 0
+}
+
+func (m *OfpOxmOfbField) GetIpv6Exthdr() uint32 {
+	if x, ok := m.GetValue().(*OfpOxmOfbField_Ipv6Exthdr); ok {
+		return x.Ipv6Exthdr
+	}
+	return 0
+}
+
+func (m *OfpOxmOfbField) GetTableMetadataMask() uint64 {
+	if x, ok := m.GetMask().(*OfpOxmOfbField_TableMetadataMask); ok {
+		return x.TableMetadataMask
+	}
+	return 0
+}
+
+func (m *OfpOxmOfbField) GetEthDstMask() []byte {
+	if x, ok := m.GetMask().(*OfpOxmOfbField_EthDstMask); ok {
+		return x.EthDstMask
+	}
+	return nil
+}
+
+func (m *OfpOxmOfbField) GetEthSrcMask() []byte {
+	if x, ok := m.GetMask().(*OfpOxmOfbField_EthSrcMask); ok {
+		return x.EthSrcMask
+	}
+	return nil
+}
+
+func (m *OfpOxmOfbField) GetVlanVidMask() uint32 {
+	if x, ok := m.GetMask().(*OfpOxmOfbField_VlanVidMask); ok {
+		return x.VlanVidMask
+	}
+	return 0
+}
+
+func (m *OfpOxmOfbField) GetIpv4SrcMask() uint32 {
+	if x, ok := m.GetMask().(*OfpOxmOfbField_Ipv4SrcMask); ok {
+		return x.Ipv4SrcMask
+	}
+	return 0
+}
+
+func (m *OfpOxmOfbField) GetIpv4DstMask() uint32 {
+	if x, ok := m.GetMask().(*OfpOxmOfbField_Ipv4DstMask); ok {
+		return x.Ipv4DstMask
+	}
+	return 0
+}
+
+func (m *OfpOxmOfbField) GetArpSpaMask() uint32 {
+	if x, ok := m.GetMask().(*OfpOxmOfbField_ArpSpaMask); ok {
+		return x.ArpSpaMask
+	}
+	return 0
+}
+
+func (m *OfpOxmOfbField) GetArpTpaMask() uint32 {
+	if x, ok := m.GetMask().(*OfpOxmOfbField_ArpTpaMask); ok {
+		return x.ArpTpaMask
+	}
+	return 0
+}
+
+func (m *OfpOxmOfbField) GetIpv6SrcMask() []byte {
+	if x, ok := m.GetMask().(*OfpOxmOfbField_Ipv6SrcMask); ok {
+		return x.Ipv6SrcMask
+	}
+	return nil
+}
+
+func (m *OfpOxmOfbField) GetIpv6DstMask() []byte {
+	if x, ok := m.GetMask().(*OfpOxmOfbField_Ipv6DstMask); ok {
+		return x.Ipv6DstMask
+	}
+	return nil
+}
+
+func (m *OfpOxmOfbField) GetIpv6FlabelMask() uint32 {
+	if x, ok := m.GetMask().(*OfpOxmOfbField_Ipv6FlabelMask); ok {
+		return x.Ipv6FlabelMask
+	}
+	return 0
+}
+
+func (m *OfpOxmOfbField) GetPbbIsidMask() uint32 {
+	if x, ok := m.GetMask().(*OfpOxmOfbField_PbbIsidMask); ok {
+		return x.PbbIsidMask
+	}
+	return 0
+}
+
+func (m *OfpOxmOfbField) GetTunnelIdMask() uint64 {
+	if x, ok := m.GetMask().(*OfpOxmOfbField_TunnelIdMask); ok {
+		return x.TunnelIdMask
+	}
+	return 0
+}
+
+func (m *OfpOxmOfbField) GetIpv6ExthdrMask() uint32 {
+	if x, ok := m.GetMask().(*OfpOxmOfbField_Ipv6ExthdrMask); ok {
+		return x.Ipv6ExthdrMask
+	}
+	return 0
+}
+
+// XXX_OneofFuncs is for the internal use of the proto package.
+func (*OfpOxmOfbField) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
+	return _OfpOxmOfbField_OneofMarshaler, _OfpOxmOfbField_OneofUnmarshaler, _OfpOxmOfbField_OneofSizer, []interface{}{
+		(*OfpOxmOfbField_Port)(nil),
+		(*OfpOxmOfbField_PhysicalPort)(nil),
+		(*OfpOxmOfbField_TableMetadata)(nil),
+		(*OfpOxmOfbField_EthDst)(nil),
+		(*OfpOxmOfbField_EthSrc)(nil),
+		(*OfpOxmOfbField_EthType)(nil),
+		(*OfpOxmOfbField_VlanVid)(nil),
+		(*OfpOxmOfbField_VlanPcp)(nil),
+		(*OfpOxmOfbField_IpDscp)(nil),
+		(*OfpOxmOfbField_IpEcn)(nil),
+		(*OfpOxmOfbField_IpProto)(nil),
+		(*OfpOxmOfbField_Ipv4Src)(nil),
+		(*OfpOxmOfbField_Ipv4Dst)(nil),
+		(*OfpOxmOfbField_TcpSrc)(nil),
+		(*OfpOxmOfbField_TcpDst)(nil),
+		(*OfpOxmOfbField_UdpSrc)(nil),
+		(*OfpOxmOfbField_UdpDst)(nil),
+		(*OfpOxmOfbField_SctpSrc)(nil),
+		(*OfpOxmOfbField_SctpDst)(nil),
+		(*OfpOxmOfbField_Icmpv4Type)(nil),
+		(*OfpOxmOfbField_Icmpv4Code)(nil),
+		(*OfpOxmOfbField_ArpOp)(nil),
+		(*OfpOxmOfbField_ArpSpa)(nil),
+		(*OfpOxmOfbField_ArpTpa)(nil),
+		(*OfpOxmOfbField_ArpSha)(nil),
+		(*OfpOxmOfbField_ArpTha)(nil),
+		(*OfpOxmOfbField_Ipv6Src)(nil),
+		(*OfpOxmOfbField_Ipv6Dst)(nil),
+		(*OfpOxmOfbField_Ipv6Flabel)(nil),
+		(*OfpOxmOfbField_Icmpv6Type)(nil),
+		(*OfpOxmOfbField_Icmpv6Code)(nil),
+		(*OfpOxmOfbField_Ipv6NdTarget)(nil),
+		(*OfpOxmOfbField_Ipv6NdSsl)(nil),
+		(*OfpOxmOfbField_Ipv6NdTll)(nil),
+		(*OfpOxmOfbField_MplsLabel)(nil),
+		(*OfpOxmOfbField_MplsTc)(nil),
+		(*OfpOxmOfbField_MplsBos)(nil),
+		(*OfpOxmOfbField_PbbIsid)(nil),
+		(*OfpOxmOfbField_TunnelId)(nil),
+		(*OfpOxmOfbField_Ipv6Exthdr)(nil),
+		(*OfpOxmOfbField_TableMetadataMask)(nil),
+		(*OfpOxmOfbField_EthDstMask)(nil),
+		(*OfpOxmOfbField_EthSrcMask)(nil),
+		(*OfpOxmOfbField_VlanVidMask)(nil),
+		(*OfpOxmOfbField_Ipv4SrcMask)(nil),
+		(*OfpOxmOfbField_Ipv4DstMask)(nil),
+		(*OfpOxmOfbField_ArpSpaMask)(nil),
+		(*OfpOxmOfbField_ArpTpaMask)(nil),
+		(*OfpOxmOfbField_Ipv6SrcMask)(nil),
+		(*OfpOxmOfbField_Ipv6DstMask)(nil),
+		(*OfpOxmOfbField_Ipv6FlabelMask)(nil),
+		(*OfpOxmOfbField_PbbIsidMask)(nil),
+		(*OfpOxmOfbField_TunnelIdMask)(nil),
+		(*OfpOxmOfbField_Ipv6ExthdrMask)(nil),
+	}
+}
+
+func _OfpOxmOfbField_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
+	m := msg.(*OfpOxmOfbField)
+	// value
+	switch x := m.Value.(type) {
+	case *OfpOxmOfbField_Port:
+		b.EncodeVarint(3<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.Port))
+	case *OfpOxmOfbField_PhysicalPort:
+		b.EncodeVarint(4<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.PhysicalPort))
+	case *OfpOxmOfbField_TableMetadata:
+		b.EncodeVarint(5<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.TableMetadata))
+	case *OfpOxmOfbField_EthDst:
+		b.EncodeVarint(6<<3 | proto.WireBytes)
+		b.EncodeRawBytes(x.EthDst)
+	case *OfpOxmOfbField_EthSrc:
+		b.EncodeVarint(7<<3 | proto.WireBytes)
+		b.EncodeRawBytes(x.EthSrc)
+	case *OfpOxmOfbField_EthType:
+		b.EncodeVarint(8<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.EthType))
+	case *OfpOxmOfbField_VlanVid:
+		b.EncodeVarint(9<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.VlanVid))
+	case *OfpOxmOfbField_VlanPcp:
+		b.EncodeVarint(10<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.VlanPcp))
+	case *OfpOxmOfbField_IpDscp:
+		b.EncodeVarint(11<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.IpDscp))
+	case *OfpOxmOfbField_IpEcn:
+		b.EncodeVarint(12<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.IpEcn))
+	case *OfpOxmOfbField_IpProto:
+		b.EncodeVarint(13<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.IpProto))
+	case *OfpOxmOfbField_Ipv4Src:
+		b.EncodeVarint(14<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.Ipv4Src))
+	case *OfpOxmOfbField_Ipv4Dst:
+		b.EncodeVarint(15<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.Ipv4Dst))
+	case *OfpOxmOfbField_TcpSrc:
+		b.EncodeVarint(16<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.TcpSrc))
+	case *OfpOxmOfbField_TcpDst:
+		b.EncodeVarint(17<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.TcpDst))
+	case *OfpOxmOfbField_UdpSrc:
+		b.EncodeVarint(18<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.UdpSrc))
+	case *OfpOxmOfbField_UdpDst:
+		b.EncodeVarint(19<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.UdpDst))
+	case *OfpOxmOfbField_SctpSrc:
+		b.EncodeVarint(20<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.SctpSrc))
+	case *OfpOxmOfbField_SctpDst:
+		b.EncodeVarint(21<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.SctpDst))
+	case *OfpOxmOfbField_Icmpv4Type:
+		b.EncodeVarint(22<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.Icmpv4Type))
+	case *OfpOxmOfbField_Icmpv4Code:
+		b.EncodeVarint(23<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.Icmpv4Code))
+	case *OfpOxmOfbField_ArpOp:
+		b.EncodeVarint(24<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.ArpOp))
+	case *OfpOxmOfbField_ArpSpa:
+		b.EncodeVarint(25<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.ArpSpa))
+	case *OfpOxmOfbField_ArpTpa:
+		b.EncodeVarint(26<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.ArpTpa))
+	case *OfpOxmOfbField_ArpSha:
+		b.EncodeVarint(27<<3 | proto.WireBytes)
+		b.EncodeRawBytes(x.ArpSha)
+	case *OfpOxmOfbField_ArpTha:
+		b.EncodeVarint(28<<3 | proto.WireBytes)
+		b.EncodeRawBytes(x.ArpTha)
+	case *OfpOxmOfbField_Ipv6Src:
+		b.EncodeVarint(29<<3 | proto.WireBytes)
+		b.EncodeRawBytes(x.Ipv6Src)
+	case *OfpOxmOfbField_Ipv6Dst:
+		b.EncodeVarint(30<<3 | proto.WireBytes)
+		b.EncodeRawBytes(x.Ipv6Dst)
+	case *OfpOxmOfbField_Ipv6Flabel:
+		b.EncodeVarint(31<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.Ipv6Flabel))
+	case *OfpOxmOfbField_Icmpv6Type:
+		b.EncodeVarint(32<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.Icmpv6Type))
+	case *OfpOxmOfbField_Icmpv6Code:
+		b.EncodeVarint(33<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.Icmpv6Code))
+	case *OfpOxmOfbField_Ipv6NdTarget:
+		b.EncodeVarint(34<<3 | proto.WireBytes)
+		b.EncodeRawBytes(x.Ipv6NdTarget)
+	case *OfpOxmOfbField_Ipv6NdSsl:
+		b.EncodeVarint(35<<3 | proto.WireBytes)
+		b.EncodeRawBytes(x.Ipv6NdSsl)
+	case *OfpOxmOfbField_Ipv6NdTll:
+		b.EncodeVarint(36<<3 | proto.WireBytes)
+		b.EncodeRawBytes(x.Ipv6NdTll)
+	case *OfpOxmOfbField_MplsLabel:
+		b.EncodeVarint(37<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.MplsLabel))
+	case *OfpOxmOfbField_MplsTc:
+		b.EncodeVarint(38<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.MplsTc))
+	case *OfpOxmOfbField_MplsBos:
+		b.EncodeVarint(39<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.MplsBos))
+	case *OfpOxmOfbField_PbbIsid:
+		b.EncodeVarint(40<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.PbbIsid))
+	case *OfpOxmOfbField_TunnelId:
+		b.EncodeVarint(41<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.TunnelId))
+	case *OfpOxmOfbField_Ipv6Exthdr:
+		b.EncodeVarint(42<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.Ipv6Exthdr))
+	case nil:
+	default:
+		return fmt.Errorf("OfpOxmOfbField.Value has unexpected type %T", x)
+	}
+	// mask
+	switch x := m.Mask.(type) {
+	case *OfpOxmOfbField_TableMetadataMask:
+		b.EncodeVarint(105<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.TableMetadataMask))
+	case *OfpOxmOfbField_EthDstMask:
+		b.EncodeVarint(106<<3 | proto.WireBytes)
+		b.EncodeRawBytes(x.EthDstMask)
+	case *OfpOxmOfbField_EthSrcMask:
+		b.EncodeVarint(107<<3 | proto.WireBytes)
+		b.EncodeRawBytes(x.EthSrcMask)
+	case *OfpOxmOfbField_VlanVidMask:
+		b.EncodeVarint(109<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.VlanVidMask))
+	case *OfpOxmOfbField_Ipv4SrcMask:
+		b.EncodeVarint(114<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.Ipv4SrcMask))
+	case *OfpOxmOfbField_Ipv4DstMask:
+		b.EncodeVarint(115<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.Ipv4DstMask))
+	case *OfpOxmOfbField_ArpSpaMask:
+		b.EncodeVarint(125<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.ArpSpaMask))
+	case *OfpOxmOfbField_ArpTpaMask:
+		b.EncodeVarint(126<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.ArpTpaMask))
+	case *OfpOxmOfbField_Ipv6SrcMask:
+		b.EncodeVarint(129<<3 | proto.WireBytes)
+		b.EncodeRawBytes(x.Ipv6SrcMask)
+	case *OfpOxmOfbField_Ipv6DstMask:
+		b.EncodeVarint(130<<3 | proto.WireBytes)
+		b.EncodeRawBytes(x.Ipv6DstMask)
+	case *OfpOxmOfbField_Ipv6FlabelMask:
+		b.EncodeVarint(131<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.Ipv6FlabelMask))
+	case *OfpOxmOfbField_PbbIsidMask:
+		b.EncodeVarint(140<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.PbbIsidMask))
+	case *OfpOxmOfbField_TunnelIdMask:
+		b.EncodeVarint(141<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.TunnelIdMask))
+	case *OfpOxmOfbField_Ipv6ExthdrMask:
+		b.EncodeVarint(142<<3 | proto.WireVarint)
+		b.EncodeVarint(uint64(x.Ipv6ExthdrMask))
+	case nil:
+	default:
+		return fmt.Errorf("OfpOxmOfbField.Mask has unexpected type %T", x)
+	}
+	return nil
+}
+
+func _OfpOxmOfbField_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
+	m := msg.(*OfpOxmOfbField)
+	switch tag {
+	case 3: // value.port
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.Value = &OfpOxmOfbField_Port{uint32(x)}
+		return true, err
+	case 4: // value.physical_port
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.Value = &OfpOxmOfbField_PhysicalPort{uint32(x)}
+		return true, err
+	case 5: // value.table_metadata
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.Value = &OfpOxmOfbField_TableMetadata{x}
+		return true, err
+	case 6: // value.eth_dst
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeRawBytes(true)
+		m.Value = &OfpOxmOfbField_EthDst{x}
+		return true, err
+	case 7: // value.eth_src
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeRawBytes(true)
+		m.Value = &OfpOxmOfbField_EthSrc{x}
+		return true, err
+	case 8: // value.eth_type
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.Value = &OfpOxmOfbField_EthType{uint32(x)}
+		return true, err
+	case 9: // value.vlan_vid
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.Value = &OfpOxmOfbField_VlanVid{uint32(x)}
+		return true, err
+	case 10: // value.vlan_pcp
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.Value = &OfpOxmOfbField_VlanPcp{uint32(x)}
+		return true, err
+	case 11: // value.ip_dscp
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.Value = &OfpOxmOfbField_IpDscp{uint32(x)}
+		return true, err
+	case 12: // value.ip_ecn
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.Value = &OfpOxmOfbField_IpEcn{uint32(x)}
+		return true, err
+	case 13: // value.ip_proto
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.Value = &OfpOxmOfbField_IpProto{uint32(x)}
+		return true, err
+	case 14: // value.ipv4_src
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.Value = &OfpOxmOfbField_Ipv4Src{uint32(x)}
+		return true, err
+	case 15: // value.ipv4_dst
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.Value = &OfpOxmOfbField_Ipv4Dst{uint32(x)}
+		return true, err
+	case 16: // value.tcp_src
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.Value = &OfpOxmOfbField_TcpSrc{uint32(x)}
+		return true, err
+	case 17: // value.tcp_dst
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.Value = &OfpOxmOfbField_TcpDst{uint32(x)}
+		return true, err
+	case 18: // value.udp_src
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.Value = &OfpOxmOfbField_UdpSrc{uint32(x)}
+		return true, err
+	case 19: // value.udp_dst
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.Value = &OfpOxmOfbField_UdpDst{uint32(x)}
+		return true, err
+	case 20: // value.sctp_src
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.Value = &OfpOxmOfbField_SctpSrc{uint32(x)}
+		return true, err
+	case 21: // value.sctp_dst
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.Value = &OfpOxmOfbField_SctpDst{uint32(x)}
+		return true, err
+	case 22: // value.icmpv4_type
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.Value = &OfpOxmOfbField_Icmpv4Type{uint32(x)}
+		return true, err
+	case 23: // value.icmpv4_code
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.Value = &OfpOxmOfbField_Icmpv4Code{uint32(x)}
+		return true, err
+	case 24: // value.arp_op
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.Value = &OfpOxmOfbField_ArpOp{uint32(x)}
+		return true, err
+	case 25: // value.arp_spa
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.Value = &OfpOxmOfbField_ArpSpa{uint32(x)}
+		return true, err
+	case 26: // value.arp_tpa
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.Value = &OfpOxmOfbField_ArpTpa{uint32(x)}
+		return true, err
+	case 27: // value.arp_sha
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeRawBytes(true)
+		m.Value = &OfpOxmOfbField_ArpSha{x}
+		return true, err
+	case 28: // value.arp_tha
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeRawBytes(true)
+		m.Value = &OfpOxmOfbField_ArpTha{x}
+		return true, err
+	case 29: // value.ipv6_src
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeRawBytes(true)
+		m.Value = &OfpOxmOfbField_Ipv6Src{x}
+		return true, err
+	case 30: // value.ipv6_dst
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeRawBytes(true)
+		m.Value = &OfpOxmOfbField_Ipv6Dst{x}
+		return true, err
+	case 31: // value.ipv6_flabel
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.Value = &OfpOxmOfbField_Ipv6Flabel{uint32(x)}
+		return true, err
+	case 32: // value.icmpv6_type
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.Value = &OfpOxmOfbField_Icmpv6Type{uint32(x)}
+		return true, err
+	case 33: // value.icmpv6_code
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.Value = &OfpOxmOfbField_Icmpv6Code{uint32(x)}
+		return true, err
+	case 34: // value.ipv6_nd_target
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeRawBytes(true)
+		m.Value = &OfpOxmOfbField_Ipv6NdTarget{x}
+		return true, err
+	case 35: // value.ipv6_nd_ssl
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeRawBytes(true)
+		m.Value = &OfpOxmOfbField_Ipv6NdSsl{x}
+		return true, err
+	case 36: // value.ipv6_nd_tll
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeRawBytes(true)
+		m.Value = &OfpOxmOfbField_Ipv6NdTll{x}
+		return true, err
+	case 37: // value.mpls_label
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.Value = &OfpOxmOfbField_MplsLabel{uint32(x)}
+		return true, err
+	case 38: // value.mpls_tc
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.Value = &OfpOxmOfbField_MplsTc{uint32(x)}
+		return true, err
+	case 39: // value.mpls_bos
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.Value = &OfpOxmOfbField_MplsBos{uint32(x)}
+		return true, err
+	case 40: // value.pbb_isid
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.Value = &OfpOxmOfbField_PbbIsid{uint32(x)}
+		return true, err
+	case 41: // value.tunnel_id
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.Value = &OfpOxmOfbField_TunnelId{x}
+		return true, err
+	case 42: // value.ipv6_exthdr
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.Value = &OfpOxmOfbField_Ipv6Exthdr{uint32(x)}
+		return true, err
+	case 105: // mask.table_metadata_mask
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.Mask = &OfpOxmOfbField_TableMetadataMask{x}
+		return true, err
+	case 106: // mask.eth_dst_mask
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeRawBytes(true)
+		m.Mask = &OfpOxmOfbField_EthDstMask{x}
+		return true, err
+	case 107: // mask.eth_src_mask
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeRawBytes(true)
+		m.Mask = &OfpOxmOfbField_EthSrcMask{x}
+		return true, err
+	case 109: // mask.vlan_vid_mask
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.Mask = &OfpOxmOfbField_VlanVidMask{uint32(x)}
+		return true, err
+	case 114: // mask.ipv4_src_mask
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.Mask = &OfpOxmOfbField_Ipv4SrcMask{uint32(x)}
+		return true, err
+	case 115: // mask.ipv4_dst_mask
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.Mask = &OfpOxmOfbField_Ipv4DstMask{uint32(x)}
+		return true, err
+	case 125: // mask.arp_spa_mask
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.Mask = &OfpOxmOfbField_ArpSpaMask{uint32(x)}
+		return true, err
+	case 126: // mask.arp_tpa_mask
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.Mask = &OfpOxmOfbField_ArpTpaMask{uint32(x)}
+		return true, err
+	case 129: // mask.ipv6_src_mask
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeRawBytes(true)
+		m.Mask = &OfpOxmOfbField_Ipv6SrcMask{x}
+		return true, err
+	case 130: // mask.ipv6_dst_mask
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeRawBytes(true)
+		m.Mask = &OfpOxmOfbField_Ipv6DstMask{x}
+		return true, err
+	case 131: // mask.ipv6_flabel_mask
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.Mask = &OfpOxmOfbField_Ipv6FlabelMask{uint32(x)}
+		return true, err
+	case 140: // mask.pbb_isid_mask
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.Mask = &OfpOxmOfbField_PbbIsidMask{uint32(x)}
+		return true, err
+	case 141: // mask.tunnel_id_mask
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.Mask = &OfpOxmOfbField_TunnelIdMask{x}
+		return true, err
+	case 142: // mask.ipv6_exthdr_mask
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.Mask = &OfpOxmOfbField_Ipv6ExthdrMask{uint32(x)}
+		return true, err
+	default:
+		return false, nil
+	}
+}
+
+func _OfpOxmOfbField_OneofSizer(msg proto.Message) (n int) {
+	m := msg.(*OfpOxmOfbField)
+	// value
+	switch x := m.Value.(type) {
+	case *OfpOxmOfbField_Port:
+		n += proto.SizeVarint(3<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.Port))
+	case *OfpOxmOfbField_PhysicalPort:
+		n += proto.SizeVarint(4<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.PhysicalPort))
+	case *OfpOxmOfbField_TableMetadata:
+		n += proto.SizeVarint(5<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.TableMetadata))
+	case *OfpOxmOfbField_EthDst:
+		n += proto.SizeVarint(6<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(len(x.EthDst)))
+		n += len(x.EthDst)
+	case *OfpOxmOfbField_EthSrc:
+		n += proto.SizeVarint(7<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(len(x.EthSrc)))
+		n += len(x.EthSrc)
+	case *OfpOxmOfbField_EthType:
+		n += proto.SizeVarint(8<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.EthType))
+	case *OfpOxmOfbField_VlanVid:
+		n += proto.SizeVarint(9<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.VlanVid))
+	case *OfpOxmOfbField_VlanPcp:
+		n += proto.SizeVarint(10<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.VlanPcp))
+	case *OfpOxmOfbField_IpDscp:
+		n += proto.SizeVarint(11<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.IpDscp))
+	case *OfpOxmOfbField_IpEcn:
+		n += proto.SizeVarint(12<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.IpEcn))
+	case *OfpOxmOfbField_IpProto:
+		n += proto.SizeVarint(13<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.IpProto))
+	case *OfpOxmOfbField_Ipv4Src:
+		n += proto.SizeVarint(14<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.Ipv4Src))
+	case *OfpOxmOfbField_Ipv4Dst:
+		n += proto.SizeVarint(15<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.Ipv4Dst))
+	case *OfpOxmOfbField_TcpSrc:
+		n += proto.SizeVarint(16<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.TcpSrc))
+	case *OfpOxmOfbField_TcpDst:
+		n += proto.SizeVarint(17<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.TcpDst))
+	case *OfpOxmOfbField_UdpSrc:
+		n += proto.SizeVarint(18<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.UdpSrc))
+	case *OfpOxmOfbField_UdpDst:
+		n += proto.SizeVarint(19<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.UdpDst))
+	case *OfpOxmOfbField_SctpSrc:
+		n += proto.SizeVarint(20<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.SctpSrc))
+	case *OfpOxmOfbField_SctpDst:
+		n += proto.SizeVarint(21<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.SctpDst))
+	case *OfpOxmOfbField_Icmpv4Type:
+		n += proto.SizeVarint(22<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.Icmpv4Type))
+	case *OfpOxmOfbField_Icmpv4Code:
+		n += proto.SizeVarint(23<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.Icmpv4Code))
+	case *OfpOxmOfbField_ArpOp:
+		n += proto.SizeVarint(24<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.ArpOp))
+	case *OfpOxmOfbField_ArpSpa:
+		n += proto.SizeVarint(25<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.ArpSpa))
+	case *OfpOxmOfbField_ArpTpa:
+		n += proto.SizeVarint(26<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.ArpTpa))
+	case *OfpOxmOfbField_ArpSha:
+		n += proto.SizeVarint(27<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(len(x.ArpSha)))
+		n += len(x.ArpSha)
+	case *OfpOxmOfbField_ArpTha:
+		n += proto.SizeVarint(28<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(len(x.ArpTha)))
+		n += len(x.ArpTha)
+	case *OfpOxmOfbField_Ipv6Src:
+		n += proto.SizeVarint(29<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(len(x.Ipv6Src)))
+		n += len(x.Ipv6Src)
+	case *OfpOxmOfbField_Ipv6Dst:
+		n += proto.SizeVarint(30<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(len(x.Ipv6Dst)))
+		n += len(x.Ipv6Dst)
+	case *OfpOxmOfbField_Ipv6Flabel:
+		n += proto.SizeVarint(31<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.Ipv6Flabel))
+	case *OfpOxmOfbField_Icmpv6Type:
+		n += proto.SizeVarint(32<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.Icmpv6Type))
+	case *OfpOxmOfbField_Icmpv6Code:
+		n += proto.SizeVarint(33<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.Icmpv6Code))
+	case *OfpOxmOfbField_Ipv6NdTarget:
+		n += proto.SizeVarint(34<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(len(x.Ipv6NdTarget)))
+		n += len(x.Ipv6NdTarget)
+	case *OfpOxmOfbField_Ipv6NdSsl:
+		n += proto.SizeVarint(35<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(len(x.Ipv6NdSsl)))
+		n += len(x.Ipv6NdSsl)
+	case *OfpOxmOfbField_Ipv6NdTll:
+		n += proto.SizeVarint(36<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(len(x.Ipv6NdTll)))
+		n += len(x.Ipv6NdTll)
+	case *OfpOxmOfbField_MplsLabel:
+		n += proto.SizeVarint(37<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.MplsLabel))
+	case *OfpOxmOfbField_MplsTc:
+		n += proto.SizeVarint(38<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.MplsTc))
+	case *OfpOxmOfbField_MplsBos:
+		n += proto.SizeVarint(39<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.MplsBos))
+	case *OfpOxmOfbField_PbbIsid:
+		n += proto.SizeVarint(40<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.PbbIsid))
+	case *OfpOxmOfbField_TunnelId:
+		n += proto.SizeVarint(41<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.TunnelId))
+	case *OfpOxmOfbField_Ipv6Exthdr:
+		n += proto.SizeVarint(42<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.Ipv6Exthdr))
+	case nil:
+	default:
+		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
+	}
+	// mask
+	switch x := m.Mask.(type) {
+	case *OfpOxmOfbField_TableMetadataMask:
+		n += proto.SizeVarint(105<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.TableMetadataMask))
+	case *OfpOxmOfbField_EthDstMask:
+		n += proto.SizeVarint(106<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(len(x.EthDstMask)))
+		n += len(x.EthDstMask)
+	case *OfpOxmOfbField_EthSrcMask:
+		n += proto.SizeVarint(107<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(len(x.EthSrcMask)))
+		n += len(x.EthSrcMask)
+	case *OfpOxmOfbField_VlanVidMask:
+		n += proto.SizeVarint(109<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.VlanVidMask))
+	case *OfpOxmOfbField_Ipv4SrcMask:
+		n += proto.SizeVarint(114<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.Ipv4SrcMask))
+	case *OfpOxmOfbField_Ipv4DstMask:
+		n += proto.SizeVarint(115<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.Ipv4DstMask))
+	case *OfpOxmOfbField_ArpSpaMask:
+		n += proto.SizeVarint(125<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.ArpSpaMask))
+	case *OfpOxmOfbField_ArpTpaMask:
+		n += proto.SizeVarint(126<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.ArpTpaMask))
+	case *OfpOxmOfbField_Ipv6SrcMask:
+		n += proto.SizeVarint(129<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(len(x.Ipv6SrcMask)))
+		n += len(x.Ipv6SrcMask)
+	case *OfpOxmOfbField_Ipv6DstMask:
+		n += proto.SizeVarint(130<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(len(x.Ipv6DstMask)))
+		n += len(x.Ipv6DstMask)
+	case *OfpOxmOfbField_Ipv6FlabelMask:
+		n += proto.SizeVarint(131<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.Ipv6FlabelMask))
+	case *OfpOxmOfbField_PbbIsidMask:
+		n += proto.SizeVarint(140<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.PbbIsidMask))
+	case *OfpOxmOfbField_TunnelIdMask:
+		n += proto.SizeVarint(141<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.TunnelIdMask))
+	case *OfpOxmOfbField_Ipv6ExthdrMask:
+		n += proto.SizeVarint(142<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.Ipv6ExthdrMask))
+	case nil:
+	default:
+		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
+	}
+	return n
+}
+
+// Header for OXM experimenter match fields.
+// The experimenter class should not use OXM_HEADER() macros for defining
+// fields due to this extra header.
+type OfpOxmExperimenterField struct {
+	OxmHeader    uint32 `protobuf:"varint,1,opt,name=oxm_header,json=oxmHeader" json:"oxm_header,omitempty"`
+	Experimenter uint32 `protobuf:"varint,2,opt,name=experimenter" json:"experimenter,omitempty"`
+}
+
+func (m *OfpOxmExperimenterField) Reset()                    { *m = OfpOxmExperimenterField{} }
+func (m *OfpOxmExperimenterField) String() string            { return proto.CompactTextString(m) }
+func (*OfpOxmExperimenterField) ProtoMessage()               {}
+func (*OfpOxmExperimenterField) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{13} }
+
+func (m *OfpOxmExperimenterField) GetOxmHeader() uint32 {
+	if m != nil {
+		return m.OxmHeader
+	}
+	return 0
+}
+
+func (m *OfpOxmExperimenterField) GetExperimenter() uint32 {
+	if m != nil {
+		return m.Experimenter
+	}
+	return 0
+}
+
+// Action header that is common to all actions.  The length includes the
+// header and any padding used to make the action 64-bit aligned.
+// NB: The length of an action *must* always be a multiple of eight.
+type OfpAction struct {
+	Type OfpActionType `protobuf:"varint,1,opt,name=type,enum=openflow_13.OfpActionType" json:"type,omitempty"`
+	// Types that are valid to be assigned to Action:
+	//	*OfpAction_Output
+	//	*OfpAction_MplsTtl
+	//	*OfpAction_Push
+	//	*OfpAction_PopMpls
+	//	*OfpAction_Group
+	//	*OfpAction_NwTtl
+	//	*OfpAction_SetField
+	//	*OfpAction_Experimenter
+	Action isOfpAction_Action `protobuf_oneof:"action"`
+}
+
+func (m *OfpAction) Reset()                    { *m = OfpAction{} }
+func (m *OfpAction) String() string            { return proto.CompactTextString(m) }
+func (*OfpAction) ProtoMessage()               {}
+func (*OfpAction) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{14} }
+
+type isOfpAction_Action interface {
+	isOfpAction_Action()
+}
+
+type OfpAction_Output struct {
+	Output *OfpActionOutput `protobuf:"bytes,2,opt,name=output,oneof"`
+}
+type OfpAction_MplsTtl struct {
+	MplsTtl *OfpActionMplsTtl `protobuf:"bytes,3,opt,name=mpls_ttl,json=mplsTtl,oneof"`
+}
+type OfpAction_Push struct {
+	Push *OfpActionPush `protobuf:"bytes,4,opt,name=push,oneof"`
+}
+type OfpAction_PopMpls struct {
+	PopMpls *OfpActionPopMpls `protobuf:"bytes,5,opt,name=pop_mpls,json=popMpls,oneof"`
+}
+type OfpAction_Group struct {
+	Group *OfpActionGroup `protobuf:"bytes,6,opt,name=group,oneof"`
+}
+type OfpAction_NwTtl struct {
+	NwTtl *OfpActionNwTtl `protobuf:"bytes,7,opt,name=nw_ttl,json=nwTtl,oneof"`
+}
+type OfpAction_SetField struct {
+	SetField *OfpActionSetField `protobuf:"bytes,8,opt,name=set_field,json=setField,oneof"`
+}
+type OfpAction_Experimenter struct {
+	Experimenter *OfpActionExperimenter `protobuf:"bytes,9,opt,name=experimenter,oneof"`
+}
+
+func (*OfpAction_Output) isOfpAction_Action()       {}
+func (*OfpAction_MplsTtl) isOfpAction_Action()      {}
+func (*OfpAction_Push) isOfpAction_Action()         {}
+func (*OfpAction_PopMpls) isOfpAction_Action()      {}
+func (*OfpAction_Group) isOfpAction_Action()        {}
+func (*OfpAction_NwTtl) isOfpAction_Action()        {}
+func (*OfpAction_SetField) isOfpAction_Action()     {}
+func (*OfpAction_Experimenter) isOfpAction_Action() {}
+
+func (m *OfpAction) GetAction() isOfpAction_Action {
+	if m != nil {
+		return m.Action
+	}
+	return nil
+}
+
+func (m *OfpAction) GetType() OfpActionType {
+	if m != nil {
+		return m.Type
+	}
+	return OfpActionType_OFPAT_OUTPUT
+}
+
+func (m *OfpAction) GetOutput() *OfpActionOutput {
+	if x, ok := m.GetAction().(*OfpAction_Output); ok {
+		return x.Output
+	}
+	return nil
+}
+
+func (m *OfpAction) GetMplsTtl() *OfpActionMplsTtl {
+	if x, ok := m.GetAction().(*OfpAction_MplsTtl); ok {
+		return x.MplsTtl
+	}
+	return nil
+}
+
+func (m *OfpAction) GetPush() *OfpActionPush {
+	if x, ok := m.GetAction().(*OfpAction_Push); ok {
+		return x.Push
+	}
+	return nil
+}
+
+func (m *OfpAction) GetPopMpls() *OfpActionPopMpls {
+	if x, ok := m.GetAction().(*OfpAction_PopMpls); ok {
+		return x.PopMpls
+	}
+	return nil
+}
+
+func (m *OfpAction) GetGroup() *OfpActionGroup {
+	if x, ok := m.GetAction().(*OfpAction_Group); ok {
+		return x.Group
+	}
+	return nil
+}
+
+func (m *OfpAction) GetNwTtl() *OfpActionNwTtl {
+	if x, ok := m.GetAction().(*OfpAction_NwTtl); ok {
+		return x.NwTtl
+	}
+	return nil
+}
+
+func (m *OfpAction) GetSetField() *OfpActionSetField {
+	if x, ok := m.GetAction().(*OfpAction_SetField); ok {
+		return x.SetField
+	}
+	return nil
+}
+
+func (m *OfpAction) GetExperimenter() *OfpActionExperimenter {
+	if x, ok := m.GetAction().(*OfpAction_Experimenter); ok {
+		return x.Experimenter
+	}
+	return nil
+}
+
+// XXX_OneofFuncs is for the internal use of the proto package.
+func (*OfpAction) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
+	return _OfpAction_OneofMarshaler, _OfpAction_OneofUnmarshaler, _OfpAction_OneofSizer, []interface{}{
+		(*OfpAction_Output)(nil),
+		(*OfpAction_MplsTtl)(nil),
+		(*OfpAction_Push)(nil),
+		(*OfpAction_PopMpls)(nil),
+		(*OfpAction_Group)(nil),
+		(*OfpAction_NwTtl)(nil),
+		(*OfpAction_SetField)(nil),
+		(*OfpAction_Experimenter)(nil),
+	}
+}
+
+func _OfpAction_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
+	m := msg.(*OfpAction)
+	// action
+	switch x := m.Action.(type) {
+	case *OfpAction_Output:
+		b.EncodeVarint(2<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.Output); err != nil {
+			return err
+		}
+	case *OfpAction_MplsTtl:
+		b.EncodeVarint(3<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.MplsTtl); err != nil {
+			return err
+		}
+	case *OfpAction_Push:
+		b.EncodeVarint(4<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.Push); err != nil {
+			return err
+		}
+	case *OfpAction_PopMpls:
+		b.EncodeVarint(5<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.PopMpls); err != nil {
+			return err
+		}
+	case *OfpAction_Group:
+		b.EncodeVarint(6<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.Group); err != nil {
+			return err
+		}
+	case *OfpAction_NwTtl:
+		b.EncodeVarint(7<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.NwTtl); err != nil {
+			return err
+		}
+	case *OfpAction_SetField:
+		b.EncodeVarint(8<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.SetField); err != nil {
+			return err
+		}
+	case *OfpAction_Experimenter:
+		b.EncodeVarint(9<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.Experimenter); err != nil {
+			return err
+		}
+	case nil:
+	default:
+		return fmt.Errorf("OfpAction.Action has unexpected type %T", x)
+	}
+	return nil
+}
+
+func _OfpAction_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
+	m := msg.(*OfpAction)
+	switch tag {
+	case 2: // action.output
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(OfpActionOutput)
+		err := b.DecodeMessage(msg)
+		m.Action = &OfpAction_Output{msg}
+		return true, err
+	case 3: // action.mpls_ttl
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(OfpActionMplsTtl)
+		err := b.DecodeMessage(msg)
+		m.Action = &OfpAction_MplsTtl{msg}
+		return true, err
+	case 4: // action.push
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(OfpActionPush)
+		err := b.DecodeMessage(msg)
+		m.Action = &OfpAction_Push{msg}
+		return true, err
+	case 5: // action.pop_mpls
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(OfpActionPopMpls)
+		err := b.DecodeMessage(msg)
+		m.Action = &OfpAction_PopMpls{msg}
+		return true, err
+	case 6: // action.group
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(OfpActionGroup)
+		err := b.DecodeMessage(msg)
+		m.Action = &OfpAction_Group{msg}
+		return true, err
+	case 7: // action.nw_ttl
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(OfpActionNwTtl)
+		err := b.DecodeMessage(msg)
+		m.Action = &OfpAction_NwTtl{msg}
+		return true, err
+	case 8: // action.set_field
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(OfpActionSetField)
+		err := b.DecodeMessage(msg)
+		m.Action = &OfpAction_SetField{msg}
+		return true, err
+	case 9: // action.experimenter
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(OfpActionExperimenter)
+		err := b.DecodeMessage(msg)
+		m.Action = &OfpAction_Experimenter{msg}
+		return true, err
+	default:
+		return false, nil
+	}
+}
+
+func _OfpAction_OneofSizer(msg proto.Message) (n int) {
+	m := msg.(*OfpAction)
+	// action
+	switch x := m.Action.(type) {
+	case *OfpAction_Output:
+		s := proto.Size(x.Output)
+		n += proto.SizeVarint(2<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case *OfpAction_MplsTtl:
+		s := proto.Size(x.MplsTtl)
+		n += proto.SizeVarint(3<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case *OfpAction_Push:
+		s := proto.Size(x.Push)
+		n += proto.SizeVarint(4<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case *OfpAction_PopMpls:
+		s := proto.Size(x.PopMpls)
+		n += proto.SizeVarint(5<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case *OfpAction_Group:
+		s := proto.Size(x.Group)
+		n += proto.SizeVarint(6<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case *OfpAction_NwTtl:
+		s := proto.Size(x.NwTtl)
+		n += proto.SizeVarint(7<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case *OfpAction_SetField:
+		s := proto.Size(x.SetField)
+		n += proto.SizeVarint(8<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case *OfpAction_Experimenter:
+		s := proto.Size(x.Experimenter)
+		n += proto.SizeVarint(9<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case nil:
+	default:
+		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
+	}
+	return n
+}
+
+// Action structure for OFPAT_OUTPUT, which sends packets out 'port'.
+// When the 'port' is the OFPP_CONTROLLER, 'max_len' indicates the max
+// number of bytes to send.  A 'max_len' of zero means no bytes of the
+// packet should be sent. A 'max_len' of OFPCML_NO_BUFFER means that
+// the packet is not buffered and the complete packet is to be sent to
+// the controller.
+type OfpActionOutput struct {
+	Port   uint32 `protobuf:"varint,1,opt,name=port" json:"port,omitempty"`
+	MaxLen uint32 `protobuf:"varint,2,opt,name=max_len,json=maxLen" json:"max_len,omitempty"`
+}
+
+func (m *OfpActionOutput) Reset()                    { *m = OfpActionOutput{} }
+func (m *OfpActionOutput) String() string            { return proto.CompactTextString(m) }
+func (*OfpActionOutput) ProtoMessage()               {}
+func (*OfpActionOutput) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{15} }
+
+func (m *OfpActionOutput) GetPort() uint32 {
+	if m != nil {
+		return m.Port
+	}
+	return 0
+}
+
+func (m *OfpActionOutput) GetMaxLen() uint32 {
+	if m != nil {
+		return m.MaxLen
+	}
+	return 0
+}
+
+// Action structure for OFPAT_SET_MPLS_TTL.
+type OfpActionMplsTtl struct {
+	MplsTtl uint32 `protobuf:"varint,1,opt,name=mpls_ttl,json=mplsTtl" json:"mpls_ttl,omitempty"`
+}
+
+func (m *OfpActionMplsTtl) Reset()                    { *m = OfpActionMplsTtl{} }
+func (m *OfpActionMplsTtl) String() string            { return proto.CompactTextString(m) }
+func (*OfpActionMplsTtl) ProtoMessage()               {}
+func (*OfpActionMplsTtl) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{16} }
+
+func (m *OfpActionMplsTtl) GetMplsTtl() uint32 {
+	if m != nil {
+		return m.MplsTtl
+	}
+	return 0
+}
+
+// Action structure for OFPAT_PUSH_VLAN/MPLS/PBB.
+type OfpActionPush struct {
+	Ethertype uint32 `protobuf:"varint,1,opt,name=ethertype" json:"ethertype,omitempty"`
+}
+
+func (m *OfpActionPush) Reset()                    { *m = OfpActionPush{} }
+func (m *OfpActionPush) String() string            { return proto.CompactTextString(m) }
+func (*OfpActionPush) ProtoMessage()               {}
+func (*OfpActionPush) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{17} }
+
+func (m *OfpActionPush) GetEthertype() uint32 {
+	if m != nil {
+		return m.Ethertype
+	}
+	return 0
+}
+
+// Action structure for OFPAT_POP_MPLS.
+type OfpActionPopMpls struct {
+	Ethertype uint32 `protobuf:"varint,1,opt,name=ethertype" json:"ethertype,omitempty"`
+}
+
+func (m *OfpActionPopMpls) Reset()                    { *m = OfpActionPopMpls{} }
+func (m *OfpActionPopMpls) String() string            { return proto.CompactTextString(m) }
+func (*OfpActionPopMpls) ProtoMessage()               {}
+func (*OfpActionPopMpls) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{18} }
+
+func (m *OfpActionPopMpls) GetEthertype() uint32 {
+	if m != nil {
+		return m.Ethertype
+	}
+	return 0
+}
+
+// Action structure for OFPAT_GROUP.
+type OfpActionGroup struct {
+	GroupId uint32 `protobuf:"varint,1,opt,name=group_id,json=groupId" json:"group_id,omitempty"`
+}
+
+func (m *OfpActionGroup) Reset()                    { *m = OfpActionGroup{} }
+func (m *OfpActionGroup) String() string            { return proto.CompactTextString(m) }
+func (*OfpActionGroup) ProtoMessage()               {}
+func (*OfpActionGroup) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{19} }
+
+func (m *OfpActionGroup) GetGroupId() uint32 {
+	if m != nil {
+		return m.GroupId
+	}
+	return 0
+}
+
+// Action structure for OFPAT_SET_NW_TTL.
+type OfpActionNwTtl struct {
+	NwTtl uint32 `protobuf:"varint,1,opt,name=nw_ttl,json=nwTtl" json:"nw_ttl,omitempty"`
+}
+
+func (m *OfpActionNwTtl) Reset()                    { *m = OfpActionNwTtl{} }
+func (m *OfpActionNwTtl) String() string            { return proto.CompactTextString(m) }
+func (*OfpActionNwTtl) ProtoMessage()               {}
+func (*OfpActionNwTtl) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{20} }
+
+func (m *OfpActionNwTtl) GetNwTtl() uint32 {
+	if m != nil {
+		return m.NwTtl
+	}
+	return 0
+}
+
+// Action structure for OFPAT_SET_FIELD.
+type OfpActionSetField struct {
+	Field *OfpOxmField `protobuf:"bytes,1,opt,name=field" json:"field,omitempty"`
+}
+
+func (m *OfpActionSetField) Reset()                    { *m = OfpActionSetField{} }
+func (m *OfpActionSetField) String() string            { return proto.CompactTextString(m) }
+func (*OfpActionSetField) ProtoMessage()               {}
+func (*OfpActionSetField) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{21} }
+
+func (m *OfpActionSetField) GetField() *OfpOxmField {
+	if m != nil {
+		return m.Field
+	}
+	return nil
+}
+
+// Action header for OFPAT_EXPERIMENTER.
+// The rest of the body is experimenter-defined.
+type OfpActionExperimenter struct {
+	Experimenter uint32 `protobuf:"varint,1,opt,name=experimenter" json:"experimenter,omitempty"`
+	Data         []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
+}
+
+func (m *OfpActionExperimenter) Reset()                    { *m = OfpActionExperimenter{} }
+func (m *OfpActionExperimenter) String() string            { return proto.CompactTextString(m) }
+func (*OfpActionExperimenter) ProtoMessage()               {}
+func (*OfpActionExperimenter) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{22} }
+
+func (m *OfpActionExperimenter) GetExperimenter() uint32 {
+	if m != nil {
+		return m.Experimenter
+	}
+	return 0
+}
+
+func (m *OfpActionExperimenter) GetData() []byte {
+	if m != nil {
+		return m.Data
+	}
+	return nil
+}
+
+// Instruction header that is common to all instructions.  The length includes
+// the header and any padding used to make the instruction 64-bit aligned.
+// NB: The length of an instruction *must* always be a multiple of eight.
+type OfpInstruction struct {
+	Type uint32 `protobuf:"varint,1,opt,name=type" json:"type,omitempty"`
+	// Types that are valid to be assigned to Data:
+	//	*OfpInstruction_GotoTable
+	//	*OfpInstruction_WriteMetadata
+	//	*OfpInstruction_Actions
+	//	*OfpInstruction_Meter
+	//	*OfpInstruction_Experimenter
+	Data isOfpInstruction_Data `protobuf_oneof:"data"`
+}
+
+func (m *OfpInstruction) Reset()                    { *m = OfpInstruction{} }
+func (m *OfpInstruction) String() string            { return proto.CompactTextString(m) }
+func (*OfpInstruction) ProtoMessage()               {}
+func (*OfpInstruction) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{23} }
+
+type isOfpInstruction_Data interface {
+	isOfpInstruction_Data()
+}
+
+type OfpInstruction_GotoTable struct {
+	GotoTable *OfpInstructionGotoTable `protobuf:"bytes,2,opt,name=goto_table,json=gotoTable,oneof"`
+}
+type OfpInstruction_WriteMetadata struct {
+	WriteMetadata *OfpInstructionWriteMetadata `protobuf:"bytes,3,opt,name=write_metadata,json=writeMetadata,oneof"`
+}
+type OfpInstruction_Actions struct {
+	Actions *OfpInstructionActions `protobuf:"bytes,4,opt,name=actions,oneof"`
+}
+type OfpInstruction_Meter struct {
+	Meter *OfpInstructionMeter `protobuf:"bytes,5,opt,name=meter,oneof"`
+}
+type OfpInstruction_Experimenter struct {
+	Experimenter *OfpInstructionExperimenter `protobuf:"bytes,6,opt,name=experimenter,oneof"`
+}
+
+func (*OfpInstruction_GotoTable) isOfpInstruction_Data()     {}
+func (*OfpInstruction_WriteMetadata) isOfpInstruction_Data() {}
+func (*OfpInstruction_Actions) isOfpInstruction_Data()       {}
+func (*OfpInstruction_Meter) isOfpInstruction_Data()         {}
+func (*OfpInstruction_Experimenter) isOfpInstruction_Data()  {}
+
+func (m *OfpInstruction) GetData() isOfpInstruction_Data {
+	if m != nil {
+		return m.Data
+	}
+	return nil
+}
+
+func (m *OfpInstruction) GetType() uint32 {
+	if m != nil {
+		return m.Type
+	}
+	return 0
+}
+
+func (m *OfpInstruction) GetGotoTable() *OfpInstructionGotoTable {
+	if x, ok := m.GetData().(*OfpInstruction_GotoTable); ok {
+		return x.GotoTable
+	}
+	return nil
+}
+
+func (m *OfpInstruction) GetWriteMetadata() *OfpInstructionWriteMetadata {
+	if x, ok := m.GetData().(*OfpInstruction_WriteMetadata); ok {
+		return x.WriteMetadata
+	}
+	return nil
+}
+
+func (m *OfpInstruction) GetActions() *OfpInstructionActions {
+	if x, ok := m.GetData().(*OfpInstruction_Actions); ok {
+		return x.Actions
+	}
+	return nil
+}
+
+func (m *OfpInstruction) GetMeter() *OfpInstructionMeter {
+	if x, ok := m.GetData().(*OfpInstruction_Meter); ok {
+		return x.Meter
+	}
+	return nil
+}
+
+func (m *OfpInstruction) GetExperimenter() *OfpInstructionExperimenter {
+	if x, ok := m.GetData().(*OfpInstruction_Experimenter); ok {
+		return x.Experimenter
+	}
+	return nil
+}
+
+// XXX_OneofFuncs is for the internal use of the proto package.
+func (*OfpInstruction) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
+	return _OfpInstruction_OneofMarshaler, _OfpInstruction_OneofUnmarshaler, _OfpInstruction_OneofSizer, []interface{}{
+		(*OfpInstruction_GotoTable)(nil),
+		(*OfpInstruction_WriteMetadata)(nil),
+		(*OfpInstruction_Actions)(nil),
+		(*OfpInstruction_Meter)(nil),
+		(*OfpInstruction_Experimenter)(nil),
+	}
+}
+
+func _OfpInstruction_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
+	m := msg.(*OfpInstruction)
+	// data
+	switch x := m.Data.(type) {
+	case *OfpInstruction_GotoTable:
+		b.EncodeVarint(2<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.GotoTable); err != nil {
+			return err
+		}
+	case *OfpInstruction_WriteMetadata:
+		b.EncodeVarint(3<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.WriteMetadata); err != nil {
+			return err
+		}
+	case *OfpInstruction_Actions:
+		b.EncodeVarint(4<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.Actions); err != nil {
+			return err
+		}
+	case *OfpInstruction_Meter:
+		b.EncodeVarint(5<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.Meter); err != nil {
+			return err
+		}
+	case *OfpInstruction_Experimenter:
+		b.EncodeVarint(6<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.Experimenter); err != nil {
+			return err
+		}
+	case nil:
+	default:
+		return fmt.Errorf("OfpInstruction.Data has unexpected type %T", x)
+	}
+	return nil
+}
+
+func _OfpInstruction_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
+	m := msg.(*OfpInstruction)
+	switch tag {
+	case 2: // data.goto_table
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(OfpInstructionGotoTable)
+		err := b.DecodeMessage(msg)
+		m.Data = &OfpInstruction_GotoTable{msg}
+		return true, err
+	case 3: // data.write_metadata
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(OfpInstructionWriteMetadata)
+		err := b.DecodeMessage(msg)
+		m.Data = &OfpInstruction_WriteMetadata{msg}
+		return true, err
+	case 4: // data.actions
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(OfpInstructionActions)
+		err := b.DecodeMessage(msg)
+		m.Data = &OfpInstruction_Actions{msg}
+		return true, err
+	case 5: // data.meter
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(OfpInstructionMeter)
+		err := b.DecodeMessage(msg)
+		m.Data = &OfpInstruction_Meter{msg}
+		return true, err
+	case 6: // data.experimenter
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(OfpInstructionExperimenter)
+		err := b.DecodeMessage(msg)
+		m.Data = &OfpInstruction_Experimenter{msg}
+		return true, err
+	default:
+		return false, nil
+	}
+}
+
+func _OfpInstruction_OneofSizer(msg proto.Message) (n int) {
+	m := msg.(*OfpInstruction)
+	// data
+	switch x := m.Data.(type) {
+	case *OfpInstruction_GotoTable:
+		s := proto.Size(x.GotoTable)
+		n += proto.SizeVarint(2<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case *OfpInstruction_WriteMetadata:
+		s := proto.Size(x.WriteMetadata)
+		n += proto.SizeVarint(3<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case *OfpInstruction_Actions:
+		s := proto.Size(x.Actions)
+		n += proto.SizeVarint(4<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case *OfpInstruction_Meter:
+		s := proto.Size(x.Meter)
+		n += proto.SizeVarint(5<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case *OfpInstruction_Experimenter:
+		s := proto.Size(x.Experimenter)
+		n += proto.SizeVarint(6<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case nil:
+	default:
+		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
+	}
+	return n
+}
+
+// Instruction structure for OFPIT_GOTO_TABLE
+type OfpInstructionGotoTable struct {
+	TableId uint32 `protobuf:"varint,1,opt,name=table_id,json=tableId" json:"table_id,omitempty"`
+}
+
+func (m *OfpInstructionGotoTable) Reset()                    { *m = OfpInstructionGotoTable{} }
+func (m *OfpInstructionGotoTable) String() string            { return proto.CompactTextString(m) }
+func (*OfpInstructionGotoTable) ProtoMessage()               {}
+func (*OfpInstructionGotoTable) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{24} }
+
+func (m *OfpInstructionGotoTable) GetTableId() uint32 {
+	if m != nil {
+		return m.TableId
+	}
+	return 0
+}
+
+// Instruction structure for OFPIT_WRITE_METADATA
+type OfpInstructionWriteMetadata struct {
+	Metadata     uint64 `protobuf:"varint,1,opt,name=metadata" json:"metadata,omitempty"`
+	MetadataMask uint64 `protobuf:"varint,2,opt,name=metadata_mask,json=metadataMask" json:"metadata_mask,omitempty"`
+}
+
+func (m *OfpInstructionWriteMetadata) Reset()                    { *m = OfpInstructionWriteMetadata{} }
+func (m *OfpInstructionWriteMetadata) String() string            { return proto.CompactTextString(m) }
+func (*OfpInstructionWriteMetadata) ProtoMessage()               {}
+func (*OfpInstructionWriteMetadata) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{25} }
+
+func (m *OfpInstructionWriteMetadata) GetMetadata() uint64 {
+	if m != nil {
+		return m.Metadata
+	}
+	return 0
+}
+
+func (m *OfpInstructionWriteMetadata) GetMetadataMask() uint64 {
+	if m != nil {
+		return m.MetadataMask
+	}
+	return 0
+}
+
+// Instruction structure for OFPIT_WRITE/APPLY/CLEAR_ACTIONS
+type OfpInstructionActions struct {
+	Actions []*OfpAction `protobuf:"bytes,1,rep,name=actions" json:"actions,omitempty"`
+}
+
+func (m *OfpInstructionActions) Reset()                    { *m = OfpInstructionActions{} }
+func (m *OfpInstructionActions) String() string            { return proto.CompactTextString(m) }
+func (*OfpInstructionActions) ProtoMessage()               {}
+func (*OfpInstructionActions) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{26} }
+
+func (m *OfpInstructionActions) GetActions() []*OfpAction {
+	if m != nil {
+		return m.Actions
+	}
+	return nil
+}
+
+// Instruction structure for OFPIT_METER
+type OfpInstructionMeter struct {
+	MeterId uint32 `protobuf:"varint,1,opt,name=meter_id,json=meterId" json:"meter_id,omitempty"`
+}
+
+func (m *OfpInstructionMeter) Reset()                    { *m = OfpInstructionMeter{} }
+func (m *OfpInstructionMeter) String() string            { return proto.CompactTextString(m) }
+func (*OfpInstructionMeter) ProtoMessage()               {}
+func (*OfpInstructionMeter) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{27} }
+
+func (m *OfpInstructionMeter) GetMeterId() uint32 {
+	if m != nil {
+		return m.MeterId
+	}
+	return 0
+}
+
+// Instruction structure for experimental instructions
+type OfpInstructionExperimenter struct {
+	Experimenter uint32 `protobuf:"varint,1,opt,name=experimenter" json:"experimenter,omitempty"`
+	// Experimenter-defined arbitrary additional data.
+	Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
+}
+
+func (m *OfpInstructionExperimenter) Reset()                    { *m = OfpInstructionExperimenter{} }
+func (m *OfpInstructionExperimenter) String() string            { return proto.CompactTextString(m) }
+func (*OfpInstructionExperimenter) ProtoMessage()               {}
+func (*OfpInstructionExperimenter) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{28} }
+
+func (m *OfpInstructionExperimenter) GetExperimenter() uint32 {
+	if m != nil {
+		return m.Experimenter
+	}
+	return 0
+}
+
+func (m *OfpInstructionExperimenter) GetData() []byte {
+	if m != nil {
+		return m.Data
+	}
+	return nil
+}
+
+// Flow setup and teardown (controller -> datapath).
+type OfpFlowMod struct {
+	// ofp_header header;
+	Cookie       uint64            `protobuf:"varint,1,opt,name=cookie" json:"cookie,omitempty"`
+	CookieMask   uint64            `protobuf:"varint,2,opt,name=cookie_mask,json=cookieMask" json:"cookie_mask,omitempty"`
+	TableId      uint32            `protobuf:"varint,3,opt,name=table_id,json=tableId" json:"table_id,omitempty"`
+	Command      OfpFlowModCommand `protobuf:"varint,4,opt,name=command,enum=openflow_13.OfpFlowModCommand" json:"command,omitempty"`
+	IdleTimeout  uint32            `protobuf:"varint,5,opt,name=idle_timeout,json=idleTimeout" json:"idle_timeout,omitempty"`
+	HardTimeout  uint32            `protobuf:"varint,6,opt,name=hard_timeout,json=hardTimeout" json:"hard_timeout,omitempty"`
+	Priority     uint32            `protobuf:"varint,7,opt,name=priority" json:"priority,omitempty"`
+	BufferId     uint32            `protobuf:"varint,8,opt,name=buffer_id,json=bufferId" json:"buffer_id,omitempty"`
+	OutPort      uint32            `protobuf:"varint,9,opt,name=out_port,json=outPort" json:"out_port,omitempty"`
+	OutGroup     uint32            `protobuf:"varint,10,opt,name=out_group,json=outGroup" json:"out_group,omitempty"`
+	Flags        uint32            `protobuf:"varint,11,opt,name=flags" json:"flags,omitempty"`
+	Match        *OfpMatch         `protobuf:"bytes,12,opt,name=match" json:"match,omitempty"`
+	Instructions []*OfpInstruction `protobuf:"bytes,13,rep,name=instructions" json:"instructions,omitempty"`
+}
+
+func (m *OfpFlowMod) Reset()                    { *m = OfpFlowMod{} }
+func (m *OfpFlowMod) String() string            { return proto.CompactTextString(m) }
+func (*OfpFlowMod) ProtoMessage()               {}
+func (*OfpFlowMod) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{29} }
+
+func (m *OfpFlowMod) GetCookie() uint64 {
+	if m != nil {
+		return m.Cookie
+	}
+	return 0
+}
+
+func (m *OfpFlowMod) GetCookieMask() uint64 {
+	if m != nil {
+		return m.CookieMask
+	}
+	return 0
+}
+
+func (m *OfpFlowMod) GetTableId() uint32 {
+	if m != nil {
+		return m.TableId
+	}
+	return 0
+}
+
+func (m *OfpFlowMod) GetCommand() OfpFlowModCommand {
+	if m != nil {
+		return m.Command
+	}
+	return OfpFlowModCommand_OFPFC_ADD
+}
+
+func (m *OfpFlowMod) GetIdleTimeout() uint32 {
+	if m != nil {
+		return m.IdleTimeout
+	}
+	return 0
+}
+
+func (m *OfpFlowMod) GetHardTimeout() uint32 {
+	if m != nil {
+		return m.HardTimeout
+	}
+	return 0
+}
+
+func (m *OfpFlowMod) GetPriority() uint32 {
+	if m != nil {
+		return m.Priority
+	}
+	return 0
+}
+
+func (m *OfpFlowMod) GetBufferId() uint32 {
+	if m != nil {
+		return m.BufferId
+	}
+	return 0
+}
+
+func (m *OfpFlowMod) GetOutPort() uint32 {
+	if m != nil {
+		return m.OutPort
+	}
+	return 0
+}
+
+func (m *OfpFlowMod) GetOutGroup() uint32 {
+	if m != nil {
+		return m.OutGroup
+	}
+	return 0
+}
+
+func (m *OfpFlowMod) GetFlags() uint32 {
+	if m != nil {
+		return m.Flags
+	}
+	return 0
+}
+
+func (m *OfpFlowMod) GetMatch() *OfpMatch {
+	if m != nil {
+		return m.Match
+	}
+	return nil
+}
+
+func (m *OfpFlowMod) GetInstructions() []*OfpInstruction {
+	if m != nil {
+		return m.Instructions
+	}
+	return nil
+}
+
+// Bucket for use in groups.
+type OfpBucket struct {
+	Weight     uint32       `protobuf:"varint,1,opt,name=weight" json:"weight,omitempty"`
+	WatchPort  uint32       `protobuf:"varint,2,opt,name=watch_port,json=watchPort" json:"watch_port,omitempty"`
+	WatchGroup uint32       `protobuf:"varint,3,opt,name=watch_group,json=watchGroup" json:"watch_group,omitempty"`
+	Actions    []*OfpAction `protobuf:"bytes,4,rep,name=actions" json:"actions,omitempty"`
+}
+
+func (m *OfpBucket) Reset()                    { *m = OfpBucket{} }
+func (m *OfpBucket) String() string            { return proto.CompactTextString(m) }
+func (*OfpBucket) ProtoMessage()               {}
+func (*OfpBucket) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{30} }
+
+func (m *OfpBucket) GetWeight() uint32 {
+	if m != nil {
+		return m.Weight
+	}
+	return 0
+}
+
+func (m *OfpBucket) GetWatchPort() uint32 {
+	if m != nil {
+		return m.WatchPort
+	}
+	return 0
+}
+
+func (m *OfpBucket) GetWatchGroup() uint32 {
+	if m != nil {
+		return m.WatchGroup
+	}
+	return 0
+}
+
+func (m *OfpBucket) GetActions() []*OfpAction {
+	if m != nil {
+		return m.Actions
+	}
+	return nil
+}
+
+// Group setup and teardown (controller -> datapath).
+type OfpGroupMod struct {
+	// ofp_header header;
+	Command OfpGroupModCommand `protobuf:"varint,1,opt,name=command,enum=openflow_13.OfpGroupModCommand" json:"command,omitempty"`
+	Type    OfpGroupType       `protobuf:"varint,2,opt,name=type,enum=openflow_13.OfpGroupType" json:"type,omitempty"`
+	GroupId uint32             `protobuf:"varint,3,opt,name=group_id,json=groupId" json:"group_id,omitempty"`
+	Buckets []*OfpBucket       `protobuf:"bytes,4,rep,name=buckets" json:"buckets,omitempty"`
+}
+
+func (m *OfpGroupMod) Reset()                    { *m = OfpGroupMod{} }
+func (m *OfpGroupMod) String() string            { return proto.CompactTextString(m) }
+func (*OfpGroupMod) ProtoMessage()               {}
+func (*OfpGroupMod) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{31} }
+
+func (m *OfpGroupMod) GetCommand() OfpGroupModCommand {
+	if m != nil {
+		return m.Command
+	}
+	return OfpGroupModCommand_OFPGC_ADD
+}
+
+func (m *OfpGroupMod) GetType() OfpGroupType {
+	if m != nil {
+		return m.Type
+	}
+	return OfpGroupType_OFPGT_ALL
+}
+
+func (m *OfpGroupMod) GetGroupId() uint32 {
+	if m != nil {
+		return m.GroupId
+	}
+	return 0
+}
+
+func (m *OfpGroupMod) GetBuckets() []*OfpBucket {
+	if m != nil {
+		return m.Buckets
+	}
+	return nil
+}
+
+// Send packet (controller -> datapath).
+type OfpPacketOut struct {
+	// ofp_header header;
+	BufferId uint32       `protobuf:"varint,1,opt,name=buffer_id,json=bufferId" json:"buffer_id,omitempty"`
+	InPort   uint32       `protobuf:"varint,2,opt,name=in_port,json=inPort" json:"in_port,omitempty"`
+	Actions  []*OfpAction `protobuf:"bytes,3,rep,name=actions" json:"actions,omitempty"`
+	// The variable size action list is optionally followed by packet data.
+	// This data is only present and meaningful if buffer_id == -1.
+	Data []byte `protobuf:"bytes,4,opt,name=data,proto3" json:"data,omitempty"`
+}
+
+func (m *OfpPacketOut) Reset()                    { *m = OfpPacketOut{} }
+func (m *OfpPacketOut) String() string            { return proto.CompactTextString(m) }
+func (*OfpPacketOut) ProtoMessage()               {}
+func (*OfpPacketOut) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{32} }
+
+func (m *OfpPacketOut) GetBufferId() uint32 {
+	if m != nil {
+		return m.BufferId
+	}
+	return 0
+}
+
+func (m *OfpPacketOut) GetInPort() uint32 {
+	if m != nil {
+		return m.InPort
+	}
+	return 0
+}
+
+func (m *OfpPacketOut) GetActions() []*OfpAction {
+	if m != nil {
+		return m.Actions
+	}
+	return nil
+}
+
+func (m *OfpPacketOut) GetData() []byte {
+	if m != nil {
+		return m.Data
+	}
+	return nil
+}
+
+// Packet received on port (datapath -> controller).
+type OfpPacketIn struct {
+	// ofp_header header;
+	BufferId uint32            `protobuf:"varint,1,opt,name=buffer_id,json=bufferId" json:"buffer_id,omitempty"`
+	Reason   OfpPacketInReason `protobuf:"varint,2,opt,name=reason,enum=openflow_13.OfpPacketInReason" json:"reason,omitempty"`
+	TableId  uint32            `protobuf:"varint,3,opt,name=table_id,json=tableId" json:"table_id,omitempty"`
+	Cookie   uint64            `protobuf:"varint,4,opt,name=cookie" json:"cookie,omitempty"`
+	Match    *OfpMatch         `protobuf:"bytes,5,opt,name=match" json:"match,omitempty"`
+	Data     []byte            `protobuf:"bytes,6,opt,name=data,proto3" json:"data,omitempty"`
+}
+
+func (m *OfpPacketIn) Reset()                    { *m = OfpPacketIn{} }
+func (m *OfpPacketIn) String() string            { return proto.CompactTextString(m) }
+func (*OfpPacketIn) ProtoMessage()               {}
+func (*OfpPacketIn) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{33} }
+
+func (m *OfpPacketIn) GetBufferId() uint32 {
+	if m != nil {
+		return m.BufferId
+	}
+	return 0
+}
+
+func (m *OfpPacketIn) GetReason() OfpPacketInReason {
+	if m != nil {
+		return m.Reason
+	}
+	return OfpPacketInReason_OFPR_NO_MATCH
+}
+
+func (m *OfpPacketIn) GetTableId() uint32 {
+	if m != nil {
+		return m.TableId
+	}
+	return 0
+}
+
+func (m *OfpPacketIn) GetCookie() uint64 {
+	if m != nil {
+		return m.Cookie
+	}
+	return 0
+}
+
+func (m *OfpPacketIn) GetMatch() *OfpMatch {
+	if m != nil {
+		return m.Match
+	}
+	return nil
+}
+
+func (m *OfpPacketIn) GetData() []byte {
+	if m != nil {
+		return m.Data
+	}
+	return nil
+}
+
+// Flow removed (datapath -> controller).
+type OfpFlowRemoved struct {
+	// ofp_header header;
+	Cookie       uint64               `protobuf:"varint,1,opt,name=cookie" json:"cookie,omitempty"`
+	Priority     uint32               `protobuf:"varint,2,opt,name=priority" json:"priority,omitempty"`
+	Reason       OfpFlowRemovedReason `protobuf:"varint,3,opt,name=reason,enum=openflow_13.OfpFlowRemovedReason" json:"reason,omitempty"`
+	TableId      uint32               `protobuf:"varint,4,opt,name=table_id,json=tableId" json:"table_id,omitempty"`
+	DurationSec  uint32               `protobuf:"varint,5,opt,name=duration_sec,json=durationSec" json:"duration_sec,omitempty"`
+	DurationNsec uint32               `protobuf:"varint,6,opt,name=duration_nsec,json=durationNsec" json:"duration_nsec,omitempty"`
+	IdleTimeout  uint32               `protobuf:"varint,7,opt,name=idle_timeout,json=idleTimeout" json:"idle_timeout,omitempty"`
+	HardTimeout  uint32               `protobuf:"varint,8,opt,name=hard_timeout,json=hardTimeout" json:"hard_timeout,omitempty"`
+	PacketCount  uint64               `protobuf:"varint,9,opt,name=packet_count,json=packetCount" json:"packet_count,omitempty"`
+	ByteCount    uint64               `protobuf:"varint,10,opt,name=byte_count,json=byteCount" json:"byte_count,omitempty"`
+	Match        *OfpMatch            `protobuf:"bytes,121,opt,name=match" json:"match,omitempty"`
+}
+
+func (m *OfpFlowRemoved) Reset()                    { *m = OfpFlowRemoved{} }
+func (m *OfpFlowRemoved) String() string            { return proto.CompactTextString(m) }
+func (*OfpFlowRemoved) ProtoMessage()               {}
+func (*OfpFlowRemoved) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{34} }
+
+func (m *OfpFlowRemoved) GetCookie() uint64 {
+	if m != nil {
+		return m.Cookie
+	}
+	return 0
+}
+
+func (m *OfpFlowRemoved) GetPriority() uint32 {
+	if m != nil {
+		return m.Priority
+	}
+	return 0
+}
+
+func (m *OfpFlowRemoved) GetReason() OfpFlowRemovedReason {
+	if m != nil {
+		return m.Reason
+	}
+	return OfpFlowRemovedReason_OFPRR_IDLE_TIMEOUT
+}
+
+func (m *OfpFlowRemoved) GetTableId() uint32 {
+	if m != nil {
+		return m.TableId
+	}
+	return 0
+}
+
+func (m *OfpFlowRemoved) GetDurationSec() uint32 {
+	if m != nil {
+		return m.DurationSec
+	}
+	return 0
+}
+
+func (m *OfpFlowRemoved) GetDurationNsec() uint32 {
+	if m != nil {
+		return m.DurationNsec
+	}
+	return 0
+}
+
+func (m *OfpFlowRemoved) GetIdleTimeout() uint32 {
+	if m != nil {
+		return m.IdleTimeout
+	}
+	return 0
+}
+
+func (m *OfpFlowRemoved) GetHardTimeout() uint32 {
+	if m != nil {
+		return m.HardTimeout
+	}
+	return 0
+}
+
+func (m *OfpFlowRemoved) GetPacketCount() uint64 {
+	if m != nil {
+		return m.PacketCount
+	}
+	return 0
+}
+
+func (m *OfpFlowRemoved) GetByteCount() uint64 {
+	if m != nil {
+		return m.ByteCount
+	}
+	return 0
+}
+
+func (m *OfpFlowRemoved) GetMatch() *OfpMatch {
+	if m != nil {
+		return m.Match
+	}
+	return nil
+}
+
+// Common header for all meter bands
+type OfpMeterBandHeader struct {
+	Type      OfpMeterBandType `protobuf:"varint,1,opt,name=type,enum=openflow_13.OfpMeterBandType" json:"type,omitempty"`
+	Len       uint32           `protobuf:"varint,2,opt,name=len" json:"len,omitempty"`
+	Rate      uint32           `protobuf:"varint,3,opt,name=rate" json:"rate,omitempty"`
+	BurstSize uint32           `protobuf:"varint,4,opt,name=burst_size,json=burstSize" json:"burst_size,omitempty"`
+}
+
+func (m *OfpMeterBandHeader) Reset()                    { *m = OfpMeterBandHeader{} }
+func (m *OfpMeterBandHeader) String() string            { return proto.CompactTextString(m) }
+func (*OfpMeterBandHeader) ProtoMessage()               {}
+func (*OfpMeterBandHeader) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{35} }
+
+func (m *OfpMeterBandHeader) GetType() OfpMeterBandType {
+	if m != nil {
+		return m.Type
+	}
+	return OfpMeterBandType_OFPMBT_INVALID
+}
+
+func (m *OfpMeterBandHeader) GetLen() uint32 {
+	if m != nil {
+		return m.Len
+	}
+	return 0
+}
+
+func (m *OfpMeterBandHeader) GetRate() uint32 {
+	if m != nil {
+		return m.Rate
+	}
+	return 0
+}
+
+func (m *OfpMeterBandHeader) GetBurstSize() uint32 {
+	if m != nil {
+		return m.BurstSize
+	}
+	return 0
+}
+
+// OFPMBT_DROP band - drop packets
+type OfpMeterBandDrop struct {
+	Type      uint32 `protobuf:"varint,1,opt,name=type" json:"type,omitempty"`
+	Len       uint32 `protobuf:"varint,2,opt,name=len" json:"len,omitempty"`
+	Rate      uint32 `protobuf:"varint,3,opt,name=rate" json:"rate,omitempty"`
+	BurstSize uint32 `protobuf:"varint,4,opt,name=burst_size,json=burstSize" json:"burst_size,omitempty"`
+}
+
+func (m *OfpMeterBandDrop) Reset()                    { *m = OfpMeterBandDrop{} }
+func (m *OfpMeterBandDrop) String() string            { return proto.CompactTextString(m) }
+func (*OfpMeterBandDrop) ProtoMessage()               {}
+func (*OfpMeterBandDrop) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{36} }
+
+func (m *OfpMeterBandDrop) GetType() uint32 {
+	if m != nil {
+		return m.Type
+	}
+	return 0
+}
+
+func (m *OfpMeterBandDrop) GetLen() uint32 {
+	if m != nil {
+		return m.Len
+	}
+	return 0
+}
+
+func (m *OfpMeterBandDrop) GetRate() uint32 {
+	if m != nil {
+		return m.Rate
+	}
+	return 0
+}
+
+func (m *OfpMeterBandDrop) GetBurstSize() uint32 {
+	if m != nil {
+		return m.BurstSize
+	}
+	return 0
+}
+
+// OFPMBT_DSCP_REMARK band - Remark DSCP in the IP header
+type OfpMeterBandDscpRemark struct {
+	Type      uint32 `protobuf:"varint,1,opt,name=type" json:"type,omitempty"`
+	Len       uint32 `protobuf:"varint,2,opt,name=len" json:"len,omitempty"`
+	Rate      uint32 `protobuf:"varint,3,opt,name=rate" json:"rate,omitempty"`
+	BurstSize uint32 `protobuf:"varint,4,opt,name=burst_size,json=burstSize" json:"burst_size,omitempty"`
+	PrecLevel uint32 `protobuf:"varint,5,opt,name=prec_level,json=precLevel" json:"prec_level,omitempty"`
+}
+
+func (m *OfpMeterBandDscpRemark) Reset()                    { *m = OfpMeterBandDscpRemark{} }
+func (m *OfpMeterBandDscpRemark) String() string            { return proto.CompactTextString(m) }
+func (*OfpMeterBandDscpRemark) ProtoMessage()               {}
+func (*OfpMeterBandDscpRemark) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{37} }
+
+func (m *OfpMeterBandDscpRemark) GetType() uint32 {
+	if m != nil {
+		return m.Type
+	}
+	return 0
+}
+
+func (m *OfpMeterBandDscpRemark) GetLen() uint32 {
+	if m != nil {
+		return m.Len
+	}
+	return 0
+}
+
+func (m *OfpMeterBandDscpRemark) GetRate() uint32 {
+	if m != nil {
+		return m.Rate
+	}
+	return 0
+}
+
+func (m *OfpMeterBandDscpRemark) GetBurstSize() uint32 {
+	if m != nil {
+		return m.BurstSize
+	}
+	return 0
+}
+
+func (m *OfpMeterBandDscpRemark) GetPrecLevel() uint32 {
+	if m != nil {
+		return m.PrecLevel
+	}
+	return 0
+}
+
+// OFPMBT_EXPERIMENTER band - Experimenter type.
+// The rest of the band is experimenter-defined.
+type OfpMeterBandExperimenter struct {
+	Type         OfpMeterBandType `protobuf:"varint,1,opt,name=type,enum=openflow_13.OfpMeterBandType" json:"type,omitempty"`
+	Len          uint32           `protobuf:"varint,2,opt,name=len" json:"len,omitempty"`
+	Rate         uint32           `protobuf:"varint,3,opt,name=rate" json:"rate,omitempty"`
+	BurstSize    uint32           `protobuf:"varint,4,opt,name=burst_size,json=burstSize" json:"burst_size,omitempty"`
+	Experimenter uint32           `protobuf:"varint,5,opt,name=experimenter" json:"experimenter,omitempty"`
+}
+
+func (m *OfpMeterBandExperimenter) Reset()                    { *m = OfpMeterBandExperimenter{} }
+func (m *OfpMeterBandExperimenter) String() string            { return proto.CompactTextString(m) }
+func (*OfpMeterBandExperimenter) ProtoMessage()               {}
+func (*OfpMeterBandExperimenter) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{38} }
+
+func (m *OfpMeterBandExperimenter) GetType() OfpMeterBandType {
+	if m != nil {
+		return m.Type
+	}
+	return OfpMeterBandType_OFPMBT_INVALID
+}
+
+func (m *OfpMeterBandExperimenter) GetLen() uint32 {
+	if m != nil {
+		return m.Len
+	}
+	return 0
+}
+
+func (m *OfpMeterBandExperimenter) GetRate() uint32 {
+	if m != nil {
+		return m.Rate
+	}
+	return 0
+}
+
+func (m *OfpMeterBandExperimenter) GetBurstSize() uint32 {
+	if m != nil {
+		return m.BurstSize
+	}
+	return 0
+}
+
+func (m *OfpMeterBandExperimenter) GetExperimenter() uint32 {
+	if m != nil {
+		return m.Experimenter
+	}
+	return 0
+}
+
+// Meter configuration. OFPT_METER_MOD.
+type OfpMeterMod struct {
+	//    ofp_header   header = 1;
+	Command OfpMeterModCommand    `protobuf:"varint,1,opt,name=command,enum=openflow_13.OfpMeterModCommand" json:"command,omitempty"`
+	Flags   uint32                `protobuf:"varint,2,opt,name=flags" json:"flags,omitempty"`
+	MeterId uint32                `protobuf:"varint,3,opt,name=meter_id,json=meterId" json:"meter_id,omitempty"`
+	Bands   []*OfpMeterBandHeader `protobuf:"bytes,4,rep,name=bands" json:"bands,omitempty"`
+}
+
+func (m *OfpMeterMod) Reset()                    { *m = OfpMeterMod{} }
+func (m *OfpMeterMod) String() string            { return proto.CompactTextString(m) }
+func (*OfpMeterMod) ProtoMessage()               {}
+func (*OfpMeterMod) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{39} }
+
+func (m *OfpMeterMod) GetCommand() OfpMeterModCommand {
+	if m != nil {
+		return m.Command
+	}
+	return OfpMeterModCommand_OFPMC_ADD
+}
+
+func (m *OfpMeterMod) GetFlags() uint32 {
+	if m != nil {
+		return m.Flags
+	}
+	return 0
+}
+
+func (m *OfpMeterMod) GetMeterId() uint32 {
+	if m != nil {
+		return m.MeterId
+	}
+	return 0
+}
+
+func (m *OfpMeterMod) GetBands() []*OfpMeterBandHeader {
+	if m != nil {
+		return m.Bands
+	}
+	return nil
+}
+
+// OFPT_ERROR: Error message (datapath -> controller).
+type OfpErrorMsg struct {
+	// ofp_header header;
+	Type uint32 `protobuf:"varint,1,opt,name=type" json:"type,omitempty"`
+	Code uint32 `protobuf:"varint,2,opt,name=code" json:"code,omitempty"`
+	Data []byte `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"`
+}
+
+func (m *OfpErrorMsg) Reset()                    { *m = OfpErrorMsg{} }
+func (m *OfpErrorMsg) String() string            { return proto.CompactTextString(m) }
+func (*OfpErrorMsg) ProtoMessage()               {}
+func (*OfpErrorMsg) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{40} }
+
+func (m *OfpErrorMsg) GetType() uint32 {
+	if m != nil {
+		return m.Type
+	}
+	return 0
+}
+
+func (m *OfpErrorMsg) GetCode() uint32 {
+	if m != nil {
+		return m.Code
+	}
+	return 0
+}
+
+func (m *OfpErrorMsg) GetData() []byte {
+	if m != nil {
+		return m.Data
+	}
+	return nil
+}
+
+// OFPET_EXPERIMENTER: Error message (datapath -> controller).
+type OfpErrorExperimenterMsg struct {
+	Type         uint32 `protobuf:"varint,1,opt,name=type" json:"type,omitempty"`
+	ExpType      uint32 `protobuf:"varint,2,opt,name=exp_type,json=expType" json:"exp_type,omitempty"`
+	Experimenter uint32 `protobuf:"varint,3,opt,name=experimenter" json:"experimenter,omitempty"`
+	Data         []byte `protobuf:"bytes,4,opt,name=data,proto3" json:"data,omitempty"`
+}
+
+func (m *OfpErrorExperimenterMsg) Reset()                    { *m = OfpErrorExperimenterMsg{} }
+func (m *OfpErrorExperimenterMsg) String() string            { return proto.CompactTextString(m) }
+func (*OfpErrorExperimenterMsg) ProtoMessage()               {}
+func (*OfpErrorExperimenterMsg) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{41} }
+
+func (m *OfpErrorExperimenterMsg) GetType() uint32 {
+	if m != nil {
+		return m.Type
+	}
+	return 0
+}
+
+func (m *OfpErrorExperimenterMsg) GetExpType() uint32 {
+	if m != nil {
+		return m.ExpType
+	}
+	return 0
+}
+
+func (m *OfpErrorExperimenterMsg) GetExperimenter() uint32 {
+	if m != nil {
+		return m.Experimenter
+	}
+	return 0
+}
+
+func (m *OfpErrorExperimenterMsg) GetData() []byte {
+	if m != nil {
+		return m.Data
+	}
+	return nil
+}
+
+type OfpMultipartRequest struct {
+	// ofp_header header;
+	Type  OfpMultipartType `protobuf:"varint,1,opt,name=type,enum=openflow_13.OfpMultipartType" json:"type,omitempty"`
+	Flags uint32           `protobuf:"varint,2,opt,name=flags" json:"flags,omitempty"`
+	Body  []byte           `protobuf:"bytes,3,opt,name=body,proto3" json:"body,omitempty"`
+}
+
+func (m *OfpMultipartRequest) Reset()                    { *m = OfpMultipartRequest{} }
+func (m *OfpMultipartRequest) String() string            { return proto.CompactTextString(m) }
+func (*OfpMultipartRequest) ProtoMessage()               {}
+func (*OfpMultipartRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{42} }
+
+func (m *OfpMultipartRequest) GetType() OfpMultipartType {
+	if m != nil {
+		return m.Type
+	}
+	return OfpMultipartType_OFPMP_DESC
+}
+
+func (m *OfpMultipartRequest) GetFlags() uint32 {
+	if m != nil {
+		return m.Flags
+	}
+	return 0
+}
+
+func (m *OfpMultipartRequest) GetBody() []byte {
+	if m != nil {
+		return m.Body
+	}
+	return nil
+}
+
+type OfpMultipartReply struct {
+	// ofp_header header;
+	Type  OfpMultipartType `protobuf:"varint,1,opt,name=type,enum=openflow_13.OfpMultipartType" json:"type,omitempty"`
+	Flags uint32           `protobuf:"varint,2,opt,name=flags" json:"flags,omitempty"`
+	Body  []byte           `protobuf:"bytes,3,opt,name=body,proto3" json:"body,omitempty"`
+}
+
+func (m *OfpMultipartReply) Reset()                    { *m = OfpMultipartReply{} }
+func (m *OfpMultipartReply) String() string            { return proto.CompactTextString(m) }
+func (*OfpMultipartReply) ProtoMessage()               {}
+func (*OfpMultipartReply) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{43} }
+
+func (m *OfpMultipartReply) GetType() OfpMultipartType {
+	if m != nil {
+		return m.Type
+	}
+	return OfpMultipartType_OFPMP_DESC
+}
+
+func (m *OfpMultipartReply) GetFlags() uint32 {
+	if m != nil {
+		return m.Flags
+	}
+	return 0
+}
+
+func (m *OfpMultipartReply) GetBody() []byte {
+	if m != nil {
+		return m.Body
+	}
+	return nil
+}
+
+// Body of reply to OFPMP_DESC request.  Each entry is a NULL-terminated
+// ASCII string.
+type OfpDesc struct {
+	MfrDesc   string `protobuf:"bytes,1,opt,name=mfr_desc,json=mfrDesc" json:"mfr_desc,omitempty"`
+	HwDesc    string `protobuf:"bytes,2,opt,name=hw_desc,json=hwDesc" json:"hw_desc,omitempty"`
+	SwDesc    string `protobuf:"bytes,3,opt,name=sw_desc,json=swDesc" json:"sw_desc,omitempty"`
+	SerialNum string `protobuf:"bytes,4,opt,name=serial_num,json=serialNum" json:"serial_num,omitempty"`
+	DpDesc    string `protobuf:"bytes,5,opt,name=dp_desc,json=dpDesc" json:"dp_desc,omitempty"`
+}
+
+func (m *OfpDesc) Reset()                    { *m = OfpDesc{} }
+func (m *OfpDesc) String() string            { return proto.CompactTextString(m) }
+func (*OfpDesc) ProtoMessage()               {}
+func (*OfpDesc) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{44} }
+
+func (m *OfpDesc) GetMfrDesc() string {
+	if m != nil {
+		return m.MfrDesc
+	}
+	return ""
+}
+
+func (m *OfpDesc) GetHwDesc() string {
+	if m != nil {
+		return m.HwDesc
+	}
+	return ""
+}
+
+func (m *OfpDesc) GetSwDesc() string {
+	if m != nil {
+		return m.SwDesc
+	}
+	return ""
+}
+
+func (m *OfpDesc) GetSerialNum() string {
+	if m != nil {
+		return m.SerialNum
+	}
+	return ""
+}
+
+func (m *OfpDesc) GetDpDesc() string {
+	if m != nil {
+		return m.DpDesc
+	}
+	return ""
+}
+
+// Body for ofp_multipart_request of type OFPMP_FLOW.
+type OfpFlowStatsRequest struct {
+	TableId    uint32    `protobuf:"varint,1,opt,name=table_id,json=tableId" json:"table_id,omitempty"`
+	OutPort    uint32    `protobuf:"varint,2,opt,name=out_port,json=outPort" json:"out_port,omitempty"`
+	OutGroup   uint32    `protobuf:"varint,3,opt,name=out_group,json=outGroup" json:"out_group,omitempty"`
+	Cookie     uint64    `protobuf:"varint,4,opt,name=cookie" json:"cookie,omitempty"`
+	CookieMask uint64    `protobuf:"varint,5,opt,name=cookie_mask,json=cookieMask" json:"cookie_mask,omitempty"`
+	Match      *OfpMatch `protobuf:"bytes,6,opt,name=match" json:"match,omitempty"`
+}
+
+func (m *OfpFlowStatsRequest) Reset()                    { *m = OfpFlowStatsRequest{} }
+func (m *OfpFlowStatsRequest) String() string            { return proto.CompactTextString(m) }
+func (*OfpFlowStatsRequest) ProtoMessage()               {}
+func (*OfpFlowStatsRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{45} }
+
+func (m *OfpFlowStatsRequest) GetTableId() uint32 {
+	if m != nil {
+		return m.TableId
+	}
+	return 0
+}
+
+func (m *OfpFlowStatsRequest) GetOutPort() uint32 {
+	if m != nil {
+		return m.OutPort
+	}
+	return 0
+}
+
+func (m *OfpFlowStatsRequest) GetOutGroup() uint32 {
+	if m != nil {
+		return m.OutGroup
+	}
+	return 0
+}
+
+func (m *OfpFlowStatsRequest) GetCookie() uint64 {
+	if m != nil {
+		return m.Cookie
+	}
+	return 0
+}
+
+func (m *OfpFlowStatsRequest) GetCookieMask() uint64 {
+	if m != nil {
+		return m.CookieMask
+	}
+	return 0
+}
+
+func (m *OfpFlowStatsRequest) GetMatch() *OfpMatch {
+	if m != nil {
+		return m.Match
+	}
+	return nil
+}
+
+// Body of reply to OFPMP_FLOW request.
+type OfpFlowStats struct {
+	Id           uint64            `protobuf:"varint,14,opt,name=id" json:"id,omitempty"`
+	TableId      uint32            `protobuf:"varint,1,opt,name=table_id,json=tableId" json:"table_id,omitempty"`
+	DurationSec  uint32            `protobuf:"varint,2,opt,name=duration_sec,json=durationSec" json:"duration_sec,omitempty"`
+	DurationNsec uint32            `protobuf:"varint,3,opt,name=duration_nsec,json=durationNsec" json:"duration_nsec,omitempty"`
+	Priority     uint32            `protobuf:"varint,4,opt,name=priority" json:"priority,omitempty"`
+	IdleTimeout  uint32            `protobuf:"varint,5,opt,name=idle_timeout,json=idleTimeout" json:"idle_timeout,omitempty"`
+	HardTimeout  uint32            `protobuf:"varint,6,opt,name=hard_timeout,json=hardTimeout" json:"hard_timeout,omitempty"`
+	Flags        uint32            `protobuf:"varint,7,opt,name=flags" json:"flags,omitempty"`
+	Cookie       uint64            `protobuf:"varint,8,opt,name=cookie" json:"cookie,omitempty"`
+	PacketCount  uint64            `protobuf:"varint,9,opt,name=packet_count,json=packetCount" json:"packet_count,omitempty"`
+	ByteCount    uint64            `protobuf:"varint,10,opt,name=byte_count,json=byteCount" json:"byte_count,omitempty"`
+	Match        *OfpMatch         `protobuf:"bytes,12,opt,name=match" json:"match,omitempty"`
+	Instructions []*OfpInstruction `protobuf:"bytes,13,rep,name=instructions" json:"instructions,omitempty"`
+}
+
+func (m *OfpFlowStats) Reset()                    { *m = OfpFlowStats{} }
+func (m *OfpFlowStats) String() string            { return proto.CompactTextString(m) }
+func (*OfpFlowStats) ProtoMessage()               {}
+func (*OfpFlowStats) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{46} }
+
+func (m *OfpFlowStats) GetId() uint64 {
+	if m != nil {
+		return m.Id
+	}
+	return 0
+}
+
+func (m *OfpFlowStats) GetTableId() uint32 {
+	if m != nil {
+		return m.TableId
+	}
+	return 0
+}
+
+func (m *OfpFlowStats) GetDurationSec() uint32 {
+	if m != nil {
+		return m.DurationSec
+	}
+	return 0
+}
+
+func (m *OfpFlowStats) GetDurationNsec() uint32 {
+	if m != nil {
+		return m.DurationNsec
+	}
+	return 0
+}
+
+func (m *OfpFlowStats) GetPriority() uint32 {
+	if m != nil {
+		return m.Priority
+	}
+	return 0
+}
+
+func (m *OfpFlowStats) GetIdleTimeout() uint32 {
+	if m != nil {
+		return m.IdleTimeout
+	}
+	return 0
+}
+
+func (m *OfpFlowStats) GetHardTimeout() uint32 {
+	if m != nil {
+		return m.HardTimeout
+	}
+	return 0
+}
+
+func (m *OfpFlowStats) GetFlags() uint32 {
+	if m != nil {
+		return m.Flags
+	}
+	return 0
+}
+
+func (m *OfpFlowStats) GetCookie() uint64 {
+	if m != nil {
+		return m.Cookie
+	}
+	return 0
+}
+
+func (m *OfpFlowStats) GetPacketCount() uint64 {
+	if m != nil {
+		return m.PacketCount
+	}
+	return 0
+}
+
+func (m *OfpFlowStats) GetByteCount() uint64 {
+	if m != nil {
+		return m.ByteCount
+	}
+	return 0
+}
+
+func (m *OfpFlowStats) GetMatch() *OfpMatch {
+	if m != nil {
+		return m.Match
+	}
+	return nil
+}
+
+func (m *OfpFlowStats) GetInstructions() []*OfpInstruction {
+	if m != nil {
+		return m.Instructions
+	}
+	return nil
+}
+
+// Body for ofp_multipart_request of type OFPMP_AGGREGATE.
+type OfpAggregateStatsRequest struct {
+	TableId    uint32    `protobuf:"varint,1,opt,name=table_id,json=tableId" json:"table_id,omitempty"`
+	OutPort    uint32    `protobuf:"varint,2,opt,name=out_port,json=outPort" json:"out_port,omitempty"`
+	OutGroup   uint32    `protobuf:"varint,3,opt,name=out_group,json=outGroup" json:"out_group,omitempty"`
+	Cookie     uint64    `protobuf:"varint,4,opt,name=cookie" json:"cookie,omitempty"`
+	CookieMask uint64    `protobuf:"varint,5,opt,name=cookie_mask,json=cookieMask" json:"cookie_mask,omitempty"`
+	Match      *OfpMatch `protobuf:"bytes,6,opt,name=match" json:"match,omitempty"`
+}
+
+func (m *OfpAggregateStatsRequest) Reset()                    { *m = OfpAggregateStatsRequest{} }
+func (m *OfpAggregateStatsRequest) String() string            { return proto.CompactTextString(m) }
+func (*OfpAggregateStatsRequest) ProtoMessage()               {}
+func (*OfpAggregateStatsRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{47} }
+
+func (m *OfpAggregateStatsRequest) GetTableId() uint32 {
+	if m != nil {
+		return m.TableId
+	}
+	return 0
+}
+
+func (m *OfpAggregateStatsRequest) GetOutPort() uint32 {
+	if m != nil {
+		return m.OutPort
+	}
+	return 0
+}
+
+func (m *OfpAggregateStatsRequest) GetOutGroup() uint32 {
+	if m != nil {
+		return m.OutGroup
+	}
+	return 0
+}
+
+func (m *OfpAggregateStatsRequest) GetCookie() uint64 {
+	if m != nil {
+		return m.Cookie
+	}
+	return 0
+}
+
+func (m *OfpAggregateStatsRequest) GetCookieMask() uint64 {
+	if m != nil {
+		return m.CookieMask
+	}
+	return 0
+}
+
+func (m *OfpAggregateStatsRequest) GetMatch() *OfpMatch {
+	if m != nil {
+		return m.Match
+	}
+	return nil
+}
+
+// Body of reply to OFPMP_AGGREGATE request.
+type OfpAggregateStatsReply struct {
+	PacketCount uint64 `protobuf:"varint,1,opt,name=packet_count,json=packetCount" json:"packet_count,omitempty"`
+	ByteCount   uint64 `protobuf:"varint,2,opt,name=byte_count,json=byteCount" json:"byte_count,omitempty"`
+	FlowCount   uint32 `protobuf:"varint,3,opt,name=flow_count,json=flowCount" json:"flow_count,omitempty"`
+}
+
+func (m *OfpAggregateStatsReply) Reset()                    { *m = OfpAggregateStatsReply{} }
+func (m *OfpAggregateStatsReply) String() string            { return proto.CompactTextString(m) }
+func (*OfpAggregateStatsReply) ProtoMessage()               {}
+func (*OfpAggregateStatsReply) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{48} }
+
+func (m *OfpAggregateStatsReply) GetPacketCount() uint64 {
+	if m != nil {
+		return m.PacketCount
+	}
+	return 0
+}
+
+func (m *OfpAggregateStatsReply) GetByteCount() uint64 {
+	if m != nil {
+		return m.ByteCount
+	}
+	return 0
+}
+
+func (m *OfpAggregateStatsReply) GetFlowCount() uint32 {
+	if m != nil {
+		return m.FlowCount
+	}
+	return 0
+}
+
+// Common header for all Table Feature Properties
+type OfpTableFeatureProperty struct {
+	Type OfpTableFeaturePropType `protobuf:"varint,1,opt,name=type,enum=openflow_13.OfpTableFeaturePropType" json:"type,omitempty"`
+	// Types that are valid to be assigned to Value:
+	//	*OfpTableFeatureProperty_Instructions
+	//	*OfpTableFeatureProperty_NextTables
+	//	*OfpTableFeatureProperty_Actions
+	//	*OfpTableFeatureProperty_Oxm
+	//	*OfpTableFeatureProperty_Experimenter
+	Value isOfpTableFeatureProperty_Value `protobuf_oneof:"value"`
+}
+
+func (m *OfpTableFeatureProperty) Reset()                    { *m = OfpTableFeatureProperty{} }
+func (m *OfpTableFeatureProperty) String() string            { return proto.CompactTextString(m) }
+func (*OfpTableFeatureProperty) ProtoMessage()               {}
+func (*OfpTableFeatureProperty) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{49} }
+
+type isOfpTableFeatureProperty_Value interface {
+	isOfpTableFeatureProperty_Value()
+}
+
+type OfpTableFeatureProperty_Instructions struct {
+	Instructions *OfpTableFeaturePropInstructions `protobuf:"bytes,2,opt,name=instructions,oneof"`
+}
+type OfpTableFeatureProperty_NextTables struct {
+	NextTables *OfpTableFeaturePropNextTables `protobuf:"bytes,3,opt,name=next_tables,json=nextTables,oneof"`
+}
+type OfpTableFeatureProperty_Actions struct {
+	Actions *OfpTableFeaturePropActions `protobuf:"bytes,4,opt,name=actions,oneof"`
+}
+type OfpTableFeatureProperty_Oxm struct {
+	Oxm *OfpTableFeaturePropOxm `protobuf:"bytes,5,opt,name=oxm,oneof"`
+}
+type OfpTableFeatureProperty_Experimenter struct {
+	Experimenter *OfpTableFeaturePropExperimenter `protobuf:"bytes,6,opt,name=experimenter,oneof"`
+}
+
+func (*OfpTableFeatureProperty_Instructions) isOfpTableFeatureProperty_Value() {}
+func (*OfpTableFeatureProperty_NextTables) isOfpTableFeatureProperty_Value()   {}
+func (*OfpTableFeatureProperty_Actions) isOfpTableFeatureProperty_Value()      {}
+func (*OfpTableFeatureProperty_Oxm) isOfpTableFeatureProperty_Value()          {}
+func (*OfpTableFeatureProperty_Experimenter) isOfpTableFeatureProperty_Value() {}
+
+func (m *OfpTableFeatureProperty) GetValue() isOfpTableFeatureProperty_Value {
+	if m != nil {
+		return m.Value
+	}
+	return nil
+}
+
+func (m *OfpTableFeatureProperty) GetType() OfpTableFeaturePropType {
+	if m != nil {
+		return m.Type
+	}
+	return OfpTableFeaturePropType_OFPTFPT_INSTRUCTIONS
+}
+
+func (m *OfpTableFeatureProperty) GetInstructions() *OfpTableFeaturePropInstructions {
+	if x, ok := m.GetValue().(*OfpTableFeatureProperty_Instructions); ok {
+		return x.Instructions
+	}
+	return nil
+}
+
+func (m *OfpTableFeatureProperty) GetNextTables() *OfpTableFeaturePropNextTables {
+	if x, ok := m.GetValue().(*OfpTableFeatureProperty_NextTables); ok {
+		return x.NextTables
+	}
+	return nil
+}
+
+func (m *OfpTableFeatureProperty) GetActions() *OfpTableFeaturePropActions {
+	if x, ok := m.GetValue().(*OfpTableFeatureProperty_Actions); ok {
+		return x.Actions
+	}
+	return nil
+}
+
+func (m *OfpTableFeatureProperty) GetOxm() *OfpTableFeaturePropOxm {
+	if x, ok := m.GetValue().(*OfpTableFeatureProperty_Oxm); ok {
+		return x.Oxm
+	}
+	return nil
+}
+
+func (m *OfpTableFeatureProperty) GetExperimenter() *OfpTableFeaturePropExperimenter {
+	if x, ok := m.GetValue().(*OfpTableFeatureProperty_Experimenter); ok {
+		return x.Experimenter
+	}
+	return nil
+}
+
+// XXX_OneofFuncs is for the internal use of the proto package.
+func (*OfpTableFeatureProperty) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
+	return _OfpTableFeatureProperty_OneofMarshaler, _OfpTableFeatureProperty_OneofUnmarshaler, _OfpTableFeatureProperty_OneofSizer, []interface{}{
+		(*OfpTableFeatureProperty_Instructions)(nil),
+		(*OfpTableFeatureProperty_NextTables)(nil),
+		(*OfpTableFeatureProperty_Actions)(nil),
+		(*OfpTableFeatureProperty_Oxm)(nil),
+		(*OfpTableFeatureProperty_Experimenter)(nil),
+	}
+}
+
+func _OfpTableFeatureProperty_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
+	m := msg.(*OfpTableFeatureProperty)
+	// value
+	switch x := m.Value.(type) {
+	case *OfpTableFeatureProperty_Instructions:
+		b.EncodeVarint(2<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.Instructions); err != nil {
+			return err
+		}
+	case *OfpTableFeatureProperty_NextTables:
+		b.EncodeVarint(3<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.NextTables); err != nil {
+			return err
+		}
+	case *OfpTableFeatureProperty_Actions:
+		b.EncodeVarint(4<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.Actions); err != nil {
+			return err
+		}
+	case *OfpTableFeatureProperty_Oxm:
+		b.EncodeVarint(5<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.Oxm); err != nil {
+			return err
+		}
+	case *OfpTableFeatureProperty_Experimenter:
+		b.EncodeVarint(6<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.Experimenter); err != nil {
+			return err
+		}
+	case nil:
+	default:
+		return fmt.Errorf("OfpTableFeatureProperty.Value has unexpected type %T", x)
+	}
+	return nil
+}
+
+func _OfpTableFeatureProperty_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
+	m := msg.(*OfpTableFeatureProperty)
+	switch tag {
+	case 2: // value.instructions
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(OfpTableFeaturePropInstructions)
+		err := b.DecodeMessage(msg)
+		m.Value = &OfpTableFeatureProperty_Instructions{msg}
+		return true, err
+	case 3: // value.next_tables
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(OfpTableFeaturePropNextTables)
+		err := b.DecodeMessage(msg)
+		m.Value = &OfpTableFeatureProperty_NextTables{msg}
+		return true, err
+	case 4: // value.actions
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(OfpTableFeaturePropActions)
+		err := b.DecodeMessage(msg)
+		m.Value = &OfpTableFeatureProperty_Actions{msg}
+		return true, err
+	case 5: // value.oxm
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(OfpTableFeaturePropOxm)
+		err := b.DecodeMessage(msg)
+		m.Value = &OfpTableFeatureProperty_Oxm{msg}
+		return true, err
+	case 6: // value.experimenter
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(OfpTableFeaturePropExperimenter)
+		err := b.DecodeMessage(msg)
+		m.Value = &OfpTableFeatureProperty_Experimenter{msg}
+		return true, err
+	default:
+		return false, nil
+	}
+}
+
+func _OfpTableFeatureProperty_OneofSizer(msg proto.Message) (n int) {
+	m := msg.(*OfpTableFeatureProperty)
+	// value
+	switch x := m.Value.(type) {
+	case *OfpTableFeatureProperty_Instructions:
+		s := proto.Size(x.Instructions)
+		n += proto.SizeVarint(2<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case *OfpTableFeatureProperty_NextTables:
+		s := proto.Size(x.NextTables)
+		n += proto.SizeVarint(3<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case *OfpTableFeatureProperty_Actions:
+		s := proto.Size(x.Actions)
+		n += proto.SizeVarint(4<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case *OfpTableFeatureProperty_Oxm:
+		s := proto.Size(x.Oxm)
+		n += proto.SizeVarint(5<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case *OfpTableFeatureProperty_Experimenter:
+		s := proto.Size(x.Experimenter)
+		n += proto.SizeVarint(6<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case nil:
+	default:
+		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
+	}
+	return n
+}
+
+// Instructions property
+type OfpTableFeaturePropInstructions struct {
+	// One of OFPTFPT_INSTRUCTIONS,
+	// OFPTFPT_INSTRUCTIONS_MISS.
+	Instructions []*OfpInstruction `protobuf:"bytes,1,rep,name=instructions" json:"instructions,omitempty"`
+}
+
+func (m *OfpTableFeaturePropInstructions) Reset()         { *m = OfpTableFeaturePropInstructions{} }
+func (m *OfpTableFeaturePropInstructions) String() string { return proto.CompactTextString(m) }
+func (*OfpTableFeaturePropInstructions) ProtoMessage()    {}
+func (*OfpTableFeaturePropInstructions) Descriptor() ([]byte, []int) {
+	return fileDescriptor0, []int{50}
+}
+
+func (m *OfpTableFeaturePropInstructions) GetInstructions() []*OfpInstruction {
+	if m != nil {
+		return m.Instructions
+	}
+	return nil
+}
+
+// Next Tables property
+type OfpTableFeaturePropNextTables struct {
+	// One of OFPTFPT_NEXT_TABLES,
+	// OFPTFPT_NEXT_TABLES_MISS.
+	NextTableIds []uint32 `protobuf:"varint,1,rep,packed,name=next_table_ids,json=nextTableIds" json:"next_table_ids,omitempty"`
+}
+
+func (m *OfpTableFeaturePropNextTables) Reset()                    { *m = OfpTableFeaturePropNextTables{} }
+func (m *OfpTableFeaturePropNextTables) String() string            { return proto.CompactTextString(m) }
+func (*OfpTableFeaturePropNextTables) ProtoMessage()               {}
+func (*OfpTableFeaturePropNextTables) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{51} }
+
+func (m *OfpTableFeaturePropNextTables) GetNextTableIds() []uint32 {
+	if m != nil {
+		return m.NextTableIds
+	}
+	return nil
+}
+
+// Actions property
+type OfpTableFeaturePropActions struct {
+	// One of OFPTFPT_WRITE_ACTIONS,
+	// OFPTFPT_WRITE_ACTIONS_MISS,
+	// OFPTFPT_APPLY_ACTIONS,
+	// OFPTFPT_APPLY_ACTIONS_MISS.
+	Actions []*OfpAction `protobuf:"bytes,1,rep,name=actions" json:"actions,omitempty"`
+}
+
+func (m *OfpTableFeaturePropActions) Reset()                    { *m = OfpTableFeaturePropActions{} }
+func (m *OfpTableFeaturePropActions) String() string            { return proto.CompactTextString(m) }
+func (*OfpTableFeaturePropActions) ProtoMessage()               {}
+func (*OfpTableFeaturePropActions) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{52} }
+
+func (m *OfpTableFeaturePropActions) GetActions() []*OfpAction {
+	if m != nil {
+		return m.Actions
+	}
+	return nil
+}
+
+// Match, Wildcard or Set-Field property
+type OfpTableFeaturePropOxm struct {
+	// TODO is this a uint32???
+	OxmIds []uint32 `protobuf:"varint,3,rep,packed,name=oxm_ids,json=oxmIds" json:"oxm_ids,omitempty"`
+}
+
+func (m *OfpTableFeaturePropOxm) Reset()                    { *m = OfpTableFeaturePropOxm{} }
+func (m *OfpTableFeaturePropOxm) String() string            { return proto.CompactTextString(m) }
+func (*OfpTableFeaturePropOxm) ProtoMessage()               {}
+func (*OfpTableFeaturePropOxm) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{53} }
+
+func (m *OfpTableFeaturePropOxm) GetOxmIds() []uint32 {
+	if m != nil {
+		return m.OxmIds
+	}
+	return nil
+}
+
+// Experimenter table feature property
+type OfpTableFeaturePropExperimenter struct {
+	// One of OFPTFPT_EXPERIMENTER,
+	// OFPTFPT_EXPERIMENTER_MISS.
+	Experimenter     uint32   `protobuf:"varint,2,opt,name=experimenter" json:"experimenter,omitempty"`
+	ExpType          uint32   `protobuf:"varint,3,opt,name=exp_type,json=expType" json:"exp_type,omitempty"`
+	ExperimenterData []uint32 `protobuf:"varint,4,rep,packed,name=experimenter_data,json=experimenterData" json:"experimenter_data,omitempty"`
+}
+
+func (m *OfpTableFeaturePropExperimenter) Reset()         { *m = OfpTableFeaturePropExperimenter{} }
+func (m *OfpTableFeaturePropExperimenter) String() string { return proto.CompactTextString(m) }
+func (*OfpTableFeaturePropExperimenter) ProtoMessage()    {}
+func (*OfpTableFeaturePropExperimenter) Descriptor() ([]byte, []int) {
+	return fileDescriptor0, []int{54}
+}
+
+func (m *OfpTableFeaturePropExperimenter) GetExperimenter() uint32 {
+	if m != nil {
+		return m.Experimenter
+	}
+	return 0
+}
+
+func (m *OfpTableFeaturePropExperimenter) GetExpType() uint32 {
+	if m != nil {
+		return m.ExpType
+	}
+	return 0
+}
+
+func (m *OfpTableFeaturePropExperimenter) GetExperimenterData() []uint32 {
+	if m != nil {
+		return m.ExperimenterData
+	}
+	return nil
+}
+
+// Body for ofp_multipart_request of type OFPMP_TABLE_FEATURES./
+// Body of reply to OFPMP_TABLE_FEATURES request.
+type OfpTableFeatures struct {
+	TableId       uint32 `protobuf:"varint,1,opt,name=table_id,json=tableId" json:"table_id,omitempty"`
+	Name          string `protobuf:"bytes,2,opt,name=name" json:"name,omitempty"`
+	MetadataMatch uint64 `protobuf:"varint,3,opt,name=metadata_match,json=metadataMatch" json:"metadata_match,omitempty"`
+	MetadataWrite uint64 `protobuf:"varint,4,opt,name=metadata_write,json=metadataWrite" json:"metadata_write,omitempty"`
+	Config        uint32 `protobuf:"varint,5,opt,name=config" json:"config,omitempty"`
+	MaxEntries    uint32 `protobuf:"varint,6,opt,name=max_entries,json=maxEntries" json:"max_entries,omitempty"`
+	// Table Feature Property list
+	Properties []*OfpTableFeatureProperty `protobuf:"bytes,7,rep,name=properties" json:"properties,omitempty"`
+}
+
+func (m *OfpTableFeatures) Reset()                    { *m = OfpTableFeatures{} }
+func (m *OfpTableFeatures) String() string            { return proto.CompactTextString(m) }
+func (*OfpTableFeatures) ProtoMessage()               {}
+func (*OfpTableFeatures) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{55} }
+
+func (m *OfpTableFeatures) GetTableId() uint32 {
+	if m != nil {
+		return m.TableId
+	}
+	return 0
+}
+
+func (m *OfpTableFeatures) GetName() string {
+	if m != nil {
+		return m.Name
+	}
+	return ""
+}
+
+func (m *OfpTableFeatures) GetMetadataMatch() uint64 {
+	if m != nil {
+		return m.MetadataMatch
+	}
+	return 0
+}
+
+func (m *OfpTableFeatures) GetMetadataWrite() uint64 {
+	if m != nil {
+		return m.MetadataWrite
+	}
+	return 0
+}
+
+func (m *OfpTableFeatures) GetConfig() uint32 {
+	if m != nil {
+		return m.Config
+	}
+	return 0
+}
+
+func (m *OfpTableFeatures) GetMaxEntries() uint32 {
+	if m != nil {
+		return m.MaxEntries
+	}
+	return 0
+}
+
+func (m *OfpTableFeatures) GetProperties() []*OfpTableFeatureProperty {
+	if m != nil {
+		return m.Properties
+	}
+	return nil
+}
+
+// Body of reply to OFPMP_TABLE request.
+type OfpTableStats struct {
+	TableId      uint32 `protobuf:"varint,1,opt,name=table_id,json=tableId" json:"table_id,omitempty"`
+	ActiveCount  uint32 `protobuf:"varint,2,opt,name=active_count,json=activeCount" json:"active_count,omitempty"`
+	LookupCount  uint64 `protobuf:"varint,3,opt,name=lookup_count,json=lookupCount" json:"lookup_count,omitempty"`
+	MatchedCount uint64 `protobuf:"varint,4,opt,name=matched_count,json=matchedCount" json:"matched_count,omitempty"`
+}
+
+func (m *OfpTableStats) Reset()                    { *m = OfpTableStats{} }
+func (m *OfpTableStats) String() string            { return proto.CompactTextString(m) }
+func (*OfpTableStats) ProtoMessage()               {}
+func (*OfpTableStats) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{56} }
+
+func (m *OfpTableStats) GetTableId() uint32 {
+	if m != nil {
+		return m.TableId
+	}
+	return 0
+}
+
+func (m *OfpTableStats) GetActiveCount() uint32 {
+	if m != nil {
+		return m.ActiveCount
+	}
+	return 0
+}
+
+func (m *OfpTableStats) GetLookupCount() uint64 {
+	if m != nil {
+		return m.LookupCount
+	}
+	return 0
+}
+
+func (m *OfpTableStats) GetMatchedCount() uint64 {
+	if m != nil {
+		return m.MatchedCount
+	}
+	return 0
+}
+
+// Body for ofp_multipart_request of type OFPMP_PORT.
+type OfpPortStatsRequest struct {
+	PortNo uint32 `protobuf:"varint,1,opt,name=port_no,json=portNo" json:"port_no,omitempty"`
+}
+
+func (m *OfpPortStatsRequest) Reset()                    { *m = OfpPortStatsRequest{} }
+func (m *OfpPortStatsRequest) String() string            { return proto.CompactTextString(m) }
+func (*OfpPortStatsRequest) ProtoMessage()               {}
+func (*OfpPortStatsRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{57} }
+
+func (m *OfpPortStatsRequest) GetPortNo() uint32 {
+	if m != nil {
+		return m.PortNo
+	}
+	return 0
+}
+
+// Body of reply to OFPMP_PORT request. If a counter is unsupported, set
+// the field to all ones.
+type OfpPortStats struct {
+	PortNo       uint32 `protobuf:"varint,1,opt,name=port_no,json=portNo" json:"port_no,omitempty"`
+	RxPackets    uint64 `protobuf:"varint,2,opt,name=rx_packets,json=rxPackets" json:"rx_packets,omitempty"`
+	TxPackets    uint64 `protobuf:"varint,3,opt,name=tx_packets,json=txPackets" json:"tx_packets,omitempty"`
+	RxBytes      uint64 `protobuf:"varint,4,opt,name=rx_bytes,json=rxBytes" json:"rx_bytes,omitempty"`
+	TxBytes      uint64 `protobuf:"varint,5,opt,name=tx_bytes,json=txBytes" json:"tx_bytes,omitempty"`
+	RxDropped    uint64 `protobuf:"varint,6,opt,name=rx_dropped,json=rxDropped" json:"rx_dropped,omitempty"`
+	TxDropped    uint64 `protobuf:"varint,7,opt,name=tx_dropped,json=txDropped" json:"tx_dropped,omitempty"`
+	RxErrors     uint64 `protobuf:"varint,8,opt,name=rx_errors,json=rxErrors" json:"rx_errors,omitempty"`
+	TxErrors     uint64 `protobuf:"varint,9,opt,name=tx_errors,json=txErrors" json:"tx_errors,omitempty"`
+	RxFrameErr   uint64 `protobuf:"varint,10,opt,name=rx_frame_err,json=rxFrameErr" json:"rx_frame_err,omitempty"`
+	RxOverErr    uint64 `protobuf:"varint,11,opt,name=rx_over_err,json=rxOverErr" json:"rx_over_err,omitempty"`
+	RxCrcErr     uint64 `protobuf:"varint,12,opt,name=rx_crc_err,json=rxCrcErr" json:"rx_crc_err,omitempty"`
+	Collisions   uint64 `protobuf:"varint,13,opt,name=collisions" json:"collisions,omitempty"`
+	DurationSec  uint32 `protobuf:"varint,14,opt,name=duration_sec,json=durationSec" json:"duration_sec,omitempty"`
+	DurationNsec uint32 `protobuf:"varint,15,opt,name=duration_nsec,json=durationNsec" json:"duration_nsec,omitempty"`
+}
+
+func (m *OfpPortStats) Reset()                    { *m = OfpPortStats{} }
+func (m *OfpPortStats) String() string            { return proto.CompactTextString(m) }
+func (*OfpPortStats) ProtoMessage()               {}
+func (*OfpPortStats) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{58} }
+
+func (m *OfpPortStats) GetPortNo() uint32 {
+	if m != nil {
+		return m.PortNo
+	}
+	return 0
+}
+
+func (m *OfpPortStats) GetRxPackets() uint64 {
+	if m != nil {
+		return m.RxPackets
+	}
+	return 0
+}
+
+func (m *OfpPortStats) GetTxPackets() uint64 {
+	if m != nil {
+		return m.TxPackets
+	}
+	return 0
+}
+
+func (m *OfpPortStats) GetRxBytes() uint64 {
+	if m != nil {
+		return m.RxBytes
+	}
+	return 0
+}
+
+func (m *OfpPortStats) GetTxBytes() uint64 {
+	if m != nil {
+		return m.TxBytes
+	}
+	return 0
+}
+
+func (m *OfpPortStats) GetRxDropped() uint64 {
+	if m != nil {
+		return m.RxDropped
+	}
+	return 0
+}
+
+func (m *OfpPortStats) GetTxDropped() uint64 {
+	if m != nil {
+		return m.TxDropped
+	}
+	return 0
+}
+
+func (m *OfpPortStats) GetRxErrors() uint64 {
+	if m != nil {
+		return m.RxErrors
+	}
+	return 0
+}
+
+func (m *OfpPortStats) GetTxErrors() uint64 {
+	if m != nil {
+		return m.TxErrors
+	}
+	return 0
+}
+
+func (m *OfpPortStats) GetRxFrameErr() uint64 {
+	if m != nil {
+		return m.RxFrameErr
+	}
+	return 0
+}
+
+func (m *OfpPortStats) GetRxOverErr() uint64 {
+	if m != nil {
+		return m.RxOverErr
+	}
+	return 0
+}
+
+func (m *OfpPortStats) GetRxCrcErr() uint64 {
+	if m != nil {
+		return m.RxCrcErr
+	}
+	return 0
+}
+
+func (m *OfpPortStats) GetCollisions() uint64 {
+	if m != nil {
+		return m.Collisions
+	}
+	return 0
+}
+
+func (m *OfpPortStats) GetDurationSec() uint32 {
+	if m != nil {
+		return m.DurationSec
+	}
+	return 0
+}
+
+func (m *OfpPortStats) GetDurationNsec() uint32 {
+	if m != nil {
+		return m.DurationNsec
+	}
+	return 0
+}
+
+// Body of OFPMP_GROUP request.
+type OfpGroupStatsRequest struct {
+	GroupId uint32 `protobuf:"varint,1,opt,name=group_id,json=groupId" json:"group_id,omitempty"`
+}
+
+func (m *OfpGroupStatsRequest) Reset()                    { *m = OfpGroupStatsRequest{} }
+func (m *OfpGroupStatsRequest) String() string            { return proto.CompactTextString(m) }
+func (*OfpGroupStatsRequest) ProtoMessage()               {}
+func (*OfpGroupStatsRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{59} }
+
+func (m *OfpGroupStatsRequest) GetGroupId() uint32 {
+	if m != nil {
+		return m.GroupId
+	}
+	return 0
+}
+
+// Used in group stats replies.
+type OfpBucketCounter struct {
+	PacketCount uint64 `protobuf:"varint,1,opt,name=packet_count,json=packetCount" json:"packet_count,omitempty"`
+	ByteCount   uint64 `protobuf:"varint,2,opt,name=byte_count,json=byteCount" json:"byte_count,omitempty"`
+}
+
+func (m *OfpBucketCounter) Reset()                    { *m = OfpBucketCounter{} }
+func (m *OfpBucketCounter) String() string            { return proto.CompactTextString(m) }
+func (*OfpBucketCounter) ProtoMessage()               {}
+func (*OfpBucketCounter) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{60} }
+
+func (m *OfpBucketCounter) GetPacketCount() uint64 {
+	if m != nil {
+		return m.PacketCount
+	}
+	return 0
+}
+
+func (m *OfpBucketCounter) GetByteCount() uint64 {
+	if m != nil {
+		return m.ByteCount
+	}
+	return 0
+}
+
+// Body of reply to OFPMP_GROUP request.
+type OfpGroupStats struct {
+	GroupId      uint32              `protobuf:"varint,1,opt,name=group_id,json=groupId" json:"group_id,omitempty"`
+	RefCount     uint32              `protobuf:"varint,2,opt,name=ref_count,json=refCount" json:"ref_count,omitempty"`
+	PacketCount  uint64              `protobuf:"varint,3,opt,name=packet_count,json=packetCount" json:"packet_count,omitempty"`
+	ByteCount    uint64              `protobuf:"varint,4,opt,name=byte_count,json=byteCount" json:"byte_count,omitempty"`
+	DurationSec  uint32              `protobuf:"varint,5,opt,name=duration_sec,json=durationSec" json:"duration_sec,omitempty"`
+	DurationNsec uint32              `protobuf:"varint,6,opt,name=duration_nsec,json=durationNsec" json:"duration_nsec,omitempty"`
+	BucketStats  []*OfpBucketCounter `protobuf:"bytes,7,rep,name=bucket_stats,json=bucketStats" json:"bucket_stats,omitempty"`
+}
+
+func (m *OfpGroupStats) Reset()                    { *m = OfpGroupStats{} }
+func (m *OfpGroupStats) String() string            { return proto.CompactTextString(m) }
+func (*OfpGroupStats) ProtoMessage()               {}
+func (*OfpGroupStats) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{61} }
+
+func (m *OfpGroupStats) GetGroupId() uint32 {
+	if m != nil {
+		return m.GroupId
+	}
+	return 0
+}
+
+func (m *OfpGroupStats) GetRefCount() uint32 {
+	if m != nil {
+		return m.RefCount
+	}
+	return 0
+}
+
+func (m *OfpGroupStats) GetPacketCount() uint64 {
+	if m != nil {
+		return m.PacketCount
+	}
+	return 0
+}
+
+func (m *OfpGroupStats) GetByteCount() uint64 {
+	if m != nil {
+		return m.ByteCount
+	}
+	return 0
+}
+
+func (m *OfpGroupStats) GetDurationSec() uint32 {
+	if m != nil {
+		return m.DurationSec
+	}
+	return 0
+}
+
+func (m *OfpGroupStats) GetDurationNsec() uint32 {
+	if m != nil {
+		return m.DurationNsec
+	}
+	return 0
+}
+
+func (m *OfpGroupStats) GetBucketStats() []*OfpBucketCounter {
+	if m != nil {
+		return m.BucketStats
+	}
+	return nil
+}
+
+// Body of reply to OFPMP_GROUP_DESC request.
+type OfpGroupDesc struct {
+	Type    OfpGroupType `protobuf:"varint,1,opt,name=type,enum=openflow_13.OfpGroupType" json:"type,omitempty"`
+	GroupId uint32       `protobuf:"varint,2,opt,name=group_id,json=groupId" json:"group_id,omitempty"`
+	Buckets []*OfpBucket `protobuf:"bytes,3,rep,name=buckets" json:"buckets,omitempty"`
+}
+
+func (m *OfpGroupDesc) Reset()                    { *m = OfpGroupDesc{} }
+func (m *OfpGroupDesc) String() string            { return proto.CompactTextString(m) }
+func (*OfpGroupDesc) ProtoMessage()               {}
+func (*OfpGroupDesc) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{62} }
+
+func (m *OfpGroupDesc) GetType() OfpGroupType {
+	if m != nil {
+		return m.Type
+	}
+	return OfpGroupType_OFPGT_ALL
+}
+
+func (m *OfpGroupDesc) GetGroupId() uint32 {
+	if m != nil {
+		return m.GroupId
+	}
+	return 0
+}
+
+func (m *OfpGroupDesc) GetBuckets() []*OfpBucket {
+	if m != nil {
+		return m.Buckets
+	}
+	return nil
+}
+
+type OfpGroupEntry struct {
+	Desc  *OfpGroupDesc  `protobuf:"bytes,1,opt,name=desc" json:"desc,omitempty"`
+	Stats *OfpGroupStats `protobuf:"bytes,2,opt,name=stats" json:"stats,omitempty"`
+}
+
+func (m *OfpGroupEntry) Reset()                    { *m = OfpGroupEntry{} }
+func (m *OfpGroupEntry) String() string            { return proto.CompactTextString(m) }
+func (*OfpGroupEntry) ProtoMessage()               {}
+func (*OfpGroupEntry) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{63} }
+
+func (m *OfpGroupEntry) GetDesc() *OfpGroupDesc {
+	if m != nil {
+		return m.Desc
+	}
+	return nil
+}
+
+func (m *OfpGroupEntry) GetStats() *OfpGroupStats {
+	if m != nil {
+		return m.Stats
+	}
+	return nil
+}
+
+// Body of reply to OFPMP_GROUP_FEATURES request. Group features.
+type OfpGroupFeatures struct {
+	Types        uint32   `protobuf:"varint,1,opt,name=types" json:"types,omitempty"`
+	Capabilities uint32   `protobuf:"varint,2,opt,name=capabilities" json:"capabilities,omitempty"`
+	MaxGroups    []uint32 `protobuf:"varint,3,rep,packed,name=max_groups,json=maxGroups" json:"max_groups,omitempty"`
+	Actions      []uint32 `protobuf:"varint,4,rep,packed,name=actions" json:"actions,omitempty"`
+}
+
+func (m *OfpGroupFeatures) Reset()                    { *m = OfpGroupFeatures{} }
+func (m *OfpGroupFeatures) String() string            { return proto.CompactTextString(m) }
+func (*OfpGroupFeatures) ProtoMessage()               {}
+func (*OfpGroupFeatures) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{64} }
+
+func (m *OfpGroupFeatures) GetTypes() uint32 {
+	if m != nil {
+		return m.Types
+	}
+	return 0
+}
+
+func (m *OfpGroupFeatures) GetCapabilities() uint32 {
+	if m != nil {
+		return m.Capabilities
+	}
+	return 0
+}
+
+func (m *OfpGroupFeatures) GetMaxGroups() []uint32 {
+	if m != nil {
+		return m.MaxGroups
+	}
+	return nil
+}
+
+func (m *OfpGroupFeatures) GetActions() []uint32 {
+	if m != nil {
+		return m.Actions
+	}
+	return nil
+}
+
+// Body of OFPMP_METER and OFPMP_METER_CONFIG requests.
+type OfpMeterMultipartRequest struct {
+	MeterId uint32 `protobuf:"varint,1,opt,name=meter_id,json=meterId" json:"meter_id,omitempty"`
+}
+
+func (m *OfpMeterMultipartRequest) Reset()                    { *m = OfpMeterMultipartRequest{} }
+func (m *OfpMeterMultipartRequest) String() string            { return proto.CompactTextString(m) }
+func (*OfpMeterMultipartRequest) ProtoMessage()               {}
+func (*OfpMeterMultipartRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{65} }
+
+func (m *OfpMeterMultipartRequest) GetMeterId() uint32 {
+	if m != nil {
+		return m.MeterId
+	}
+	return 0
+}
+
+// Statistics for each meter band
+type OfpMeterBandStats struct {
+	PacketBandCount uint64 `protobuf:"varint,1,opt,name=packet_band_count,json=packetBandCount" json:"packet_band_count,omitempty"`
+	ByteBandCount   uint64 `protobuf:"varint,2,opt,name=byte_band_count,json=byteBandCount" json:"byte_band_count,omitempty"`
+}
+
+func (m *OfpMeterBandStats) Reset()                    { *m = OfpMeterBandStats{} }
+func (m *OfpMeterBandStats) String() string            { return proto.CompactTextString(m) }
+func (*OfpMeterBandStats) ProtoMessage()               {}
+func (*OfpMeterBandStats) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{66} }
+
+func (m *OfpMeterBandStats) GetPacketBandCount() uint64 {
+	if m != nil {
+		return m.PacketBandCount
+	}
+	return 0
+}
+
+func (m *OfpMeterBandStats) GetByteBandCount() uint64 {
+	if m != nil {
+		return m.ByteBandCount
+	}
+	return 0
+}
+
+// Body of reply to OFPMP_METER request. Meter statistics.
+type OfpMeterStats struct {
+	MeterId       uint32               `protobuf:"varint,1,opt,name=meter_id,json=meterId" json:"meter_id,omitempty"`
+	FlowCount     uint32               `protobuf:"varint,2,opt,name=flow_count,json=flowCount" json:"flow_count,omitempty"`
+	PacketInCount uint64               `protobuf:"varint,3,opt,name=packet_in_count,json=packetInCount" json:"packet_in_count,omitempty"`
+	ByteInCount   uint64               `protobuf:"varint,4,opt,name=byte_in_count,json=byteInCount" json:"byte_in_count,omitempty"`
+	DurationSec   uint32               `protobuf:"varint,5,opt,name=duration_sec,json=durationSec" json:"duration_sec,omitempty"`
+	DurationNsec  uint32               `protobuf:"varint,6,opt,name=duration_nsec,json=durationNsec" json:"duration_nsec,omitempty"`
+	BandStats     []*OfpMeterBandStats `protobuf:"bytes,7,rep,name=band_stats,json=bandStats" json:"band_stats,omitempty"`
+}
+
+func (m *OfpMeterStats) Reset()                    { *m = OfpMeterStats{} }
+func (m *OfpMeterStats) String() string            { return proto.CompactTextString(m) }
+func (*OfpMeterStats) ProtoMessage()               {}
+func (*OfpMeterStats) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{67} }
+
+func (m *OfpMeterStats) GetMeterId() uint32 {
+	if m != nil {
+		return m.MeterId
+	}
+	return 0
+}
+
+func (m *OfpMeterStats) GetFlowCount() uint32 {
+	if m != nil {
+		return m.FlowCount
+	}
+	return 0
+}
+
+func (m *OfpMeterStats) GetPacketInCount() uint64 {
+	if m != nil {
+		return m.PacketInCount
+	}
+	return 0
+}
+
+func (m *OfpMeterStats) GetByteInCount() uint64 {
+	if m != nil {
+		return m.ByteInCount
+	}
+	return 0
+}
+
+func (m *OfpMeterStats) GetDurationSec() uint32 {
+	if m != nil {
+		return m.DurationSec
+	}
+	return 0
+}
+
+func (m *OfpMeterStats) GetDurationNsec() uint32 {
+	if m != nil {
+		return m.DurationNsec
+	}
+	return 0
+}
+
+func (m *OfpMeterStats) GetBandStats() []*OfpMeterBandStats {
+	if m != nil {
+		return m.BandStats
+	}
+	return nil
+}
+
+// Body of reply to OFPMP_METER_CONFIG request. Meter configuration.
+type OfpMeterConfig struct {
+	Flags   uint32                `protobuf:"varint,1,opt,name=flags" json:"flags,omitempty"`
+	MeterId uint32                `protobuf:"varint,2,opt,name=meter_id,json=meterId" json:"meter_id,omitempty"`
+	Bands   []*OfpMeterBandHeader `protobuf:"bytes,3,rep,name=bands" json:"bands,omitempty"`
+}
+
+func (m *OfpMeterConfig) Reset()                    { *m = OfpMeterConfig{} }
+func (m *OfpMeterConfig) String() string            { return proto.CompactTextString(m) }
+func (*OfpMeterConfig) ProtoMessage()               {}
+func (*OfpMeterConfig) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{68} }
+
+func (m *OfpMeterConfig) GetFlags() uint32 {
+	if m != nil {
+		return m.Flags
+	}
+	return 0
+}
+
+func (m *OfpMeterConfig) GetMeterId() uint32 {
+	if m != nil {
+		return m.MeterId
+	}
+	return 0
+}
+
+func (m *OfpMeterConfig) GetBands() []*OfpMeterBandHeader {
+	if m != nil {
+		return m.Bands
+	}
+	return nil
+}
+
+// Body of reply to OFPMP_METER_FEATURES request. Meter features.
+type OfpMeterFeatures struct {
+	MaxMeter     uint32 `protobuf:"varint,1,opt,name=max_meter,json=maxMeter" json:"max_meter,omitempty"`
+	BandTypes    uint32 `protobuf:"varint,2,opt,name=band_types,json=bandTypes" json:"band_types,omitempty"`
+	Capabilities uint32 `protobuf:"varint,3,opt,name=capabilities" json:"capabilities,omitempty"`
+	MaxBands     uint32 `protobuf:"varint,4,opt,name=max_bands,json=maxBands" json:"max_bands,omitempty"`
+	MaxColor     uint32 `protobuf:"varint,5,opt,name=max_color,json=maxColor" json:"max_color,omitempty"`
+}
+
+func (m *OfpMeterFeatures) Reset()                    { *m = OfpMeterFeatures{} }
+func (m *OfpMeterFeatures) String() string            { return proto.CompactTextString(m) }
+func (*OfpMeterFeatures) ProtoMessage()               {}
+func (*OfpMeterFeatures) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{69} }
+
+func (m *OfpMeterFeatures) GetMaxMeter() uint32 {
+	if m != nil {
+		return m.MaxMeter
+	}
+	return 0
+}
+
+func (m *OfpMeterFeatures) GetBandTypes() uint32 {
+	if m != nil {
+		return m.BandTypes
+	}
+	return 0
+}
+
+func (m *OfpMeterFeatures) GetCapabilities() uint32 {
+	if m != nil {
+		return m.Capabilities
+	}
+	return 0
+}
+
+func (m *OfpMeterFeatures) GetMaxBands() uint32 {
+	if m != nil {
+		return m.MaxBands
+	}
+	return 0
+}
+
+func (m *OfpMeterFeatures) GetMaxColor() uint32 {
+	if m != nil {
+		return m.MaxColor
+	}
+	return 0
+}
+
+// Body for ofp_multipart_request/reply of type OFPMP_EXPERIMENTER.
+type OfpExperimenterMultipartHeader struct {
+	Experimenter uint32 `protobuf:"varint,1,opt,name=experimenter" json:"experimenter,omitempty"`
+	ExpType      uint32 `protobuf:"varint,2,opt,name=exp_type,json=expType" json:"exp_type,omitempty"`
+	Data         []byte `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"`
+}
+
+func (m *OfpExperimenterMultipartHeader) Reset()                    { *m = OfpExperimenterMultipartHeader{} }
+func (m *OfpExperimenterMultipartHeader) String() string            { return proto.CompactTextString(m) }
+func (*OfpExperimenterMultipartHeader) ProtoMessage()               {}
+func (*OfpExperimenterMultipartHeader) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{70} }
+
+func (m *OfpExperimenterMultipartHeader) GetExperimenter() uint32 {
+	if m != nil {
+		return m.Experimenter
+	}
+	return 0
+}
+
+func (m *OfpExperimenterMultipartHeader) GetExpType() uint32 {
+	if m != nil {
+		return m.ExpType
+	}
+	return 0
+}
+
+func (m *OfpExperimenterMultipartHeader) GetData() []byte {
+	if m != nil {
+		return m.Data
+	}
+	return nil
+}
+
+// Experimenter extension.
+type OfpExperimenterHeader struct {
+	// ofp_header header;  /* Type OFPT_EXPERIMENTER. */
+	Experimenter uint32 `protobuf:"varint,1,opt,name=experimenter" json:"experimenter,omitempty"`
+	ExpType      uint32 `protobuf:"varint,2,opt,name=exp_type,json=expType" json:"exp_type,omitempty"`
+	Data         []byte `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"`
+}
+
+func (m *OfpExperimenterHeader) Reset()                    { *m = OfpExperimenterHeader{} }
+func (m *OfpExperimenterHeader) String() string            { return proto.CompactTextString(m) }
+func (*OfpExperimenterHeader) ProtoMessage()               {}
+func (*OfpExperimenterHeader) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{71} }
+
+func (m *OfpExperimenterHeader) GetExperimenter() uint32 {
+	if m != nil {
+		return m.Experimenter
+	}
+	return 0
+}
+
+func (m *OfpExperimenterHeader) GetExpType() uint32 {
+	if m != nil {
+		return m.ExpType
+	}
+	return 0
+}
+
+func (m *OfpExperimenterHeader) GetData() []byte {
+	if m != nil {
+		return m.Data
+	}
+	return nil
+}
+
+// Common description for a queue.
+type OfpQueuePropHeader struct {
+	Property uint32 `protobuf:"varint,1,opt,name=property" json:"property,omitempty"`
+	Len      uint32 `protobuf:"varint,2,opt,name=len" json:"len,omitempty"`
+}
+
+func (m *OfpQueuePropHeader) Reset()                    { *m = OfpQueuePropHeader{} }
+func (m *OfpQueuePropHeader) String() string            { return proto.CompactTextString(m) }
+func (*OfpQueuePropHeader) ProtoMessage()               {}
+func (*OfpQueuePropHeader) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{72} }
+
+func (m *OfpQueuePropHeader) GetProperty() uint32 {
+	if m != nil {
+		return m.Property
+	}
+	return 0
+}
+
+func (m *OfpQueuePropHeader) GetLen() uint32 {
+	if m != nil {
+		return m.Len
+	}
+	return 0
+}
+
+// Min-Rate queue property description.
+type OfpQueuePropMinRate struct {
+	PropHeader *OfpQueuePropHeader `protobuf:"bytes,1,opt,name=prop_header,json=propHeader" json:"prop_header,omitempty"`
+	Rate       uint32              `protobuf:"varint,2,opt,name=rate" json:"rate,omitempty"`
+}
+
+func (m *OfpQueuePropMinRate) Reset()                    { *m = OfpQueuePropMinRate{} }
+func (m *OfpQueuePropMinRate) String() string            { return proto.CompactTextString(m) }
+func (*OfpQueuePropMinRate) ProtoMessage()               {}
+func (*OfpQueuePropMinRate) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{73} }
+
+func (m *OfpQueuePropMinRate) GetPropHeader() *OfpQueuePropHeader {
+	if m != nil {
+		return m.PropHeader
+	}
+	return nil
+}
+
+func (m *OfpQueuePropMinRate) GetRate() uint32 {
+	if m != nil {
+		return m.Rate
+	}
+	return 0
+}
+
+// Max-Rate queue property description.
+type OfpQueuePropMaxRate struct {
+	PropHeader *OfpQueuePropHeader `protobuf:"bytes,1,opt,name=prop_header,json=propHeader" json:"prop_header,omitempty"`
+	Rate       uint32              `protobuf:"varint,2,opt,name=rate" json:"rate,omitempty"`
+}
+
+func (m *OfpQueuePropMaxRate) Reset()                    { *m = OfpQueuePropMaxRate{} }
+func (m *OfpQueuePropMaxRate) String() string            { return proto.CompactTextString(m) }
+func (*OfpQueuePropMaxRate) ProtoMessage()               {}
+func (*OfpQueuePropMaxRate) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{74} }
+
+func (m *OfpQueuePropMaxRate) GetPropHeader() *OfpQueuePropHeader {
+	if m != nil {
+		return m.PropHeader
+	}
+	return nil
+}
+
+func (m *OfpQueuePropMaxRate) GetRate() uint32 {
+	if m != nil {
+		return m.Rate
+	}
+	return 0
+}
+
+// Experimenter queue property description.
+type OfpQueuePropExperimenter struct {
+	PropHeader   *OfpQueuePropHeader `protobuf:"bytes,1,opt,name=prop_header,json=propHeader" json:"prop_header,omitempty"`
+	Experimenter uint32              `protobuf:"varint,2,opt,name=experimenter" json:"experimenter,omitempty"`
+	Data         []byte              `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"`
+}
+
+func (m *OfpQueuePropExperimenter) Reset()                    { *m = OfpQueuePropExperimenter{} }
+func (m *OfpQueuePropExperimenter) String() string            { return proto.CompactTextString(m) }
+func (*OfpQueuePropExperimenter) ProtoMessage()               {}
+func (*OfpQueuePropExperimenter) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{75} }
+
+func (m *OfpQueuePropExperimenter) GetPropHeader() *OfpQueuePropHeader {
+	if m != nil {
+		return m.PropHeader
+	}
+	return nil
+}
+
+func (m *OfpQueuePropExperimenter) GetExperimenter() uint32 {
+	if m != nil {
+		return m.Experimenter
+	}
+	return 0
+}
+
+func (m *OfpQueuePropExperimenter) GetData() []byte {
+	if m != nil {
+		return m.Data
+	}
+	return nil
+}
+
+// Full description for a queue.
+type OfpPacketQueue struct {
+	QueueId    uint32                `protobuf:"varint,1,opt,name=queue_id,json=queueId" json:"queue_id,omitempty"`
+	Port       uint32                `protobuf:"varint,2,opt,name=port" json:"port,omitempty"`
+	Properties []*OfpQueuePropHeader `protobuf:"bytes,4,rep,name=properties" json:"properties,omitempty"`
+}
+
+func (m *OfpPacketQueue) Reset()                    { *m = OfpPacketQueue{} }
+func (m *OfpPacketQueue) String() string            { return proto.CompactTextString(m) }
+func (*OfpPacketQueue) ProtoMessage()               {}
+func (*OfpPacketQueue) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{76} }
+
+func (m *OfpPacketQueue) GetQueueId() uint32 {
+	if m != nil {
+		return m.QueueId
+	}
+	return 0
+}
+
+func (m *OfpPacketQueue) GetPort() uint32 {
+	if m != nil {
+		return m.Port
+	}
+	return 0
+}
+
+func (m *OfpPacketQueue) GetProperties() []*OfpQueuePropHeader {
+	if m != nil {
+		return m.Properties
+	}
+	return nil
+}
+
+// Query for port queue configuration.
+type OfpQueueGetConfigRequest struct {
+	// ofp_header header;
+	Port uint32 `protobuf:"varint,1,opt,name=port" json:"port,omitempty"`
+}
+
+func (m *OfpQueueGetConfigRequest) Reset()                    { *m = OfpQueueGetConfigRequest{} }
+func (m *OfpQueueGetConfigRequest) String() string            { return proto.CompactTextString(m) }
+func (*OfpQueueGetConfigRequest) ProtoMessage()               {}
+func (*OfpQueueGetConfigRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{77} }
+
+func (m *OfpQueueGetConfigRequest) GetPort() uint32 {
+	if m != nil {
+		return m.Port
+	}
+	return 0
+}
+
+// Queue configuration for a given port.
+type OfpQueueGetConfigReply struct {
+	// ofp_header header;
+	Port   uint32            `protobuf:"varint,1,opt,name=port" json:"port,omitempty"`
+	Queues []*OfpPacketQueue `protobuf:"bytes,2,rep,name=queues" json:"queues,omitempty"`
+}
+
+func (m *OfpQueueGetConfigReply) Reset()                    { *m = OfpQueueGetConfigReply{} }
+func (m *OfpQueueGetConfigReply) String() string            { return proto.CompactTextString(m) }
+func (*OfpQueueGetConfigReply) ProtoMessage()               {}
+func (*OfpQueueGetConfigReply) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{78} }
+
+func (m *OfpQueueGetConfigReply) GetPort() uint32 {
+	if m != nil {
+		return m.Port
+	}
+	return 0
+}
+
+func (m *OfpQueueGetConfigReply) GetQueues() []*OfpPacketQueue {
+	if m != nil {
+		return m.Queues
+	}
+	return nil
+}
+
+// OFPAT_SET_QUEUE action struct: send packets to given queue on port.
+type OfpActionSetQueue struct {
+	Type    uint32 `protobuf:"varint,1,opt,name=type" json:"type,omitempty"`
+	QueueId uint32 `protobuf:"varint,3,opt,name=queue_id,json=queueId" json:"queue_id,omitempty"`
+}
+
+func (m *OfpActionSetQueue) Reset()                    { *m = OfpActionSetQueue{} }
+func (m *OfpActionSetQueue) String() string            { return proto.CompactTextString(m) }
+func (*OfpActionSetQueue) ProtoMessage()               {}
+func (*OfpActionSetQueue) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{79} }
+
+func (m *OfpActionSetQueue) GetType() uint32 {
+	if m != nil {
+		return m.Type
+	}
+	return 0
+}
+
+func (m *OfpActionSetQueue) GetQueueId() uint32 {
+	if m != nil {
+		return m.QueueId
+	}
+	return 0
+}
+
+type OfpQueueStatsRequest struct {
+	PortNo  uint32 `protobuf:"varint,1,opt,name=port_no,json=portNo" json:"port_no,omitempty"`
+	QueueId uint32 `protobuf:"varint,2,opt,name=queue_id,json=queueId" json:"queue_id,omitempty"`
+}
+
+func (m *OfpQueueStatsRequest) Reset()                    { *m = OfpQueueStatsRequest{} }
+func (m *OfpQueueStatsRequest) String() string            { return proto.CompactTextString(m) }
+func (*OfpQueueStatsRequest) ProtoMessage()               {}
+func (*OfpQueueStatsRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{80} }
+
+func (m *OfpQueueStatsRequest) GetPortNo() uint32 {
+	if m != nil {
+		return m.PortNo
+	}
+	return 0
+}
+
+func (m *OfpQueueStatsRequest) GetQueueId() uint32 {
+	if m != nil {
+		return m.QueueId
+	}
+	return 0
+}
+
+type OfpQueueStats struct {
+	PortNo       uint32 `protobuf:"varint,1,opt,name=port_no,json=portNo" json:"port_no,omitempty"`
+	QueueId      uint32 `protobuf:"varint,2,opt,name=queue_id,json=queueId" json:"queue_id,omitempty"`
+	TxBytes      uint64 `protobuf:"varint,3,opt,name=tx_bytes,json=txBytes" json:"tx_bytes,omitempty"`
+	TxPackets    uint64 `protobuf:"varint,4,opt,name=tx_packets,json=txPackets" json:"tx_packets,omitempty"`
+	TxErrors     uint64 `protobuf:"varint,5,opt,name=tx_errors,json=txErrors" json:"tx_errors,omitempty"`
+	DurationSec  uint32 `protobuf:"varint,6,opt,name=duration_sec,json=durationSec" json:"duration_sec,omitempty"`
+	DurationNsec uint32 `protobuf:"varint,7,opt,name=duration_nsec,json=durationNsec" json:"duration_nsec,omitempty"`
+}
+
+func (m *OfpQueueStats) Reset()                    { *m = OfpQueueStats{} }
+func (m *OfpQueueStats) String() string            { return proto.CompactTextString(m) }
+func (*OfpQueueStats) ProtoMessage()               {}
+func (*OfpQueueStats) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{81} }
+
+func (m *OfpQueueStats) GetPortNo() uint32 {
+	if m != nil {
+		return m.PortNo
+	}
+	return 0
+}
+
+func (m *OfpQueueStats) GetQueueId() uint32 {
+	if m != nil {
+		return m.QueueId
+	}
+	return 0
+}
+
+func (m *OfpQueueStats) GetTxBytes() uint64 {
+	if m != nil {
+		return m.TxBytes
+	}
+	return 0
+}
+
+func (m *OfpQueueStats) GetTxPackets() uint64 {
+	if m != nil {
+		return m.TxPackets
+	}
+	return 0
+}
+
+func (m *OfpQueueStats) GetTxErrors() uint64 {
+	if m != nil {
+		return m.TxErrors
+	}
+	return 0
+}
+
+func (m *OfpQueueStats) GetDurationSec() uint32 {
+	if m != nil {
+		return m.DurationSec
+	}
+	return 0
+}
+
+func (m *OfpQueueStats) GetDurationNsec() uint32 {
+	if m != nil {
+		return m.DurationNsec
+	}
+	return 0
+}
+
+// Role request and reply message.
+type OfpRoleRequest struct {
+	// ofp_header header;        /* Type OFPT_ROLE_REQUEST/OFPT_ROLE_REPLY. */
+	Role         OfpControllerRole `protobuf:"varint,1,opt,name=role,enum=openflow_13.OfpControllerRole" json:"role,omitempty"`
+	GenerationId uint64            `protobuf:"varint,2,opt,name=generation_id,json=generationId" json:"generation_id,omitempty"`
+}
+
+func (m *OfpRoleRequest) Reset()                    { *m = OfpRoleRequest{} }
+func (m *OfpRoleRequest) String() string            { return proto.CompactTextString(m) }
+func (*OfpRoleRequest) ProtoMessage()               {}
+func (*OfpRoleRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{82} }
+
+func (m *OfpRoleRequest) GetRole() OfpControllerRole {
+	if m != nil {
+		return m.Role
+	}
+	return OfpControllerRole_OFPCR_ROLE_NOCHANGE
+}
+
+func (m *OfpRoleRequest) GetGenerationId() uint64 {
+	if m != nil {
+		return m.GenerationId
+	}
+	return 0
+}
+
+// Asynchronous message configuration.
+type OfpAsyncConfig struct {
+	// ofp_header header;    /* OFPT_GET_ASYNC_REPLY or OFPT_SET_ASYNC. */
+	PacketInMask    []uint32 `protobuf:"varint,1,rep,packed,name=packet_in_mask,json=packetInMask" json:"packet_in_mask,omitempty"`
+	PortStatusMask  []uint32 `protobuf:"varint,2,rep,packed,name=port_status_mask,json=portStatusMask" json:"port_status_mask,omitempty"`
+	FlowRemovedMask []uint32 `protobuf:"varint,3,rep,packed,name=flow_removed_mask,json=flowRemovedMask" json:"flow_removed_mask,omitempty"`
+}
+
+func (m *OfpAsyncConfig) Reset()                    { *m = OfpAsyncConfig{} }
+func (m *OfpAsyncConfig) String() string            { return proto.CompactTextString(m) }
+func (*OfpAsyncConfig) ProtoMessage()               {}
+func (*OfpAsyncConfig) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{83} }
+
+func (m *OfpAsyncConfig) GetPacketInMask() []uint32 {
+	if m != nil {
+		return m.PacketInMask
+	}
+	return nil
+}
+
+func (m *OfpAsyncConfig) GetPortStatusMask() []uint32 {
+	if m != nil {
+		return m.PortStatusMask
+	}
+	return nil
+}
+
+func (m *OfpAsyncConfig) GetFlowRemovedMask() []uint32 {
+	if m != nil {
+		return m.FlowRemovedMask
+	}
+	return nil
+}
+
+type FlowTableUpdate struct {
+	Id      string      `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
+	FlowMod *OfpFlowMod `protobuf:"bytes,2,opt,name=flow_mod,json=flowMod" json:"flow_mod,omitempty"`
+}
+
+func (m *FlowTableUpdate) Reset()                    { *m = FlowTableUpdate{} }
+func (m *FlowTableUpdate) String() string            { return proto.CompactTextString(m) }
+func (*FlowTableUpdate) ProtoMessage()               {}
+func (*FlowTableUpdate) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{84} }
+
+func (m *FlowTableUpdate) GetId() string {
+	if m != nil {
+		return m.Id
+	}
+	return ""
+}
+
+func (m *FlowTableUpdate) GetFlowMod() *OfpFlowMod {
+	if m != nil {
+		return m.FlowMod
+	}
+	return nil
+}
+
+type FlowGroupTableUpdate struct {
+	Id       string       `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
+	GroupMod *OfpGroupMod `protobuf:"bytes,2,opt,name=group_mod,json=groupMod" json:"group_mod,omitempty"`
+}
+
+func (m *FlowGroupTableUpdate) Reset()                    { *m = FlowGroupTableUpdate{} }
+func (m *FlowGroupTableUpdate) String() string            { return proto.CompactTextString(m) }
+func (*FlowGroupTableUpdate) ProtoMessage()               {}
+func (*FlowGroupTableUpdate) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{85} }
+
+func (m *FlowGroupTableUpdate) GetId() string {
+	if m != nil {
+		return m.Id
+	}
+	return ""
+}
+
+func (m *FlowGroupTableUpdate) GetGroupMod() *OfpGroupMod {
+	if m != nil {
+		return m.GroupMod
+	}
+	return nil
+}
+
+type Flows struct {
+	Items []*OfpFlowStats `protobuf:"bytes,1,rep,name=items" json:"items,omitempty"`
+}
+
+func (m *Flows) Reset()                    { *m = Flows{} }
+func (m *Flows) String() string            { return proto.CompactTextString(m) }
+func (*Flows) ProtoMessage()               {}
+func (*Flows) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{86} }
+
+func (m *Flows) GetItems() []*OfpFlowStats {
+	if m != nil {
+		return m.Items
+	}
+	return nil
+}
+
+type FlowGroups struct {
+	Items []*OfpGroupEntry `protobuf:"bytes,1,rep,name=items" json:"items,omitempty"`
+}
+
+func (m *FlowGroups) Reset()                    { *m = FlowGroups{} }
+func (m *FlowGroups) String() string            { return proto.CompactTextString(m) }
+func (*FlowGroups) ProtoMessage()               {}
+func (*FlowGroups) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{87} }
+
+func (m *FlowGroups) GetItems() []*OfpGroupEntry {
+	if m != nil {
+		return m.Items
+	}
+	return nil
+}
+
+type PacketIn struct {
+	Id       string       `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
+	PacketIn *OfpPacketIn `protobuf:"bytes,2,opt,name=packet_in,json=packetIn" json:"packet_in,omitempty"`
+}
+
+func (m *PacketIn) Reset()                    { *m = PacketIn{} }
+func (m *PacketIn) String() string            { return proto.CompactTextString(m) }
+func (*PacketIn) ProtoMessage()               {}
+func (*PacketIn) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{88} }
+
+func (m *PacketIn) GetId() string {
+	if m != nil {
+		return m.Id
+	}
+	return ""
+}
+
+func (m *PacketIn) GetPacketIn() *OfpPacketIn {
+	if m != nil {
+		return m.PacketIn
+	}
+	return nil
+}
+
+type PacketOut struct {
+	Id        string        `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
+	PacketOut *OfpPacketOut `protobuf:"bytes,2,opt,name=packet_out,json=packetOut" json:"packet_out,omitempty"`
+}
+
+func (m *PacketOut) Reset()                    { *m = PacketOut{} }
+func (m *PacketOut) String() string            { return proto.CompactTextString(m) }
+func (*PacketOut) ProtoMessage()               {}
+func (*PacketOut) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{89} }
+
+func (m *PacketOut) GetId() string {
+	if m != nil {
+		return m.Id
+	}
+	return ""
+}
+
+func (m *PacketOut) GetPacketOut() *OfpPacketOut {
+	if m != nil {
+		return m.PacketOut
+	}
+	return nil
+}
+
+type ChangeEvent struct {
+	Id string `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
+	// Types that are valid to be assigned to Event:
+	//	*ChangeEvent_PortStatus
+	Event isChangeEvent_Event `protobuf_oneof:"event"`
+}
+
+func (m *ChangeEvent) Reset()                    { *m = ChangeEvent{} }
+func (m *ChangeEvent) String() string            { return proto.CompactTextString(m) }
+func (*ChangeEvent) ProtoMessage()               {}
+func (*ChangeEvent) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{90} }
+
+type isChangeEvent_Event interface {
+	isChangeEvent_Event()
+}
+
+type ChangeEvent_PortStatus struct {
+	PortStatus *OfpPortStatus `protobuf:"bytes,2,opt,name=port_status,json=portStatus,oneof"`
+}
+
+func (*ChangeEvent_PortStatus) isChangeEvent_Event() {}
+
+func (m *ChangeEvent) GetEvent() isChangeEvent_Event {
+	if m != nil {
+		return m.Event
+	}
+	return nil
+}
+
+func (m *ChangeEvent) GetId() string {
+	if m != nil {
+		return m.Id
+	}
+	return ""
+}
+
+func (m *ChangeEvent) GetPortStatus() *OfpPortStatus {
+	if x, ok := m.GetEvent().(*ChangeEvent_PortStatus); ok {
+		return x.PortStatus
+	}
+	return nil
+}
+
+// XXX_OneofFuncs is for the internal use of the proto package.
+func (*ChangeEvent) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
+	return _ChangeEvent_OneofMarshaler, _ChangeEvent_OneofUnmarshaler, _ChangeEvent_OneofSizer, []interface{}{
+		(*ChangeEvent_PortStatus)(nil),
+	}
+}
+
+func _ChangeEvent_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
+	m := msg.(*ChangeEvent)
+	// event
+	switch x := m.Event.(type) {
+	case *ChangeEvent_PortStatus:
+		b.EncodeVarint(2<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.PortStatus); err != nil {
+			return err
+		}
+	case nil:
+	default:
+		return fmt.Errorf("ChangeEvent.Event has unexpected type %T", x)
+	}
+	return nil
+}
+
+func _ChangeEvent_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
+	m := msg.(*ChangeEvent)
+	switch tag {
+	case 2: // event.port_status
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(OfpPortStatus)
+		err := b.DecodeMessage(msg)
+		m.Event = &ChangeEvent_PortStatus{msg}
+		return true, err
+	default:
+		return false, nil
+	}
+}
+
+func _ChangeEvent_OneofSizer(msg proto.Message) (n int) {
+	m := msg.(*ChangeEvent)
+	// event
+	switch x := m.Event.(type) {
+	case *ChangeEvent_PortStatus:
+		s := proto.Size(x.PortStatus)
+		n += proto.SizeVarint(2<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case nil:
+	default:
+		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
+	}
+	return n
+}
+
+func init() {
+	proto.RegisterType((*OfpHeader)(nil), "openflow_13.ofp_header")
+	proto.RegisterType((*OfpHelloElemHeader)(nil), "openflow_13.ofp_hello_elem_header")
+	proto.RegisterType((*OfpHelloElemVersionbitmap)(nil), "openflow_13.ofp_hello_elem_versionbitmap")
+	proto.RegisterType((*OfpHello)(nil), "openflow_13.ofp_hello")
+	proto.RegisterType((*OfpSwitchConfig)(nil), "openflow_13.ofp_switch_config")
+	proto.RegisterType((*OfpTableMod)(nil), "openflow_13.ofp_table_mod")
+	proto.RegisterType((*OfpPort)(nil), "openflow_13.ofp_port")
+	proto.RegisterType((*OfpSwitchFeatures)(nil), "openflow_13.ofp_switch_features")
+	proto.RegisterType((*OfpPortStatus)(nil), "openflow_13.ofp_port_status")
+	proto.RegisterType((*OfpPortMod)(nil), "openflow_13.ofp_port_mod")
+	proto.RegisterType((*OfpMatch)(nil), "openflow_13.ofp_match")
+	proto.RegisterType((*OfpOxmField)(nil), "openflow_13.ofp_oxm_field")
+	proto.RegisterType((*OfpOxmOfbField)(nil), "openflow_13.ofp_oxm_ofb_field")
+	proto.RegisterType((*OfpOxmExperimenterField)(nil), "openflow_13.ofp_oxm_experimenter_field")
+	proto.RegisterType((*OfpAction)(nil), "openflow_13.ofp_action")
+	proto.RegisterType((*OfpActionOutput)(nil), "openflow_13.ofp_action_output")
+	proto.RegisterType((*OfpActionMplsTtl)(nil), "openflow_13.ofp_action_mpls_ttl")
+	proto.RegisterType((*OfpActionPush)(nil), "openflow_13.ofp_action_push")
+	proto.RegisterType((*OfpActionPopMpls)(nil), "openflow_13.ofp_action_pop_mpls")
+	proto.RegisterType((*OfpActionGroup)(nil), "openflow_13.ofp_action_group")
+	proto.RegisterType((*OfpActionNwTtl)(nil), "openflow_13.ofp_action_nw_ttl")
+	proto.RegisterType((*OfpActionSetField)(nil), "openflow_13.ofp_action_set_field")
+	proto.RegisterType((*OfpActionExperimenter)(nil), "openflow_13.ofp_action_experimenter")
+	proto.RegisterType((*OfpInstruction)(nil), "openflow_13.ofp_instruction")
+	proto.RegisterType((*OfpInstructionGotoTable)(nil), "openflow_13.ofp_instruction_goto_table")
+	proto.RegisterType((*OfpInstructionWriteMetadata)(nil), "openflow_13.ofp_instruction_write_metadata")
+	proto.RegisterType((*OfpInstructionActions)(nil), "openflow_13.ofp_instruction_actions")
+	proto.RegisterType((*OfpInstructionMeter)(nil), "openflow_13.ofp_instruction_meter")
+	proto.RegisterType((*OfpInstructionExperimenter)(nil), "openflow_13.ofp_instruction_experimenter")
+	proto.RegisterType((*OfpFlowMod)(nil), "openflow_13.ofp_flow_mod")
+	proto.RegisterType((*OfpBucket)(nil), "openflow_13.ofp_bucket")
+	proto.RegisterType((*OfpGroupMod)(nil), "openflow_13.ofp_group_mod")
+	proto.RegisterType((*OfpPacketOut)(nil), "openflow_13.ofp_packet_out")
+	proto.RegisterType((*OfpPacketIn)(nil), "openflow_13.ofp_packet_in")
+	proto.RegisterType((*OfpFlowRemoved)(nil), "openflow_13.ofp_flow_removed")
+	proto.RegisterType((*OfpMeterBandHeader)(nil), "openflow_13.ofp_meter_band_header")
+	proto.RegisterType((*OfpMeterBandDrop)(nil), "openflow_13.ofp_meter_band_drop")
+	proto.RegisterType((*OfpMeterBandDscpRemark)(nil), "openflow_13.ofp_meter_band_dscp_remark")
+	proto.RegisterType((*OfpMeterBandExperimenter)(nil), "openflow_13.ofp_meter_band_experimenter")
+	proto.RegisterType((*OfpMeterMod)(nil), "openflow_13.ofp_meter_mod")
+	proto.RegisterType((*OfpErrorMsg)(nil), "openflow_13.ofp_error_msg")
+	proto.RegisterType((*OfpErrorExperimenterMsg)(nil), "openflow_13.ofp_error_experimenter_msg")
+	proto.RegisterType((*OfpMultipartRequest)(nil), "openflow_13.ofp_multipart_request")
+	proto.RegisterType((*OfpMultipartReply)(nil), "openflow_13.ofp_multipart_reply")
+	proto.RegisterType((*OfpDesc)(nil), "openflow_13.ofp_desc")
+	proto.RegisterType((*OfpFlowStatsRequest)(nil), "openflow_13.ofp_flow_stats_request")
+	proto.RegisterType((*OfpFlowStats)(nil), "openflow_13.ofp_flow_stats")
+	proto.RegisterType((*OfpAggregateStatsRequest)(nil), "openflow_13.ofp_aggregate_stats_request")
+	proto.RegisterType((*OfpAggregateStatsReply)(nil), "openflow_13.ofp_aggregate_stats_reply")
+	proto.RegisterType((*OfpTableFeatureProperty)(nil), "openflow_13.ofp_table_feature_property")
+	proto.RegisterType((*OfpTableFeaturePropInstructions)(nil), "openflow_13.ofp_table_feature_prop_instructions")
+	proto.RegisterType((*OfpTableFeaturePropNextTables)(nil), "openflow_13.ofp_table_feature_prop_next_tables")
+	proto.RegisterType((*OfpTableFeaturePropActions)(nil), "openflow_13.ofp_table_feature_prop_actions")
+	proto.RegisterType((*OfpTableFeaturePropOxm)(nil), "openflow_13.ofp_table_feature_prop_oxm")
+	proto.RegisterType((*OfpTableFeaturePropExperimenter)(nil), "openflow_13.ofp_table_feature_prop_experimenter")
+	proto.RegisterType((*OfpTableFeatures)(nil), "openflow_13.ofp_table_features")
+	proto.RegisterType((*OfpTableStats)(nil), "openflow_13.ofp_table_stats")
+	proto.RegisterType((*OfpPortStatsRequest)(nil), "openflow_13.ofp_port_stats_request")
+	proto.RegisterType((*OfpPortStats)(nil), "openflow_13.ofp_port_stats")
+	proto.RegisterType((*OfpGroupStatsRequest)(nil), "openflow_13.ofp_group_stats_request")
+	proto.RegisterType((*OfpBucketCounter)(nil), "openflow_13.ofp_bucket_counter")
+	proto.RegisterType((*OfpGroupStats)(nil), "openflow_13.ofp_group_stats")
+	proto.RegisterType((*OfpGroupDesc)(nil), "openflow_13.ofp_group_desc")
+	proto.RegisterType((*OfpGroupEntry)(nil), "openflow_13.ofp_group_entry")
+	proto.RegisterType((*OfpGroupFeatures)(nil), "openflow_13.ofp_group_features")
+	proto.RegisterType((*OfpMeterMultipartRequest)(nil), "openflow_13.ofp_meter_multipart_request")
+	proto.RegisterType((*OfpMeterBandStats)(nil), "openflow_13.ofp_meter_band_stats")
+	proto.RegisterType((*OfpMeterStats)(nil), "openflow_13.ofp_meter_stats")
+	proto.RegisterType((*OfpMeterConfig)(nil), "openflow_13.ofp_meter_config")
+	proto.RegisterType((*OfpMeterFeatures)(nil), "openflow_13.ofp_meter_features")
+	proto.RegisterType((*OfpExperimenterMultipartHeader)(nil), "openflow_13.ofp_experimenter_multipart_header")
+	proto.RegisterType((*OfpExperimenterHeader)(nil), "openflow_13.ofp_experimenter_header")
+	proto.RegisterType((*OfpQueuePropHeader)(nil), "openflow_13.ofp_queue_prop_header")
+	proto.RegisterType((*OfpQueuePropMinRate)(nil), "openflow_13.ofp_queue_prop_min_rate")
+	proto.RegisterType((*OfpQueuePropMaxRate)(nil), "openflow_13.ofp_queue_prop_max_rate")
+	proto.RegisterType((*OfpQueuePropExperimenter)(nil), "openflow_13.ofp_queue_prop_experimenter")
+	proto.RegisterType((*OfpPacketQueue)(nil), "openflow_13.ofp_packet_queue")
+	proto.RegisterType((*OfpQueueGetConfigRequest)(nil), "openflow_13.ofp_queue_get_config_request")
+	proto.RegisterType((*OfpQueueGetConfigReply)(nil), "openflow_13.ofp_queue_get_config_reply")
+	proto.RegisterType((*OfpActionSetQueue)(nil), "openflow_13.ofp_action_set_queue")
+	proto.RegisterType((*OfpQueueStatsRequest)(nil), "openflow_13.ofp_queue_stats_request")
+	proto.RegisterType((*OfpQueueStats)(nil), "openflow_13.ofp_queue_stats")
+	proto.RegisterType((*OfpRoleRequest)(nil), "openflow_13.ofp_role_request")
+	proto.RegisterType((*OfpAsyncConfig)(nil), "openflow_13.ofp_async_config")
+	proto.RegisterType((*FlowTableUpdate)(nil), "openflow_13.FlowTableUpdate")
+	proto.RegisterType((*FlowGroupTableUpdate)(nil), "openflow_13.FlowGroupTableUpdate")
+	proto.RegisterType((*Flows)(nil), "openflow_13.Flows")
+	proto.RegisterType((*FlowGroups)(nil), "openflow_13.FlowGroups")
+	proto.RegisterType((*PacketIn)(nil), "openflow_13.PacketIn")
+	proto.RegisterType((*PacketOut)(nil), "openflow_13.PacketOut")
+	proto.RegisterType((*ChangeEvent)(nil), "openflow_13.ChangeEvent")
+	proto.RegisterEnum("openflow_13.OfpPortNo", OfpPortNo_name, OfpPortNo_value)
+	proto.RegisterEnum("openflow_13.OfpType", OfpType_name, OfpType_value)
+	proto.RegisterEnum("openflow_13.OfpHelloElemType", OfpHelloElemType_name, OfpHelloElemType_value)
+	proto.RegisterEnum("openflow_13.OfpConfigFlags", OfpConfigFlags_name, OfpConfigFlags_value)
+	proto.RegisterEnum("openflow_13.OfpTableConfig", OfpTableConfig_name, OfpTableConfig_value)
+	proto.RegisterEnum("openflow_13.OfpTable", OfpTable_name, OfpTable_value)
+	proto.RegisterEnum("openflow_13.OfpCapabilities", OfpCapabilities_name, OfpCapabilities_value)
+	proto.RegisterEnum("openflow_13.OfpPortConfig", OfpPortConfig_name, OfpPortConfig_value)
+	proto.RegisterEnum("openflow_13.OfpPortState", OfpPortState_name, OfpPortState_value)
+	proto.RegisterEnum("openflow_13.OfpPortFeatures", OfpPortFeatures_name, OfpPortFeatures_value)
+	proto.RegisterEnum("openflow_13.OfpPortReason", OfpPortReason_name, OfpPortReason_value)
+	proto.RegisterEnum("openflow_13.OfpMatchType", OfpMatchType_name, OfpMatchType_value)
+	proto.RegisterEnum("openflow_13.OfpOxmClass", OfpOxmClass_name, OfpOxmClass_value)
+	proto.RegisterEnum("openflow_13.OxmOfbFieldTypes", OxmOfbFieldTypes_name, OxmOfbFieldTypes_value)
+	proto.RegisterEnum("openflow_13.OfpVlanId", OfpVlanId_name, OfpVlanId_value)
+	proto.RegisterEnum("openflow_13.OfpIpv6ExthdrFlags", OfpIpv6ExthdrFlags_name, OfpIpv6ExthdrFlags_value)
+	proto.RegisterEnum("openflow_13.OfpActionType", OfpActionType_name, OfpActionType_value)
+	proto.RegisterEnum("openflow_13.OfpControllerMaxLen", OfpControllerMaxLen_name, OfpControllerMaxLen_value)
+	proto.RegisterEnum("openflow_13.OfpInstructionType", OfpInstructionType_name, OfpInstructionType_value)
+	proto.RegisterEnum("openflow_13.OfpFlowModCommand", OfpFlowModCommand_name, OfpFlowModCommand_value)
+	proto.RegisterEnum("openflow_13.OfpFlowModFlags", OfpFlowModFlags_name, OfpFlowModFlags_value)
+	proto.RegisterEnum("openflow_13.OfpGroup", OfpGroup_name, OfpGroup_value)
+	proto.RegisterEnum("openflow_13.OfpGroupModCommand", OfpGroupModCommand_name, OfpGroupModCommand_value)
+	proto.RegisterEnum("openflow_13.OfpGroupType", OfpGroupType_name, OfpGroupType_value)
+	proto.RegisterEnum("openflow_13.OfpPacketInReason", OfpPacketInReason_name, OfpPacketInReason_value)
+	proto.RegisterEnum("openflow_13.OfpFlowRemovedReason", OfpFlowRemovedReason_name, OfpFlowRemovedReason_value)
+	proto.RegisterEnum("openflow_13.OfpMeter", OfpMeter_name, OfpMeter_value)
+	proto.RegisterEnum("openflow_13.OfpMeterBandType", OfpMeterBandType_name, OfpMeterBandType_value)
+	proto.RegisterEnum("openflow_13.OfpMeterModCommand", OfpMeterModCommand_name, OfpMeterModCommand_value)
+	proto.RegisterEnum("openflow_13.OfpMeterFlags", OfpMeterFlags_name, OfpMeterFlags_value)
+	proto.RegisterEnum("openflow_13.OfpErrorType", OfpErrorType_name, OfpErrorType_value)
+	proto.RegisterEnum("openflow_13.OfpHelloFailedCode", OfpHelloFailedCode_name, OfpHelloFailedCode_value)
+	proto.RegisterEnum("openflow_13.OfpBadRequestCode", OfpBadRequestCode_name, OfpBadRequestCode_value)
+	proto.RegisterEnum("openflow_13.OfpBadActionCode", OfpBadActionCode_name, OfpBadActionCode_value)
+	proto.RegisterEnum("openflow_13.OfpBadInstructionCode", OfpBadInstructionCode_name, OfpBadInstructionCode_value)
+	proto.RegisterEnum("openflow_13.OfpBadMatchCode", OfpBadMatchCode_name, OfpBadMatchCode_value)
+	proto.RegisterEnum("openflow_13.OfpFlowModFailedCode", OfpFlowModFailedCode_name, OfpFlowModFailedCode_value)
+	proto.RegisterEnum("openflow_13.OfpGroupModFailedCode", OfpGroupModFailedCode_name, OfpGroupModFailedCode_value)
+	proto.RegisterEnum("openflow_13.OfpPortModFailedCode", OfpPortModFailedCode_name, OfpPortModFailedCode_value)
+	proto.RegisterEnum("openflow_13.OfpTableModFailedCode", OfpTableModFailedCode_name, OfpTableModFailedCode_value)
+	proto.RegisterEnum("openflow_13.OfpQueueOpFailedCode", OfpQueueOpFailedCode_name, OfpQueueOpFailedCode_value)
+	proto.RegisterEnum("openflow_13.OfpSwitchConfigFailedCode", OfpSwitchConfigFailedCode_name, OfpSwitchConfigFailedCode_value)
+	proto.RegisterEnum("openflow_13.OfpRoleRequestFailedCode", OfpRoleRequestFailedCode_name, OfpRoleRequestFailedCode_value)
+	proto.RegisterEnum("openflow_13.OfpMeterModFailedCode", OfpMeterModFailedCode_name, OfpMeterModFailedCode_value)
+	proto.RegisterEnum("openflow_13.OfpTableFeaturesFailedCode", OfpTableFeaturesFailedCode_name, OfpTableFeaturesFailedCode_value)
+	proto.RegisterEnum("openflow_13.OfpMultipartType", OfpMultipartType_name, OfpMultipartType_value)
+	proto.RegisterEnum("openflow_13.OfpMultipartRequestFlags", OfpMultipartRequestFlags_name, OfpMultipartRequestFlags_value)
+	proto.RegisterEnum("openflow_13.OfpMultipartReplyFlags", OfpMultipartReplyFlags_name, OfpMultipartReplyFlags_value)
+	proto.RegisterEnum("openflow_13.OfpTableFeaturePropType", OfpTableFeaturePropType_name, OfpTableFeaturePropType_value)
+	proto.RegisterEnum("openflow_13.OfpGroupCapabilities", OfpGroupCapabilities_name, OfpGroupCapabilities_value)
+	proto.RegisterEnum("openflow_13.OfpQueueProperties", OfpQueueProperties_name, OfpQueueProperties_value)
+	proto.RegisterEnum("openflow_13.OfpControllerRole", OfpControllerRole_name, OfpControllerRole_value)
+}
+
+func init() { proto.RegisterFile("openflow_13.proto", fileDescriptor0) }
+
+var fileDescriptor0 = []byte{
+	// 8209 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x7c, 0x5b, 0x8c, 0x1b, 0x4b,
+	0x76, 0x98, 0xf8, 0x98, 0x21, 0x59, 0x9c, 0x19, 0xb5, 0x5a, 0x2f, 0x4a, 0x23, 0x5d, 0x49, 0x5c,
+	0xdd, 0xdd, 0xbb, 0x5c, 0xdb, 0xf7, 0x5e, 0x5d, 0xad, 0x76, 0xbd, 0x7e, 0x44, 0x4d, 0xb2, 0x39,
+	0xe4, 0x8a, 0x8f, 0x56, 0x77, 0xcf, 0x48, 0x72, 0xe0, 0x34, 0x38, 0x64, 0x6b, 0x86, 0xbe, 0x7c,
+	0x6d, 0x77, 0xcf, 0x68, 0xe4, 0xc4, 0x81, 0x62, 0x23, 0x08, 0x90, 0xc4, 0x76, 0x12, 0x07, 0x58,
+	0x20, 0x70, 0x80, 0x18, 0x71, 0x3e, 0x82, 0x00, 0xf9, 0x08, 0x10, 0x20, 0x40, 0xf2, 0x99, 0x00,
+	0x09, 0x90, 0x07, 0x60, 0x20, 0xf0, 0x4f, 0xfc, 0xe7, 0xfc, 0x04, 0xf0, 0x77, 0x12, 0x67, 0xb3,
+	0x0a, 0x4e, 0x9d, 0x53, 0xd5, 0xd5, 0x7c, 0xcc, 0x9d, 0xdd, 0xdc, 0x4d, 0x00, 0x7f, 0x0d, 0xfb,
+	0x9c, 0x53, 0xa7, 0xaa, 0x4e, 0x9d, 0x77, 0x57, 0x0f, 0xbb, 0x32, 0x9b, 0xfb, 0xd3, 0xd7, 0xe3,
+	0xd9, 0x1b, 0xef, 0xd3, 0xcf, 0x7e, 0x66, 0x1e, 0xcc, 0xa2, 0x99, 0x5e, 0x54, 0x40, 0xb7, 0xef,
+	0x1c, 0xcd, 0x66, 0x47, 0x63, 0xff, 0xe3, 0xfe, 0x7c, 0xf4, 0x71, 0x7f, 0x3a, 0x9d, 0x45, 0xfd,
+	0x68, 0x34, 0x9b, 0x86, 0x48, 0x7a, 0x5b, 0x7f, 0xdb, 0x9f, 0x1e, 0x79, 0xb3, 0xb9, 0x02, 0x2b,
+	0x0f, 0x18, 0x9b, 0xbd, 0x9e, 0x7b, 0xc7, 0x7e, 0x7f, 0xe8, 0x07, 0x7a, 0x89, 0xe5, 0x4e, 0xfd,
+	0x20, 0x1c, 0xcd, 0xa6, 0xa5, 0xd4, 0xfd, 0xd4, 0x47, 0xdb, 0xb6, 0x78, 0xd4, 0xbf, 0xce, 0xb2,
+	0xd1, 0xdb, 0xb9, 0x5f, 0x4a, 0xdf, 0x4f, 0x7d, 0xb4, 0xf3, 0xe8, 0xfa, 0xcf, 0xa8, 0x0b, 0x01,
+	0x06, 0x80, 0xb4, 0x39, 0x89, 0xae, 0xb1, 0xcc, 0xd9, 0x68, 0x58, 0xca, 0x70, 0x06, 0xf0, 0xb3,
+	0xfc, 0x4f, 0x52, 0xec, 0x3a, 0xce, 0x32, 0x1e, 0xcf, 0x3c, 0x7f, 0xec, 0x4f, 0xc4, 0x84, 0x8f,
+	0x89, 0x6d, 0x8a, 0xb3, 0xbd, 0xbf, 0xc4, 0x56, 0x19, 0xa1, 0xcc, 0xf0, 0x9c, 0x6d, 0xd3, 0xba,
+	0x0e, 0x47, 0xd1, 0xa4, 0x3f, 0xe7, 0xab, 0x2a, 0x3e, 0xfa, 0xfa, 0x79, 0xc3, 0x13, 0x03, 0x9a,
+	0x97, 0xec, 0x24, 0x87, 0x6a, 0x81, 0xe5, 0x80, 0xcc, 0x9f, 0x46, 0xe5, 0x6f, 0xb3, 0x3b, 0xe7,
+	0x8d, 0x05, 0x21, 0xe1, 0xaf, 0xb0, 0x94, 0xbe, 0x9f, 0x01, 0x21, 0xd1, 0x63, 0xf9, 0x19, 0x2b,
+	0xc8, 0x91, 0xfa, 0x2f, 0xb2, 0x3c, 0x71, 0x0c, 0x4b, 0xa9, 0xfb, 0x99, 0x8f, 0x8a, 0x8f, 0xca,
+	0xe7, 0xad, 0x0f, 0x05, 0x62, 0xcb, 0x31, 0xe5, 0x0e, 0xbb, 0x02, 0x24, 0xe1, 0x9b, 0x51, 0x34,
+	0x38, 0xf6, 0x06, 0xb3, 0xe9, 0xeb, 0xd1, 0x91, 0x7e, 0x8d, 0x6d, 0xbc, 0x1e, 0xf7, 0x8f, 0x42,
+	0x3a, 0x1e, 0x7c, 0xd0, 0xcb, 0x6c, 0x7b, 0x32, 0x0a, 0x43, 0x2f, 0xf4, 0xa7, 0x43, 0x6f, 0xec,
+	0x4f, 0xb9, 0x3c, 0xb6, 0xed, 0x22, 0x00, 0x1d, 0x7f, 0x3a, 0x6c, 0xfb, 0xd3, 0x72, 0x95, 0x6d,
+	0xf3, 0x73, 0xea, 0x1f, 0x8e, 0x7d, 0x6f, 0x32, 0x1b, 0xea, 0xb7, 0x58, 0x1e, 0x1f, 0x46, 0x43,
+	0x71, 0xd8, 0xfc, 0xb9, 0x35, 0xd4, 0x6f, 0xb0, 0x4d, 0x9c, 0x8f, 0x18, 0xd1, 0x53, 0xf9, 0x1f,
+	0xa4, 0x59, 0x1e, 0x98, 0xcc, 0x67, 0x41, 0xa4, 0xdf, 0x64, 0x39, 0xf8, 0xeb, 0x4d, 0x67, 0x34,
+	0x7c, 0x13, 0x1e, 0xbb, 0x33, 0x40, 0x1c, 0xbf, 0xf1, 0xfa, 0xc3, 0x61, 0x40, 0xf2, 0xd9, 0x3c,
+	0x7e, 0x63, 0x0c, 0x87, 0x81, 0xae, 0xb3, 0xec, 0xb4, 0x3f, 0xf1, 0xb9, 0x66, 0x14, 0x6c, 0xfe,
+	0x5b, 0x99, 0x2a, 0xab, 0x4e, 0x05, 0x1b, 0x0d, 0xa3, 0x7e, 0xe4, 0x97, 0x36, 0x70, 0xa3, 0xfc,
+	0x01, 0x38, 0x0c, 0x4e, 0x82, 0xa0, 0xb4, 0xc9, 0x81, 0xfc, 0xb7, 0xfe, 0x01, 0x63, 0xfd, 0xe1,
+	0xa9, 0x1f, 0x44, 0xa3, 0xd0, 0x1f, 0x96, 0x72, 0x1c, 0xa3, 0x40, 0xf4, 0x3b, 0xac, 0x10, 0x9e,
+	0xcc, 0x61, 0x6d, 0xfe, 0xb0, 0x94, 0xe7, 0xe8, 0x18, 0x00, 0x1c, 0xe7, 0xbe, 0x1f, 0x94, 0x0a,
+	0xc8, 0x11, 0x7e, 0xeb, 0x77, 0x19, 0x03, 0xce, 0x5e, 0x38, 0xf7, 0xfd, 0x61, 0x89, 0xe1, 0x10,
+	0x80, 0x38, 0x00, 0xd0, 0x77, 0x59, 0x61, 0xd2, 0x3f, 0x23, 0x6c, 0x91, 0x63, 0xf3, 0x93, 0xfe,
+	0x19, 0x47, 0x96, 0xff, 0x79, 0x8a, 0x5d, 0x55, 0x8e, 0xed, 0xb5, 0xdf, 0x8f, 0x4e, 0x02, 0x3f,
+	0xd4, 0xef, 0xb1, 0xe2, 0xb0, 0x1f, 0xf5, 0xe7, 0xfd, 0xe8, 0x58, 0x08, 0x3c, 0x6b, 0x33, 0x01,
+	0x6a, 0x71, 0xae, 0x53, 0xef, 0xf0, 0xe4, 0xf5, 0x6b, 0x3f, 0x08, 0x49, 0xec, 0xf9, 0x69, 0x15,
+	0x9f, 0xe1, 0xac, 0xa6, 0x78, 0x74, 0x21, 0xd9, 0x55, 0x6e, 0xea, 0xf2, 0x47, 0xfd, 0x01, 0xdb,
+	0xea, 0x9f, 0x9c, 0x8d, 0xc6, 0xa3, 0x7e, 0xf0, 0x16, 0x38, 0xa3, 0x18, 0x8b, 0x12, 0xd6, 0x1a,
+	0xea, 0x65, 0xb6, 0x35, 0xe8, 0xcf, 0xfb, 0x87, 0xa3, 0xf1, 0x28, 0x1a, 0xf9, 0x21, 0x89, 0x34,
+	0x01, 0x2b, 0x07, 0xec, 0xb2, 0x38, 0x59, 0x0f, 0x64, 0x7d, 0x12, 0xea, 0x8f, 0xd9, 0x66, 0xe0,
+	0xf7, 0x43, 0xf2, 0x05, 0x3b, 0x8f, 0xee, 0x2c, 0xa9, 0x2f, 0xa7, 0x46, 0x1a, 0x9b, 0x68, 0xc1,
+	0x51, 0x0c, 0xfd, 0x70, 0x40, 0x26, 0x79, 0x7d, 0xe5, 0x18, 0x9b, 0x93, 0x94, 0xff, 0x7a, 0x8a,
+	0x6d, 0x49, 0x36, 0xa0, 0x92, 0x3f, 0xba, 0x4a, 0xc5, 0xea, 0x93, 0x49, 0xa8, 0x8f, 0xce, 0xb2,
+	0x93, 0x7e, 0xf8, 0x39, 0x49, 0x83, 0xff, 0x06, 0x45, 0x90, 0x6a, 0x41, 0x32, 0x88, 0x01, 0xe5,
+	0x37, 0x68, 0xbb, 0x93, 0x7e, 0x34, 0x38, 0xd6, 0x3f, 0x4e, 0xb8, 0xa5, 0xdd, 0xa5, 0x4d, 0x70,
+	0x2a, 0xd5, 0x23, 0xfd, 0x2c, 0x63, 0xb3, 0xb3, 0x89, 0xf7, 0x7a, 0xe4, 0x8f, 0x87, 0xe8, 0x16,
+	0x8a, 0x8f, 0x6e, 0x2f, 0x0d, 0x93, 0x24, 0x76, 0x61, 0x76, 0x36, 0x69, 0x70, 0xe2, 0xf2, 0x7f,
+	0x4b, 0xa1, 0x65, 0x4a, 0xa4, 0xfe, 0x2d, 0x06, 0x68, 0x6f, 0x30, 0xee, 0x87, 0x21, 0x2d, 0x61,
+	0x35, 0x2f, 0x4e, 0x61, 0xe7, 0x67, 0x67, 0x93, 0x1a, 0xfc, 0xd2, 0x7f, 0x01, 0xf6, 0x70, 0x88,
+	0x5c, 0xf8, 0xd6, 0x8b, 0x8f, 0x3e, 0x58, 0x39, 0x50, 0x52, 0x35, 0x2f, 0xd9, 0xf9, 0xd9, 0xeb,
+	0x43, 0xbe, 0x14, 0xfd, 0x25, 0xd3, 0xfd, 0xb3, 0xb9, 0x1f, 0x8c, 0xc0, 0x01, 0xf9, 0x01, 0xf1,
+	0xd9, 0xe0, 0x7c, 0xbe, 0xb6, 0x92, 0xcf, 0x32, 0x79, 0xf3, 0x92, 0x7d, 0x45, 0x85, 0x72, 0xce,
+	0xd5, 0x1c, 0xdb, 0xe0, 0xd8, 0xf2, 0x1f, 0xee, 0xa0, 0x57, 0x4b, 0x2c, 0xe2, 0xfc, 0x28, 0xa0,
+	0x52, 0x72, 0x91, 0x87, 0x24, 0xf3, 0x5b, 0x2c, 0x7f, 0xdc, 0x0f, 0x3d, 0x7e, 0xce, 0xa0, 0x6d,
+	0x79, 0x3b, 0x77, 0xdc, 0x0f, 0x3b, 0x70, 0xd4, 0xd7, 0x58, 0x16, 0x34, 0x07, 0x95, 0xa2, 0x79,
+	0xc9, 0xe6, 0x4f, 0xfa, 0x87, 0x6c, 0x7b, 0x7e, 0xfc, 0x36, 0x1c, 0x0d, 0xfa, 0x63, 0xae, 0x73,
+	0xa8, 0x1d, 0xcd, 0x4b, 0xf6, 0x96, 0x00, 0x5b, 0x40, 0xf6, 0x35, 0xb6, 0x43, 0x5e, 0xd2, 0x8f,
+	0xfa, 0x60, 0xa1, 0x5c, 0x04, 0x59, 0x88, 0x19, 0x1c, 0xde, 0x21, 0xb0, 0x7e, 0x8b, 0xe5, 0xfc,
+	0xe8, 0xd8, 0x1b, 0x86, 0x11, 0x77, 0x48, 0x5b, 0xcd, 0x4b, 0xf6, 0xa6, 0x1f, 0x1d, 0xd7, 0xc3,
+	0x48, 0xa0, 0xc2, 0x60, 0xc0, 0x3d, 0x92, 0x40, 0x39, 0xc1, 0x40, 0xdf, 0x65, 0x79, 0x40, 0xf1,
+	0x0d, 0xe7, 0x69, 0x01, 0x40, 0xec, 0xc2, 0x9e, 0x76, 0x59, 0xfe, 0x74, 0xdc, 0x9f, 0x7a, 0xa7,
+	0xa3, 0x21, 0xba, 0x24, 0x40, 0x02, 0xe4, 0x60, 0x34, 0x94, 0xc8, 0xf9, 0x60, 0x8e, 0x5e, 0x49,
+	0x20, 0xad, 0xc1, 0x1c, 0x66, 0x1c, 0xcd, 0xbd, 0x61, 0x38, 0x98, 0xa3, 0x4f, 0x82, 0x19, 0x47,
+	0xf3, 0x7a, 0x38, 0x98, 0xeb, 0x37, 0xd9, 0xe6, 0x68, 0xee, 0xf9, 0x83, 0x69, 0x69, 0x8b, 0x30,
+	0x1b, 0xa3, 0xb9, 0x39, 0x98, 0x02, 0xc3, 0xd1, 0xdc, 0xe3, 0x89, 0x40, 0x69, 0x5b, 0x30, 0x1c,
+	0xcd, 0x2d, 0x9e, 0x58, 0x70, 0xe4, 0xe9, 0x63, 0xbe, 0x87, 0x9d, 0x18, 0x79, 0xfa, 0x98, 0x36,
+	0xc1, 0x91, 0xb0, 0xf7, 0xcb, 0x2a, 0x92, 0x36, 0x1f, 0x0d, 0xe6, 0x7c, 0xa0, 0x26, 0x96, 0x12,
+	0x0d, 0xe6, 0x30, 0x8e, 0x50, 0x30, 0xec, 0x8a, 0x82, 0xa2, 0x51, 0x27, 0x43, 0x1c, 0xa5, 0x0b,
+	0xd4, 0xc9, 0x50, 0x8c, 0x02, 0x14, 0x8c, 0xba, 0xaa, 0xa0, 0x60, 0xd4, 0x2e, 0xcb, 0x87, 0x83,
+	0x08, 0x87, 0x5d, 0x13, 0x0b, 0x01, 0x08, 0xad, 0x92, 0x23, 0x61, 0xe0, 0x75, 0x15, 0x09, 0x23,
+	0x1f, 0xb0, 0xe2, 0x68, 0x30, 0x81, 0x4d, 0xf0, 0xa3, 0xb8, 0x41, 0x78, 0x86, 0x40, 0x7e, 0x1a,
+	0x31, 0xc9, 0x60, 0x36, 0xf4, 0x4b, 0x37, 0x93, 0x24, 0xb5, 0xd9, 0xd0, 0x07, 0xd9, 0xf6, 0x83,
+	0xb9, 0x37, 0x9b, 0x97, 0x4a, 0x42, 0xb6, 0xfd, 0x60, 0xde, 0xe3, 0xe7, 0x01, 0x88, 0x70, 0xde,
+	0x2f, 0xdd, 0x12, 0x6b, 0xee, 0x07, 0x73, 0x67, 0xde, 0x17, 0xa8, 0x68, 0xde, 0x2f, 0xdd, 0x56,
+	0x50, 0x6e, 0x8c, 0x0a, 0x8f, 0xfb, 0xa5, 0x5d, 0xa1, 0x37, 0x30, 0xea, 0x38, 0x1e, 0x75, 0xdc,
+	0x2f, 0xdd, 0x51, 0x50, 0xee, 0x71, 0x9f, 0x4e, 0xe3, 0x09, 0x17, 0xc2, 0x5d, 0xc2, 0xc1, 0x69,
+	0x3c, 0x89, 0x8f, 0xea, 0x09, 0x17, 0xc2, 0x07, 0x2a, 0x52, 0x08, 0x01, 0x90, 0xaf, 0xc7, 0xfd,
+	0x43, 0x7f, 0x5c, 0xba, 0x27, 0x77, 0x38, 0x3f, 0x7d, 0xd2, 0xe0, 0x30, 0x29, 0x84, 0x27, 0x28,
+	0xa7, 0xfb, 0x09, 0x21, 0x3c, 0x49, 0xc8, 0xe9, 0x09, 0xca, 0xe9, 0x41, 0x92, 0x84, 0xcb, 0xe9,
+	0xab, 0x6c, 0x87, 0x4f, 0x34, 0x1d, 0x7a, 0x51, 0x3f, 0x38, 0xf2, 0xa3, 0x52, 0x99, 0xd6, 0xb2,
+	0x05, 0xf0, 0xee, 0xd0, 0xe5, 0x50, 0xfd, 0x3e, 0x2d, 0x68, 0x3a, 0xf4, 0xc2, 0x70, 0x5c, 0xfa,
+	0x0a, 0x11, 0x15, 0x90, 0xc8, 0x09, 0xc7, 0x2a, 0x45, 0x34, 0x1e, 0x97, 0x1e, 0x26, 0x29, 0xdc,
+	0xf1, 0x58, 0xbf, 0xc7, 0xd8, 0x64, 0x3e, 0x0e, 0x3d, 0xdc, 0xd3, 0x87, 0xb4, 0x9a, 0x02, 0xc0,
+	0xda, 0x7c, 0x4b, 0xb7, 0x58, 0x8e, 0x13, 0x44, 0x83, 0xd2, 0x57, 0xc5, 0x01, 0x00, 0xc0, 0xe5,
+	0xd2, 0xe2, 0xa8, 0xc3, 0x59, 0x58, 0xfa, 0x9a, 0x50, 0x19, 0x80, 0x54, 0x67, 0x21, 0x20, 0xe7,
+	0x87, 0x87, 0xde, 0x28, 0x1c, 0x0d, 0x4b, 0x1f, 0x09, 0xe4, 0xfc, 0xf0, 0xb0, 0x15, 0x8e, 0x86,
+	0xfa, 0x5d, 0x56, 0x88, 0x4e, 0xa6, 0x53, 0x7f, 0x0c, 0x51, 0xf8, 0xeb, 0xe4, 0x31, 0xf2, 0x08,
+	0x6a, 0x0d, 0xa5, 0xa4, 0xfd, 0xb3, 0xe8, 0x78, 0x18, 0x94, 0x2a, 0xaa, 0xa4, 0x4d, 0x0e, 0xd3,
+	0x3f, 0x61, 0x57, 0x93, 0x8e, 0x07, 0x7d, 0xdb, 0x88, 0xf3, 0x4a, 0xd9, 0x57, 0x12, 0xde, 0x87,
+	0xfb, 0xb9, 0x32, 0xdb, 0x22, 0x0f, 0x84, 0xa4, 0xbf, 0xc2, 0x85, 0x91, 0xb2, 0x19, 0xba, 0x21,
+	0x95, 0x26, 0x0c, 0x06, 0x48, 0xf3, 0xb9, 0x42, 0xe3, 0x04, 0x03, 0x4e, 0xf3, 0x90, 0x6d, 0x0b,
+	0xb7, 0x83, 0x44, 0x13, 0xbe, 0xbc, 0x94, 0x5d, 0x24, 0xdf, 0x23, 0xa8, 0x84, 0x47, 0x40, 0xaa,
+	0x40, 0x50, 0x91, 0x5b, 0x48, 0x50, 0xc9, 0x45, 0x85, 0x2a, 0x95, 0xb2, 0x2a, 0x32, 0x0f, 0x24,
+	0xfa, 0x35, 0x22, 0x62, 0x68, 0x23, 0x2a, 0x4d, 0x24, 0x68, 0xfe, 0xb2, 0x42, 0xe3, 0x12, 0xcd,
+	0x87, 0x7c, 0xb6, 0x27, 0xf1, 0x9a, 0xfe, 0x4a, 0x8a, 0xf6, 0x57, 0x24, 0x03, 0x48, 0x90, 0xc9,
+	0x45, 0xfd, 0x7a, 0x82, 0x4c, 0xac, 0xea, 0x1b, 0x4c, 0x53, 0xcc, 0x01, 0x29, 0x7f, 0x23, 0x45,
+	0xd3, 0xee, 0xc4, 0x46, 0x21, 0x78, 0x0a, 0x6d, 0x40, 0xca, 0xbf, 0x29, 0x28, 0x8b, 0xa4, 0x13,
+	0x9c, 0x0c, 0xc2, 0x89, 0xd0, 0x0b, 0xa4, 0xfb, 0xcd, 0x14, 0x9d, 0xe8, 0x96, 0xd0, 0x8e, 0xc4,
+	0xe4, 0xa8, 0x21, 0x48, 0xfa, 0x5b, 0x89, 0xc9, 0x51, 0x4f, 0x80, 0x18, 0x22, 0xea, 0x69, 0x7f,
+	0x7c, 0xe2, 0x57, 0x37, 0x31, 0xd3, 0x29, 0x7b, 0xec, 0xf6, 0xfa, 0xa8, 0x0c, 0x29, 0x2d, 0x60,
+	0xb0, 0xc8, 0xa0, 0xe4, 0x0a, 0x92, 0x8c, 0x26, 0x96, 0x61, 0xa0, 0x23, 0xca, 0x20, 0xca, 0x3f,
+	0x13, 0xb0, 0xf2, 0x3f, 0xcb, 0x62, 0xa9, 0xd8, 0x1f, 0x40, 0xfd, 0xa8, 0x7f, 0x92, 0x88, 0xd9,
+	0xcb, 0xb9, 0x21, 0x92, 0xa9, 0x39, 0xd2, 0xb7, 0xd9, 0xe6, 0xec, 0x24, 0x9a, 0x9f, 0x44, 0x94,
+	0x1b, 0x7e, 0xb0, 0x6e, 0x0c, 0x52, 0x81, 0x51, 0xe2, 0x2f, 0xfd, 0x17, 0xc8, 0x28, 0xa3, 0x68,
+	0xcc, 0x43, 0x7a, 0x71, 0x45, 0xa5, 0x48, 0x63, 0x05, 0x9d, 0x30, 0x5b, 0x37, 0x1a, 0xeb, 0x8f,
+	0x58, 0x76, 0x7e, 0x12, 0x1e, 0x53, 0x46, 0xb4, 0x76, 0xa9, 0x40, 0xc3, 0x73, 0x85, 0x93, 0xf0,
+	0x18, 0xa6, 0x9c, 0xcf, 0xe6, 0x9c, 0x1d, 0x65, 0x40, 0x6b, 0xa7, 0x14, 0x74, 0xdc, 0x19, 0xcc,
+	0xe6, 0x9d, 0xf9, 0x38, 0xd4, 0xbf, 0xc9, 0x36, 0x8e, 0x82, 0xd9, 0xc9, 0x9c, 0x27, 0x06, 0xc5,
+	0x47, 0x77, 0xd7, 0x8d, 0xe5, 0x44, 0x10, 0x34, 0xf8, 0x0f, 0xfd, 0x5b, 0x6c, 0x73, 0xfa, 0x86,
+	0x6f, 0x33, 0x77, 0xbe, 0x88, 0x90, 0x0a, 0x06, 0x4e, 0xdf, 0xc0, 0x16, 0x9f, 0xb2, 0x42, 0xe8,
+	0x47, 0x94, 0xb1, 0xe5, 0xf9, 0xd8, 0x07, 0xeb, 0xc6, 0x4a, 0x42, 0xf0, 0x4f, 0xa1, 0x1f, 0x61,
+	0xf2, 0xf7, 0xdd, 0x05, 0x15, 0x28, 0x70, 0x26, 0x0f, 0xd7, 0x31, 0x51, 0x69, 0xc1, 0x89, 0xab,
+	0xcf, 0xd5, 0x3c, 0xdb, 0x44, 0xb2, 0xf2, 0x53, 0x4c, 0xf7, 0x12, 0x07, 0xcb, 0x6b, 0x2e, 0x48,
+	0xbf, 0x52, 0x54, 0x73, 0x51, 0x35, 0x09, 0x45, 0x55, 0x5c, 0xbc, 0x6e, 0x4e, 0xfa, 0x67, 0x50,
+	0xb7, 0x7e, 0x82, 0xf5, 0xd4, 0xc2, 0xf1, 0x42, 0xf2, 0x27, 0x55, 0x82, 0xaa, 0x57, 0x3a, 0xee,
+	0xf2, 0xc7, 0x58, 0xca, 0x28, 0xa7, 0x0a, 0xa9, 0xbf, 0x1f, 0x1d, 0xfb, 0x81, 0xd4, 0xd8, 0x6d,
+	0x3b, 0x06, 0x94, 0x3f, 0x4b, 0x4c, 0x21, 0x8e, 0xf3, 0x0b, 0x06, 0xfd, 0x34, 0xd3, 0x16, 0xcf,
+	0x11, 0x16, 0xc5, 0x7f, 0x28, 0x25, 0x35, 0x7f, 0x6e, 0x0d, 0xcb, 0x95, 0x84, 0x20, 0xf0, 0xf8,
+	0xf4, 0xeb, 0xf2, 0xb8, 0xa9, 0x9c, 0xe7, 0x87, 0x59, 0x6e, 0xb2, 0x6b, 0xab, 0x8e, 0x4b, 0xff,
+	0x84, 0xb2, 0x68, 0x4e, 0x7d, 0x7e, 0x7d, 0x41, 0xe9, 0xf6, 0x73, 0x76, 0x73, 0xcd, 0x99, 0x2d,
+	0x99, 0x7c, 0x6a, 0xd9, 0xe4, 0xe1, 0xa0, 0x78, 0xfe, 0x0b, 0x27, 0xb2, 0x65, 0xf3, 0xdf, 0xe5,
+	0xdf, 0xcd, 0xa0, 0x78, 0x47, 0xd3, 0x30, 0x0a, 0x4e, 0xd0, 0x17, 0xe8, 0x8a, 0x2f, 0xd8, 0x26,
+	0x6b, 0x6f, 0x32, 0x76, 0x34, 0x8b, 0x66, 0x58, 0xb5, 0x92, 0xc5, 0x2f, 0x17, 0x11, 0x0a, 0x17,
+	0x2f, 0x26, 0x87, 0x68, 0x0d, 0x4f, 0xbc, 0xc4, 0xd5, 0x5d, 0xb6, 0xf3, 0x26, 0x18, 0x45, 0x4a,
+	0x3e, 0x8e, 0x3e, 0xe0, 0x1b, 0xe7, 0x72, 0x4b, 0x0e, 0x81, 0xe4, 0x9d, 0x43, 0x64, 0xf2, 0xfe,
+	0x94, 0xe5, 0x50, 0x2c, 0x21, 0xf9, 0x85, 0x87, 0xe7, 0xb2, 0x23, 0x5a, 0xb0, 0x71, 0xfa, 0xa9,
+	0x7f, 0x87, 0x6d, 0x4c, 0x7c, 0x10, 0x1d, 0xfa, 0x87, 0xf2, 0xb9, 0xe3, 0x39, 0x25, 0xd8, 0x2b,
+	0xff, 0xa1, 0xf7, 0x16, 0xa4, 0xbf, 0xb9, 0xa6, 0x81, 0xa5, 0xb2, 0x38, 0xd7, 0xe4, 0x36, 0xf1,
+	0xa8, 0xca, 0xdf, 0xc2, 0x30, 0xb0, 0x5a, 0xae, 0xe7, 0xf4, 0x7c, 0xca, 0x7d, 0xf6, 0xc1, 0xf9,
+	0x22, 0xd4, 0x6f, 0xb3, 0xbc, 0x3c, 0x01, 0xec, 0x5f, 0xc8, 0x67, 0xfd, 0x2b, 0x6c, 0x3b, 0x99,
+	0xb4, 0xa4, 0x39, 0xc1, 0xd6, 0x44, 0xc9, 0x56, 0xca, 0x6d, 0xd4, 0xc6, 0x15, 0x62, 0xd5, 0x3f,
+	0x8d, 0x4f, 0x03, 0x7b, 0x65, 0x37, 0xd7, 0x38, 0x1e, 0x29, 0xfe, 0xf2, 0x23, 0xec, 0x29, 0x2e,
+	0x09, 0x99, 0xbb, 0x06, 0xf8, 0xa1, 0x6c, 0x92, 0x3f, 0xb7, 0x86, 0xe5, 0x03, 0x6c, 0xed, 0xad,
+	0x93, 0xea, 0x8f, 0x6d, 0x14, 0xff, 0x25, 0x83, 0x9d, 0x0c, 0xbe, 0xde, 0xc9, 0x8c, 0x3a, 0x68,
+	0xb3, 0xcf, 0x47, 0x3e, 0x49, 0x8a, 0x9e, 0xf4, 0x7b, 0xac, 0x88, 0xbf, 0x54, 0x29, 0x31, 0x04,
+	0xf1, 0x24, 0x40, 0x3d, 0xa1, 0x4c, 0xb2, 0x2b, 0xf7, 0x73, 0x2c, 0x37, 0x98, 0x4d, 0x26, 0xfd,
+	0x29, 0xd6, 0xf6, 0x3b, 0x2b, 0x3c, 0xbc, 0x98, 0xdf, 0x23, 0x42, 0x5b, 0x8c, 0xd0, 0x1f, 0xb0,
+	0xad, 0xd1, 0x70, 0xec, 0x7b, 0xd1, 0x68, 0xe2, 0xcf, 0x4e, 0x22, 0xea, 0x7f, 0x14, 0x01, 0xe6,
+	0x22, 0x08, 0x48, 0x8e, 0xfb, 0xc1, 0x50, 0x92, 0x60, 0x93, 0xad, 0x08, 0x30, 0x41, 0x72, 0x9b,
+	0xe5, 0xe7, 0xc1, 0x68, 0x16, 0x8c, 0xa2, 0xb7, 0xd4, 0x69, 0x93, 0xcf, 0xfa, 0x2e, 0x2b, 0x60,
+	0xfb, 0x0a, 0x96, 0x8e, 0x7d, 0xb6, 0x3c, 0x02, 0x5a, 0xbc, 0xd9, 0x38, 0x3b, 0x89, 0xb0, 0xea,
+	0xc6, 0x56, 0x5b, 0x6e, 0x76, 0x12, 0xf1, 0x72, 0x7b, 0x97, 0x15, 0x00, 0x85, 0xe1, 0x12, 0x9b,
+	0x6d, 0x40, 0xbb, 0xc7, 0x3d, 0xaa, 0xec, 0x77, 0x16, 0xd5, 0x7e, 0xe7, 0x4f, 0xb1, 0x0d, 0xde,
+	0x81, 0xe1, 0xf5, 0x6c, 0xf1, 0xd1, 0x8d, 0xd5, 0xfd, 0x19, 0x1b, 0x89, 0xf4, 0xa7, 0x6c, 0x4b,
+	0x39, 0xf0, 0xb0, 0xb4, 0xcd, 0x15, 0xec, 0xce, 0x79, 0xb6, 0x66, 0x27, 0x46, 0x94, 0xbf, 0x9f,
+	0xc2, 0xd4, 0xe7, 0xf0, 0x64, 0xf0, 0xb9, 0x1f, 0xc1, 0xe1, 0xbe, 0xf1, 0x47, 0x47, 0xc7, 0x22,
+	0x82, 0xd1, 0x13, 0x24, 0x59, 0x6f, 0x78, 0x63, 0x88, 0x6f, 0x13, 0xc3, 0x58, 0x81, 0x43, 0xf8,
+	0x46, 0xef, 0xb1, 0x22, 0xa2, 0x71, 0xab, 0x78, 0xba, 0x38, 0x02, 0x37, 0xfb, 0xa9, 0xea, 0x92,
+	0x2e, 0x66, 0x04, 0xff, 0x9e, 0x9a, 0x47, 0x18, 0x76, 0x40, 0xf3, 0x7e, 0x3e, 0xd6, 0x12, 0x4c,
+	0xcd, 0x96, 0xfd, 0x92, 0x24, 0x5e, 0x56, 0x93, 0x8f, 0x13, 0x6d, 0xfe, 0xdd, 0x35, 0x43, 0x95,
+	0xa4, 0x4e, 0x0d, 0x79, 0x99, 0x44, 0xc8, 0x83, 0xed, 0xa0, 0xc0, 0xd6, 0x6f, 0x07, 0xf1, 0xb6,
+	0xa0, 0x2b, 0xff, 0x66, 0x8a, 0xed, 0xf0, 0x8e, 0x60, 0x1f, 0x9e, 0x21, 0x5f, 0x48, 0xaa, 0x55,
+	0x6a, 0x41, 0xad, 0x6e, 0xb2, 0xdc, 0x68, 0xaa, 0x8a, 0x7b, 0x73, 0x34, 0xe5, 0xb2, 0x56, 0x44,
+	0x99, 0xb9, 0x98, 0x28, 0xa5, 0x5d, 0x67, 0x55, 0xbb, 0x26, 0xf1, 0xd2, 0x7a, 0x46, 0xd3, 0xf3,
+	0x97, 0xf3, 0xb3, 0xb2, 0x63, 0x9a, 0x5e, 0x63, 0xa0, 0x92, 0xd1, 0x62, 0xdb, 0xf4, 0x1c, 0xbb,
+	0x8f, 0x7d, 0x49, 0x36, 0xe1, 0x4b, 0xa4, 0x15, 0x6c, 0x5c, 0xc4, 0x0a, 0xc4, 0xf6, 0x36, 0x95,
+	0xed, 0xfd, 0xfd, 0x0c, 0x26, 0x31, 0x7c, 0x50, 0xe0, 0x4f, 0x66, 0xa7, 0xfe, 0x7a, 0xd7, 0xa5,
+	0xda, 0x7e, 0x7a, 0xc1, 0xf6, 0x7f, 0x5e, 0x6e, 0x3c, 0xc3, 0x37, 0xfe, 0x70, 0xb5, 0x67, 0xa2,
+	0x29, 0xce, 0xdb, 0x7b, 0x36, 0xb9, 0xf7, 0x07, 0x6c, 0x6b, 0x78, 0x12, 0xf4, 0x29, 0x11, 0x1a,
+	0x08, 0xb7, 0x25, 0x60, 0x8e, 0x3f, 0x80, 0xd0, 0x23, 0x49, 0xa6, 0x40, 0x83, 0x7e, 0x4b, 0x8e,
+	0xeb, 0x86, 0xfe, 0x60, 0xc9, 0xfd, 0xe5, 0xbe, 0xd8, 0xfd, 0xe5, 0x97, 0xdd, 0xdf, 0x03, 0xb6,
+	0x45, 0x07, 0x38, 0x98, 0x9d, 0x4c, 0xd1, 0x93, 0x65, 0xed, 0x22, 0xc2, 0x6a, 0x00, 0x02, 0x1f,
+	0x70, 0xf8, 0x36, 0xf2, 0x89, 0x80, 0x71, 0x82, 0x02, 0x40, 0x10, 0x2d, 0xcf, 0xec, 0xed, 0x05,
+	0xce, 0xac, 0xfc, 0x77, 0xe8, 0xbd, 0x19, 0x86, 0xb3, 0xc3, 0xfe, 0x74, 0x78, 0xd1, 0xf7, 0x66,
+	0xca, 0x88, 0xe4, 0x9b, 0xb9, 0x38, 0xc1, 0x86, 0x9f, 0xa0, 0x15, 0x41, 0x3f, 0xf2, 0x49, 0xe5,
+	0xf8, 0x6f, 0xbe, 0x85, 0x93, 0x20, 0x8c, 0xbc, 0x70, 0xf4, 0xab, 0x3e, 0x1d, 0x48, 0x81, 0x43,
+	0x9c, 0xd1, 0xaf, 0xfa, 0xe5, 0x29, 0x66, 0xcb, 0xca, 0x0c, 0xc3, 0x60, 0x36, 0x5f, 0x99, 0x03,
+	0x7e, 0x29, 0xf3, 0xfd, 0xdd, 0x14, 0xa6, 0x34, 0xea, 0x84, 0xe1, 0x60, 0x0e, 0xca, 0xd4, 0x0f,
+	0x3e, 0xff, 0x89, 0xcd, 0x0b, 0xe8, 0x79, 0xe0, 0x0f, 0xbc, 0xb1, 0x7f, 0xea, 0x8f, 0xc5, 0xfb,
+	0x02, 0x80, 0xb4, 0x01, 0x50, 0xfe, 0x57, 0x29, 0xb6, 0xbb, 0xb0, 0xac, 0x44, 0x9a, 0xf0, 0xff,
+	0xef, 0x84, 0x96, 0xb2, 0x98, 0x8d, 0x15, 0xd5, 0xfc, 0xbf, 0x20, 0xcf, 0x86, 0xcb, 0xb8, 0x60,
+	0xe0, 0x90, 0xc4, 0xcb, 0x81, 0x43, 0x06, 0xea, 0xb4, 0x1a, 0xa8, 0xd5, 0x54, 0x2c, 0x93, 0x48,
+	0xc5, 0xf4, 0x6f, 0xb3, 0x0d, 0xd8, 0xbc, 0x88, 0x0d, 0xe5, 0xf3, 0x04, 0x44, 0xef, 0x46, 0x71,
+	0x40, 0xf9, 0x19, 0xae, 0xdc, 0x0f, 0x82, 0x59, 0xe0, 0x4d, 0xc2, 0xa3, 0x95, 0x2a, 0xa0, 0xb3,
+	0x2c, 0xef, 0x45, 0xa6, 0xe9, 0x4d, 0xe1, 0x6c, 0xe8, 0x4b, 0x17, 0x98, 0x51, 0x5c, 0xe0, 0x6f,
+	0x90, 0x76, 0x21, 0xb7, 0x44, 0xe7, 0x64, 0x1d, 0xeb, 0x5b, 0x2c, 0xef, 0x9f, 0x61, 0x10, 0x24,
+	0xf6, 0x39, 0xff, 0x6c, 0xce, 0x1b, 0xa1, 0x8b, 0x92, 0xcf, 0x9c, 0x93, 0x3f, 0xaa, 0x71, 0xe6,
+	0x94, 0xec, 0xfc, 0x64, 0x1c, 0x8d, 0xe6, 0x7d, 0xfe, 0x52, 0xed, 0x7b, 0x27, 0x7e, 0x18, 0xe9,
+	0x9f, 0x25, 0xb4, 0xe8, 0xde, 0xb2, 0x90, 0xe4, 0x08, 0x45, 0x89, 0x56, 0x9f, 0x85, 0xce, 0xb2,
+	0x87, 0xb3, 0xe1, 0x5b, 0xb1, 0x7b, 0xf8, 0x5d, 0x8e, 0xc8, 0x96, 0x95, 0x79, 0xe7, 0xe3, 0xb7,
+	0x3f, 0xe9, 0x59, 0x7f, 0x3b, 0x85, 0xaf, 0x91, 0x87, 0x7e, 0x38, 0xe0, 0x2a, 0xf2, 0x3a, 0xe0,
+	0xbf, 0xf9, 0x7c, 0x05, 0x3b, 0x37, 0x79, 0x1d, 0xd4, 0x01, 0x85, 0x6f, 0xfd, 0xe4, 0xdb, 0xc4,
+	0x82, 0xbd, 0x79, 0xfc, 0x46, 0x20, 0x42, 0x42, 0xe0, 0xbb, 0xe4, 0xcd, 0x10, 0x11, 0x77, 0x19,
+	0x0b, 0xfd, 0x60, 0xd4, 0x1f, 0x7b, 0xd3, 0x93, 0x09, 0x97, 0x70, 0xc1, 0x2e, 0x20, 0xa4, 0x7b,
+	0x32, 0x81, 0x71, 0x43, 0x9c, 0x96, 0xdb, 0x44, 0xc1, 0xde, 0x1c, 0xce, 0x61, 0x5c, 0xf9, 0x0f,
+	0x52, 0xec, 0x86, 0x8c, 0x52, 0x61, 0xd4, 0x8f, 0x42, 0x79, 0x02, 0xe7, 0xbc, 0x26, 0x57, 0x93,
+	0xda, 0xf4, 0x39, 0x49, 0x6d, 0x66, 0x21, 0xa9, 0x5d, 0x17, 0xd0, 0x17, 0x8a, 0x83, 0x8d, 0xa5,
+	0xe2, 0x40, 0x46, 0x8f, 0xcd, 0x8b, 0x44, 0x8f, 0x7f, 0x93, 0xc1, 0x64, 0x2a, 0xde, 0x94, 0xbe,
+	0xc3, 0xd2, 0xa3, 0x21, 0x7f, 0x9b, 0x93, 0xb5, 0xd3, 0xa3, 0x73, 0xef, 0x00, 0x2c, 0x46, 0xde,
+	0xf4, 0x05, 0x22, 0x6f, 0x66, 0x45, 0xe4, 0x55, 0xd3, 0x86, 0xec, 0x42, 0xda, 0xf0, 0xe5, 0x14,
+	0x25, 0x52, 0xf1, 0x72, 0xaa, 0xe2, 0xc5, 0x42, 0xce, 0x27, 0x84, 0xfc, 0x25, 0xc6, 0xf0, 0xff,
+	0x47, 0xd5, 0xc7, 0x1f, 0x52, 0xa4, 0xe9, 0x1f, 0x1d, 0x05, 0xfe, 0x51, 0x3f, 0xf2, 0xff, 0xcc,
+	0x68, 0xe8, 0x5f, 0x62, 0xb7, 0x56, 0x6f, 0x0c, 0x9c, 0xd0, 0xe2, 0x41, 0xa5, 0xbe, 0xe8, 0xa0,
+	0xd2, 0x8b, 0x07, 0x75, 0x97, 0x31, 0x3e, 0x35, 0xa2, 0x71, 0x8f, 0x05, 0x80, 0x70, 0x74, 0xf9,
+	0x4f, 0x32, 0xe8, 0xfa, 0x51, 0x78, 0x74, 0x53, 0xc3, 0x9b, 0x07, 0xb3, 0xb9, 0x1f, 0xf0, 0x9c,
+	0x56, 0x75, 0x82, 0x1f, 0x2d, 0xdf, 0x78, 0x5a, 0x1a, 0xa6, 0x7a, 0xc3, 0x83, 0x85, 0x63, 0xc7,
+	0x06, 0xd8, 0x27, 0x17, 0xe1, 0xa2, 0x8e, 0xe3, 0xef, 0xc7, 0x94, 0x67, 0xdd, 0x66, 0xc5, 0xa9,
+	0x7f, 0x16, 0xa9, 0x97, 0x41, 0x8a, 0x8f, 0x3e, 0xbe, 0x08, 0x5b, 0x65, 0x58, 0xf3, 0x92, 0xcd,
+	0xe0, 0x91, 0xae, 0x90, 0xec, 0x2d, 0xb6, 0xc2, 0xbe, 0x71, 0x11, 0x7e, 0x2b, 0x3a, 0x62, 0x3f,
+	0xc7, 0x32, 0xb3, 0xb3, 0xc9, 0xda, 0x1b, 0x03, 0x2b, 0x98, 0xcc, 0xce, 0x26, 0xcd, 0x4b, 0x36,
+	0x8c, 0x02, 0x89, 0xad, 0x68, 0x89, 0x5d, 0x48, 0x62, 0xe7, 0x76, 0xc6, 0xc4, 0x9b, 0x92, 0xf2,
+	0x11, 0xfb, 0xca, 0x05, 0x24, 0xbe, 0x64, 0xb0, 0xa9, 0x1f, 0xd9, 0x60, 0xbf, 0xcb, 0xca, 0x5f,
+	0x7c, 0x06, 0xfa, 0x43, 0xb6, 0x13, 0x3f, 0x7a, 0xa3, 0x21, 0xce, 0xb4, 0x6d, 0x6f, 0xc9, 0x93,
+	0x69, 0x0d, 0xc3, 0xb2, 0x83, 0x6d, 0xb9, 0xf5, 0xf2, 0xff, 0x71, 0x5a, 0x67, 0xdf, 0x5c, 0xa7,
+	0xf8, 0x70, 0x1e, 0x10, 0x25, 0x67, 0x67, 0x13, 0xbe, 0xa2, 0x0c, 0x5e, 0xb6, 0x99, 0x9d, 0x4d,
+	0x60, 0x2d, 0x7f, 0x3b, 0xb5, 0x56, 0x82, 0xe7, 0x76, 0xd1, 0x56, 0xbc, 0x4d, 0x4a, 0x24, 0x51,
+	0x99, 0x64, 0x12, 0xf5, 0x0d, 0x96, 0xb8, 0x41, 0xe2, 0x51, 0xb6, 0x04, 0x2b, 0xd1, 0x54, 0x44,
+	0x1d, 0x32, 0xa7, 0xdf, 0x49, 0x33, 0x7d, 0x69, 0x4d, 0xe1, 0x79, 0x3e, 0x51, 0xdc, 0x42, 0x4b,
+	0x2b, 0xb7, 0xd0, 0x3e, 0x64, 0x3b, 0x4a, 0xfb, 0x12, 0xfc, 0x57, 0x86, 0x3b, 0x93, 0xed, 0xb8,
+	0x7f, 0x09, 0xbe, 0x5c, 0x25, 0xe3, 0xcd, 0x51, 0x72, 0x8f, 0x92, 0xec, 0x05, 0x00, 0x95, 0x4b,
+	0x49, 0x1b, 0x89, 0x4b, 0x49, 0xf7, 0x58, 0x71, 0xd2, 0x3f, 0xf3, 0xfc, 0x69, 0x14, 0x8c, 0xfc,
+	0x90, 0x42, 0x19, 0x9b, 0xf4, 0xcf, 0x4c, 0x84, 0xe8, 0x7b, 0x50, 0x72, 0x70, 0xf7, 0x03, 0xf8,
+	0x1c, 0x3f, 0xcd, 0x8b, 0x98, 0x11, 0xf8, 0x2b, 0x5b, 0x19, 0x5a, 0xfe, 0x7e, 0x0a, 0x9b, 0xf4,
+	0x48, 0x8a, 0xb1, 0xff, 0xfc, 0x58, 0x0f, 0xaa, 0x71, 0xaa, 0x7a, 0xd2, 0x6d, 0xbb, 0x88, 0x30,
+	0xf4, 0xa5, 0x0f, 0xd8, 0xd6, 0x78, 0x36, 0xfb, 0xfc, 0x64, 0xae, 0x78, 0xd3, 0xac, 0x5d, 0x44,
+	0x18, 0x92, 0x7c, 0x85, 0x6d, 0x73, 0xd9, 0xf9, 0x43, 0xa2, 0xc9, 0x52, 0x0f, 0x18, 0x81, 0xe8,
+	0x74, 0x3f, 0xc5, 0x44, 0x4b, 0xde, 0x33, 0x8b, 0xc3, 0xd8, 0xba, 0xcb, 0x5f, 0xe5, 0x3f, 0xa2,
+	0x3c, 0x26, 0x1e, 0xb3, 0xfe, 0xa2, 0xd8, 0x5d, 0xc6, 0x82, 0x33, 0xea, 0xb2, 0x84, 0x22, 0x22,
+	0x04, 0x67, 0x16, 0x02, 0x00, 0x1d, 0xc5, 0x68, 0xdc, 0x43, 0x21, 0x92, 0xe8, 0x5b, 0x2c, 0x1f,
+	0x9c, 0x79, 0x10, 0x40, 0x42, 0x5a, 0x7c, 0x2e, 0x38, 0xab, 0xc2, 0x23, 0x97, 0x9e, 0x40, 0x61,
+	0xd8, 0xcb, 0x45, 0x84, 0xc2, 0x39, 0xa1, 0x08, 0x9e, 0xfb, 0x43, 0x7e, 0xaa, 0x7c, 0xce, 0x3a,
+	0x02, 0x68, 0x4e, 0x81, 0xce, 0x89, 0x39, 0x05, 0x7a, 0x97, 0x15, 0x82, 0x33, 0x2c, 0x3f, 0x42,
+	0x4a, 0x55, 0xf2, 0xc1, 0x99, 0xc9, 0x9f, 0x01, 0x19, 0x49, 0x24, 0x66, 0x2a, 0xf9, 0x48, 0x20,
+	0xef, 0xb3, 0xad, 0xe0, 0xcc, 0x7b, 0x1d, 0xf4, 0x27, 0x3e, 0x90, 0x50, 0xa2, 0xc2, 0x82, 0xb3,
+	0x06, 0x80, 0x4c, 0x7e, 0x35, 0xb2, 0x18, 0x9c, 0x79, 0xb3, 0x53, 0x3f, 0xe0, 0x04, 0x45, 0xb1,
+	0xb4, 0xde, 0xa9, 0x1f, 0x00, 0xfe, 0x0e, 0x5f, 0xf9, 0x20, 0x18, 0x70, 0xf4, 0x96, 0x98, 0xbc,
+	0x16, 0x0c, 0x70, 0x34, 0x1b, 0xcc, 0xc6, 0xe3, 0x51, 0x48, 0x79, 0x0b, 0xc5, 0x7a, 0x01, 0x59,
+	0xca, 0x10, 0x77, 0x2e, 0x90, 0x21, 0x5e, 0x5e, 0xce, 0x10, 0xcb, 0x8f, 0xf1, 0xb5, 0x00, 0xb6,
+	0x11, 0x97, 0x52, 0x9b, 0x75, 0x2f, 0xd4, 0x0e, 0xd0, 0xee, 0xb1, 0x73, 0x88, 0x0a, 0xe7, 0x07,
+	0xff, 0xf7, 0x49, 0x43, 0xf9, 0xfb, 0x69, 0x34, 0x1d, 0x65, 0x39, 0xe7, 0x2c, 0x83, 0x1f, 0x9f,
+	0xff, 0x3a, 0x61, 0x37, 0xf9, 0xc0, 0x7f, 0x2d, 0x8d, 0x26, 0xb1, 0x9a, 0xcc, 0x17, 0xad, 0x26,
+	0xbb, 0x98, 0xc2, 0x7c, 0x59, 0xfd, 0xaf, 0x2a, 0xdb, 0x22, 0x49, 0xf1, 0x1d, 0x91, 0x6f, 0xb9,
+	0xb7, 0xa6, 0x21, 0x2b, 0xc4, 0x69, 0x17, 0xf1, 0xd9, 0x81, 0x31, 0x50, 0xb6, 0xed, 0xc4, 0x92,
+	0xe1, 0xc5, 0xdb, 0x17, 0xdd, 0x93, 0x3c, 0xb7, 0x5d, 0x9c, 0x5e, 0xdb, 0x2e, 0xce, 0x5c, 0xb0,
+	0x5d, 0xfc, 0xfb, 0x29, 0xf5, 0xac, 0xc0, 0xaf, 0xbe, 0xd5, 0x7f, 0x99, 0xee, 0x9f, 0xe2, 0x3b,
+	0xd2, 0x75, 0x4b, 0x02, 0x92, 0xea, 0x4f, 0xfd, 0xfa, 0x7f, 0xff, 0x0f, 0x77, 0x37, 0x91, 0x1e,
+	0x7e, 0xde, 0xd1, 0x6f, 0x2b, 0xd4, 0x3f, 0x9d, 0xa4, 0xc6, 0x3b, 0xab, 0xfa, 0x23, 0xbc, 0x97,
+	0x2c, 0x12, 0xba, 0x3b, 0x6b, 0xf8, 0x73, 0x1a, 0xbc, 0xb5, 0x1c, 0x96, 0xff, 0x5a, 0x0a, 0x75,
+	0x15, 0x51, 0x32, 0x46, 0x5d, 0x63, 0x1b, 0xfc, 0x3a, 0xa3, 0x78, 0xf9, 0xcb, 0x1f, 0x96, 0x2e,
+	0xeb, 0xa6, 0x97, 0x2f, 0xeb, 0x82, 0xd2, 0x40, 0x20, 0xe1, 0xfc, 0x44, 0x90, 0x2e, 0x4c, 0xfa,
+	0x67, 0x3c, 0x79, 0x0f, 0xf5, 0x52, 0xf2, 0x3d, 0xc2, 0x76, 0x1c, 0xf8, 0xbf, 0xad, 0xf6, 0xac,
+	0x96, 0xbb, 0x0d, 0xe7, 0xbc, 0x39, 0xfb, 0x15, 0x7c, 0x27, 0xad, 0x34, 0x65, 0xd0, 0x34, 0x2a,
+	0xec, 0x0a, 0xa9, 0x38, 0x07, 0xaa, 0x56, 0x77, 0x19, 0x11, 0xd5, 0xfe, 0x14, 0x7d, 0xbf, 0xfe,
+	0x55, 0x76, 0x99, 0xeb, 0xba, 0x42, 0x89, 0xe6, 0xb7, 0x0d, 0x60, 0x49, 0x57, 0xfe, 0x3d, 0x32,
+	0x41, 0x9c, 0x4c, 0x9a, 0xe0, 0x9a, 0xa5, 0x2d, 0xa4, 0xf9, 0xe9, 0x85, 0x34, 0x1f, 0x66, 0x8d,
+	0xbb, 0xee, 0xaa, 0x1d, 0x6e, 0x23, 0xb8, 0x35, 0x45, 0xba, 0x32, 0xe3, 0xcb, 0x88, 0xa9, 0xd0,
+	0x18, 0x8b, 0x00, 0x14, 0x34, 0x5f, 0x96, 0x39, 0x3e, 0x65, 0x2c, 0x96, 0x21, 0x19, 0xe3, 0x83,
+	0xf3, 0x3a, 0x60, 0xa8, 0x4f, 0x05, 0xf8, 0x8d, 0xc6, 0xf8, 0x6b, 0xd8, 0xb9, 0x47, 0x92, 0x73,
+	0x3f, 0x0e, 0x50, 0x25, 0x97, 0x5e, 0xd3, 0x83, 0xcb, 0xfc, 0xa8, 0x3d, 0xb8, 0x7f, 0x4a, 0x2a,
+	0x8d, 0x04, 0x52, 0xa5, 0xe9, 0x6a, 0x3c, 0xbe, 0x16, 0x4f, 0xc9, 0xab, 0xf1, 0x1d, 0xfe, 0x5e,
+	0xf6, 0x2e, 0x6d, 0x1a, 0x95, 0x9e, 0xce, 0x09, 0x20, 0xee, 0x4a, 0xc5, 0xcf, 0xac, 0x50, 0x7c,
+	0xe2, 0x2f, 0x1a, 0x87, 0x82, 0x3f, 0xa8, 0x8e, 0x44, 0x0e, 0x66, 0xe3, 0x99, 0xe8, 0x79, 0x02,
+	0xb2, 0x06, 0xcf, 0xe5, 0x53, 0xf6, 0x80, 0xb7, 0xf9, 0x12, 0x0d, 0x3e, 0x69, 0x00, 0xc7, 0xab,
+	0xaf, 0x41, 0xa5, 0xbe, 0x20, 0x71, 0x5d, 0xe8, 0xfe, 0xad, 0xea, 0x2f, 0x8e, 0x31, 0xb8, 0x25,
+	0xe6, 0xfd, 0xc9, 0xcd, 0x66, 0x62, 0x1f, 0xf1, 0x7b, 0x27, 0xfe, 0x09, 0x25, 0xe6, 0x34, 0x17,
+	0xef, 0xc2, 0x60, 0xa2, 0x28, 0xce, 0x45, 0x16, 0xba, 0x4b, 0x3d, 0xe7, 0x72, 0x80, 0x8b, 0x56,
+	0xd8, 0x4c, 0x46, 0x53, 0x8f, 0xb7, 0x9e, 0x6b, 0xac, 0xa8, 0xf0, 0x25, 0x2f, 0xbb, 0xac, 0x38,
+	0x4b, 0x2b, 0xc0, 0xf4, 0x94, 0xae, 0x9b, 0x89, 0x9e, 0x76, 0x3a, 0xee, 0x69, 0xaf, 0x9a, 0xb3,
+	0x7f, 0xf6, 0x13, 0x9e, 0xf3, 0xef, 0x51, 0x67, 0x45, 0x19, 0x99, 0x90, 0xfe, 0x97, 0x32, 0xf1,
+	0x45, 0xaa, 0xa1, 0x55, 0x67, 0xf9, 0x57, 0x53, 0x68, 0xe2, 0xe4, 0xbc, 0xf8, 0x24, 0xa0, 0x0f,
+	0x38, 0x5b, 0xec, 0x06, 0xf9, 0x33, 0xd6, 0x35, 0x4a, 0x9f, 0x07, 0x6f, 0x55, 0x55, 0x13, 0x05,
+	0xc5, 0xba, 0x4e, 0xfb, 0x9a, 0xf5, 0x53, 0x2d, 0xf1, 0x08, 0xef, 0x4c, 0x20, 0xd1, 0x11, 0x4f,
+	0x0e, 0xc0, 0xdb, 0xc8, 0xa0, 0xb1, 0xe2, 0x36, 0x57, 0xf9, 0x08, 0x0b, 0xcc, 0x15, 0x63, 0xe6,
+	0xe3, 0xb7, 0x2b, 0xef, 0x7f, 0x7d, 0x93, 0x6d, 0x72, 0x6a, 0xf1, 0xf1, 0xc4, 0xdd, 0x75, 0xaf,
+	0x4e, 0x39, 0x95, 0x4d, 0xc4, 0x65, 0x73, 0xe9, 0xaa, 0x14, 0xca, 0x69, 0x4d, 0xdf, 0x5e, 0xca,
+	0x2e, 0x93, 0x90, 0x5d, 0xb9, 0xa3, 0x2a, 0xdf, 0xc5, 0xca, 0x92, 0x04, 0xbb, 0x74, 0x92, 0xdd,
+	0x1f, 0x53, 0x5e, 0xa2, 0xf0, 0xfb, 0x71, 0xf8, 0x24, 0x8a, 0x8e, 0xcc, 0x52, 0xd1, 0xa1, 0x54,
+	0x32, 0xd9, 0xc5, 0x4a, 0x26, 0x51, 0x38, 0x6c, 0x2c, 0x14, 0x0e, 0x8b, 0x51, 0x6c, 0xf3, 0x02,
+	0x51, 0x2c, 0xb7, 0x22, 0x71, 0x9f, 0xa0, 0x82, 0x06, 0xb3, 0xb1, 0x2f, 0xc5, 0xf5, 0x98, 0x65,
+	0xe1, 0x79, 0xed, 0x6b, 0xaf, 0xc1, 0x6c, 0x1a, 0x05, 0xb3, 0xf1, 0xd8, 0x0f, 0xf8, 0x38, 0x9b,
+	0x53, 0xc3, 0x74, 0x47, 0xfe, 0xd4, 0xa7, 0x09, 0x49, 0x10, 0x59, 0x7b, 0x2b, 0x06, 0xb6, 0x86,
+	0xe5, 0xdf, 0x22, 0x83, 0xe8, 0x87, 0x6f, 0xa7, 0x03, 0x11, 0xf3, 0x1e, 0xb2, 0x9d, 0x38, 0xba,
+	0xf3, 0xa6, 0x24, 0x75, 0x51, 0x44, 0x70, 0xe7, 0x6d, 0xc9, 0x8f, 0x98, 0xa6, 0x7c, 0xd9, 0x24,
+	0xee, 0xde, 0x00, 0xdd, 0x0e, 0xc0, 0x1d, 0x0e, 0xe6, 0x94, 0x15, 0x76, 0x25, 0xf1, 0xaa, 0x9a,
+	0x93, 0x62, 0x86, 0x75, 0x19, 0x10, 0x36, 0xc2, 0xf9, 0x7d, 0xa6, 0x17, 0xec, 0x72, 0x63, 0x3c,
+	0x7b, 0xc3, 0x7b, 0x35, 0xfb, 0xf3, 0x21, 0xb8, 0x2a, 0x6c, 0xb0, 0xe3, 0x7b, 0x8c, 0xf4, 0x68,
+	0xa8, 0x3f, 0x66, 0x79, 0x71, 0x27, 0x87, 0x32, 0xc6, 0x5b, 0x6b, 0x2f, 0xed, 0xd8, 0x39, 0xf8,
+	0xd5, 0x99, 0x0d, 0xcb, 0x1e, 0xbb, 0x06, 0x8c, 0x79, 0x3a, 0x77, 0x1e, 0xf7, 0x6f, 0xb1, 0x82,
+	0xbc, 0xcb, 0x41, 0xec, 0x6f, 0xaf, 0xbf, 0xed, 0x61, 0x63, 0xea, 0x0d, 0x13, 0x7c, 0x87, 0x6d,
+	0xc0, 0x04, 0xa1, 0xfe, 0x29, 0xdb, 0x18, 0x45, 0xfe, 0x44, 0xb4, 0x8e, 0x76, 0x57, 0x2f, 0x8e,
+	0xb2, 0x59, 0x4e, 0x59, 0x7e, 0xca, 0x98, 0x5c, 0x5c, 0x08, 0xf9, 0xb0, 0xca, 0x60, 0x5d, 0x3e,
+	0xcc, 0x73, 0x73, 0xc1, 0xc1, 0x61, 0x79, 0x8b, 0x4e, 0x67, 0xd5, 0x96, 0xe4, 0x79, 0xae, 0xdd,
+	0x92, 0xa4, 0xb0, 0xf3, 0xe2, 0x98, 0xcb, 0x2f, 0x58, 0x01, 0x99, 0xf6, 0x4e, 0xa2, 0x25, 0xae,
+	0xdf, 0x61, 0x2c, 0xbe, 0x52, 0x42, 0x6c, 0x77, 0xd7, 0xb1, 0x9d, 0x9d, 0x44, 0x36, 0x2d, 0xa2,
+	0x77, 0x02, 0xbe, 0xac, 0x58, 0x3b, 0xee, 0x4f, 0x8f, 0x7c, 0xf3, 0xd4, 0x9f, 0x2e, 0xb3, 0xfe,
+	0x73, 0xac, 0xa8, 0xa8, 0xd6, 0xda, 0xb2, 0x40, 0xa1, 0x69, 0x5e, 0xb2, 0x59, 0xac, 0x75, 0xd5,
+	0x1c, 0xdb, 0xf0, 0x81, 0x73, 0xe5, 0x3f, 0xa7, 0x58, 0x51, 0x92, 0x4e, 0x67, 0xba, 0xc6, 0xb6,
+	0x7a, 0x0d, 0xcb, 0xf2, 0x5a, 0xdd, 0x03, 0xa3, 0xdd, 0xaa, 0x6b, 0x97, 0x74, 0x8d, 0xe5, 0x39,
+	0xa4, 0x63, 0xbc, 0xd4, 0xde, 0xfd, 0xf0, 0xfd, 0xfb, 0x9c, 0x7e, 0x4d, 0xd2, 0x78, 0x56, 0xcf,
+	0x76, 0xb5, 0xff, 0xf1, 0x1e, 0xa0, 0x3a, 0x63, 0x1c, 0xea, 0x1a, 0xd5, 0xb6, 0xa9, 0xfd, 0x4f,
+	0x0e, 0xbb, 0xca, 0x8a, 0x1c, 0xd6, 0xed, 0xd9, 0x1d, 0xa3, 0xad, 0xfd, 0x69, 0x82, 0xb0, 0xd1,
+	0xee, 0xf5, 0xea, 0xda, 0xff, 0xe2, 0x30, 0x31, 0x89, 0xd1, 0x6e, 0x6b, 0x3f, 0xe0, 0x90, 0x9b,
+	0xec, 0x32, 0x87, 0xd4, 0x7a, 0x5d, 0xd7, 0xee, 0xb5, 0xdb, 0xa6, 0xad, 0xfd, 0xef, 0xc4, 0xf0,
+	0x76, 0xaf, 0x66, 0xb4, 0xb5, 0x1f, 0x26, 0x87, 0x77, 0x5f, 0x69, 0xef, 0x01, 0x52, 0xf9, 0xb7,
+	0x1b, 0xf8, 0xba, 0x8f, 0x3b, 0xe1, 0x1d, 0x3e, 0xc4, 0xf5, 0x9a, 0x66, 0xbb, 0xdd, 0xd3, 0x2e,
+	0xc9, 0x67, 0xd3, 0xb6, 0x7b, 0xb6, 0x96, 0xd2, 0xaf, 0xb3, 0x2b, 0xf8, 0x5c, 0x6b, 0xf6, 0x3c,
+	0xdb, 0x7c, 0xbe, 0x6f, 0x3a, 0xae, 0x96, 0xd6, 0xaf, 0xf2, 0x25, 0x48, 0xb0, 0xd5, 0x7e, 0xa5,
+	0x65, 0x62, 0xda, 0x97, 0x96, 0x69, 0xb7, 0x3a, 0x66, 0xd7, 0x35, 0x6d, 0x2d, 0xab, 0xdf, 0x62,
+	0xd7, 0x39, 0xb8, 0x61, 0x1a, 0xee, 0xbe, 0x6d, 0x3a, 0x92, 0xcd, 0x86, 0x7e, 0x93, 0x5d, 0x5d,
+	0x44, 0x01, 0xab, 0x4d, 0x7d, 0x97, 0xdd, 0xe4, 0x88, 0x3d, 0xd3, 0x85, 0x6d, 0x36, 0x5a, 0x7b,
+	0x72, 0x54, 0x4e, 0x32, 0x4c, 0x20, 0x61, 0x5c, 0x5e, 0xae, 0xcb, 0x91, 0x28, 0xad, 0xa0, 0xeb,
+	0x6c, 0x87, 0x03, 0x2d, 0xa3, 0xf6, 0xcc, 0x74, 0xbd, 0x56, 0x57, 0x63, 0x72, 0xad, 0x8d, 0x76,
+	0xef, 0x85, 0x67, 0x9b, 0x9d, 0xde, 0x81, 0x59, 0xd7, 0x8a, 0xfa, 0x35, 0xa6, 0x21, 0x69, 0xcf,
+	0x76, 0x3d, 0xc7, 0x35, 0xdc, 0x7d, 0x47, 0xdb, 0x92, 0x5c, 0x89, 0x41, 0x6f, 0xdf, 0xd5, 0xb6,
+	0xf5, 0x2b, 0x6c, 0x3b, 0xe6, 0xd0, 0xe9, 0xd5, 0xb5, 0x1d, 0x39, 0xd1, 0x9e, 0xdd, 0xdb, 0xb7,
+	0x38, 0xec, 0xb2, 0x24, 0xe3, 0x1c, 0x01, 0xa4, 0x49, 0x32, 0xae, 0x0e, 0x1c, 0x76, 0x45, 0xbf,
+	0xcd, 0x6e, 0x70, 0x58, 0x67, 0xbf, 0xed, 0xb6, 0x2c, 0xc3, 0x76, 0xe5, 0x7e, 0x75, 0xbd, 0xc4,
+	0xae, 0x2d, 0xe1, 0x60, 0xbb, 0x57, 0x25, 0xa6, 0x6a, 0xd8, 0x76, 0xcb, 0xb4, 0xe5, 0x98, 0x6b,
+	0xfa, 0x0d, 0xa6, 0x2f, 0x60, 0x60, 0xc4, 0x75, 0xfd, 0x01, 0xbb, 0xcb, 0xe1, 0xcf, 0xf7, 0xcd,
+	0x7d, 0x73, 0x95, 0x78, 0x6f, 0xe8, 0xf7, 0xd8, 0xee, 0x3a, 0x12, 0xe0, 0x71, 0x53, 0xca, 0xce,
+	0xee, 0xb5, 0x4d, 0x39, 0xae, 0x24, 0xa5, 0x44, 0x60, 0xa0, 0xbd, 0x25, 0xf7, 0x05, 0x6c, 0x0c,
+	0xe7, 0x55, 0xb7, 0x26, 0x07, 0xdc, 0x96, 0xab, 0x57, 0x71, 0x30, 0x6a, 0x57, 0x4a, 0xc8, 0x11,
+	0x18, 0xed, 0x8e, 0x84, 0x75, 0x4c, 0xd7, 0xb4, 0xb9, 0xd4, 0xee, 0x56, 0x6a, 0xf8, 0xbe, 0x7c,
+	0xe1, 0xab, 0x74, 0x22, 0x6d, 0xf2, 0xb3, 0x16, 0xb6, 0x8a, 0x93, 0x01, 0xec, 0xc0, 0xb4, 0x9d,
+	0x56, 0xaf, 0x5b, 0x6d, 0xb9, 0x1d, 0xc3, 0xd2, 0x52, 0x15, 0x1f, 0xc3, 0x18, 0xa5, 0x44, 0x58,
+	0xa4, 0xa1, 0x1e, 0xd4, 0xbc, 0x86, 0x6d, 0xec, 0x09, 0x13, 0xbd, 0x44, 0x7c, 0x09, 0x5a, 0xb7,
+	0x7b, 0x96, 0x96, 0xa2, 0x5d, 0x13, 0xcc, 0x36, 0x0d, 0xa7, 0xa3, 0xa5, 0x93, 0x84, 0x1d, 0xc3,
+	0x79, 0xa6, 0x65, 0x2a, 0x4f, 0x71, 0x1a, 0xec, 0xf9, 0x52, 0xb4, 0x24, 0xe5, 0xa8, 0x29, 0xeb,
+	0x24, 0xe5, 0xae, 0x79, 0x75, 0xd3, 0xb2, 0xcd, 0x9a, 0xe1, 0x9a, 0x75, 0xc1, 0xe1, 0x17, 0xf1,
+	0x93, 0x58, 0xbc, 0x3a, 0x4c, 0x43, 0xd5, 0x2d, 0xee, 0xb0, 0x02, 0x82, 0xc0, 0x1f, 0xfd, 0x30,
+	0x15, 0x3f, 0x83, 0xeb, 0x78, 0x9f, 0xaa, 0xfc, 0x4b, 0x0a, 0xd8, 0x89, 0x12, 0x0e, 0xbd, 0x9a,
+	0xba, 0x02, 0xb9, 0x23, 0x50, 0x6c, 0xb0, 0x01, 0x47, 0x4b, 0x49, 0x81, 0xa0, 0xce, 0x22, 0x34,
+	0x2d, 0x49, 0xa5, 0xb9, 0x38, 0x5a, 0x56, 0x92, 0xa2, 0x15, 0x20, 0x34, 0x4f, 0xeb, 0xad, 0x79,
+	0x2d, 0x8b, 0xa4, 0x74, 0x5f, 0x12, 0xa2, 0xa2, 0x21, 0xe1, 0x53, 0xfd, 0x06, 0xd7, 0x2e, 0xe2,
+	0x59, 0x6d, 0xf7, 0x6a, 0xcf, 0xcc, 0xba, 0xf6, 0x2e, 0x5d, 0x39, 0x55, 0xbe, 0x88, 0x4e, 0x88,
+	0x6f, 0xc5, 0xe2, 0xc5, 0xf0, 0x7a, 0xef, 0x45, 0x57, 0x4b, 0xc5, 0x74, 0x5d, 0x70, 0x56, 0xb5,
+	0x03, 0x2d, 0x2b, 0x9c, 0x39, 0x07, 0x35, 0x5e, 0xd4, 0xb5, 0xfb, 0x64, 0x31, 0x08, 0x89, 0x3d,
+	0xc5, 0xd3, 0xca, 0x9f, 0x5f, 0xe8, 0x76, 0x0b, 0xd1, 0x5b, 0xce, 0xf2, 0xb4, 0x8e, 0xd7, 0x6e,
+	0x75, 0x9f, 0x2d, 0x4c, 0xeb, 0xc8, 0x5d, 0xa4, 0xc9, 0xbd, 0x72, 0xba, 0x03, 0x53, 0xcb, 0x56,
+	0xfe, 0x28, 0x8d, 0xdf, 0x21, 0x70, 0xee, 0xb2, 0x6c, 0xa7, 0x81, 0x0d, 0x65, 0x02, 0x09, 0xfa,
+	0xf4, 0x93, 0x4e, 0xd5, 0x6b, 0xd6, 0x63, 0xf6, 0x04, 0x6a, 0xd4, 0xa5, 0xde, 0x71, 0x10, 0x91,
+	0x65, 0x17, 0x61, 0x8d, 0xba, 0x96, 0x17, 0xbb, 0x6f, 0x78, 0x9f, 0xee, 0x71, 0x2a, 0x2d, 0x09,
+	0x69, 0x80, 0x3c, 0x14, 0xf6, 0x08, 0x7a, 0xaa, 0xeb, 0x02, 0xf4, 0x98, 0x40, 0xef, 0x40, 0xff,
+	0x63, 0xf6, 0x04, 0x4c, 0xeb, 0x57, 0x24, 0x37, 0x17, 0x41, 0x20, 0xf0, 0x22, 0x82, 0x7a, 0x6e,
+	0xd3, 0xb4, 0xb5, 0x77, 0xf9, 0x98, 0xa8, 0xd6, 0xb3, 0x2c, 0x00, 0x69, 0x31, 0x51, 0xa3, 0x55,
+	0x05, 0xc8, 0xfd, 0x78, 0x4a, 0x63, 0xdf, 0xed, 0x75, 0xcd, 0x3d, 0xed, 0xdd, 0x53, 0xfd, 0x8a,
+	0xa0, 0xb2, 0x8c, 0x7d, 0xc7, 0xd4, 0xde, 0xbd, 0x4b, 0xe9, 0x37, 0xb8, 0x2a, 0x09, 0x10, 0xf8,
+	0x8c, 0x8e, 0xf6, 0xee, 0x5d, 0xba, 0x52, 0x57, 0x94, 0x86, 0x6e, 0x37, 0x6e, 0x73, 0xab, 0xb0,
+	0x6c, 0xcf, 0xa8, 0x63, 0x0c, 0xdf, 0xc2, 0xc7, 0xba, 0xd9, 0x36, 0x5d, 0x53, 0x4b, 0xc5, 0x90,
+	0x4e, 0xaf, 0xde, 0x6a, 0xbc, 0xd2, 0xd2, 0x95, 0xcf, 0x50, 0x05, 0xe2, 0xaf, 0xcc, 0x49, 0xa8,
+	0x1d, 0xae, 0xf4, 0xdd, 0xba, 0x61, 0x03, 0x27, 0x64, 0xdc, 0x71, 0xbd, 0xde, 0xcb, 0x8e, 0x96,
+	0xaa, 0x7c, 0x1e, 0x7f, 0x46, 0xce, 0xbf, 0x0b, 0x27, 0xbe, 0x2f, 0x3b, 0x35, 0xaf, 0xfb, 0xb2,
+	0xe3, 0x7d, 0x22, 0xe7, 0x16, 0x90, 0x4f, 0xb5, 0x94, 0xbe, 0xcb, 0xad, 0x1f, 0x20, 0x3d, 0xcb,
+	0xec, 0x72, 0x0b, 0xac, 0x1a, 0x4e, 0xab, 0x06, 0x9b, 0xd1, 0x6f, 0xf1, 0x68, 0x09, 0xc8, 0x44,
+	0x84, 0x7d, 0xff, 0x3e, 0x53, 0xf9, 0x5b, 0x79, 0x76, 0x75, 0xc5, 0x97, 0xd9, 0xa4, 0xd4, 0x2f,
+	0x61, 0x51, 0x8d, 0xaa, 0xcc, 0x4a, 0x2e, 0x91, 0x5b, 0x56, 0xe1, 0xcd, 0x57, 0x88, 0x4b, 0x51,
+	0x50, 0x16, 0xb8, 0x8e, 0xe9, 0x1a, 0x75, 0xc3, 0x35, 0xb4, 0xf4, 0x02, 0x33, 0xd3, 0x6d, 0x7a,
+	0x75, 0xc7, 0xd5, 0x32, 0x2b, 0xe0, 0x8e, 0x5d, 0xd3, 0xb2, 0x0b, 0x8c, 0x00, 0xee, 0xbe, 0xb2,
+	0x4c, 0x19, 0xf6, 0x05, 0xe2, 0xa0, 0x6d, 0x74, 0xbd, 0x83, 0x56, 0x5d, 0xdb, 0x5c, 0x85, 0xb0,
+	0x6a, 0x96, 0x96, 0x5b, 0xdc, 0x87, 0xe5, 0xd5, 0x9d, 0x9a, 0xa5, 0xe5, 0x29, 0x14, 0x29, 0x70,
+	0xb3, 0xd6, 0xd5, 0x0a, 0x0b, 0x7c, 0x5a, 0x96, 0x67, 0xd9, 0x3d, 0xb7, 0xa7, 0xb1, 0x25, 0xc4,
+	0xc1, 0x63, 0xbe, 0xd6, 0xe2, 0x2a, 0x04, 0x6c, 0x6e, 0x6b, 0x61, 0x66, 0xb7, 0x66, 0xf1, 0x01,
+	0xdb, 0x2b, 0xe0, 0x40, 0xbf, 0xb3, 0x00, 0xdf, 0xaf, 0x23, 0xfd, 0xe5, 0x15, 0x70, 0xa0, 0xd7,
+	0x16, 0x26, 0x76, 0x6a, 0x2e, 0x0e, 0xb8, 0xb2, 0x0a, 0x51, 0xe7, 0xe9, 0xc0, 0xc2, 0xd9, 0xd5,
+	0x3a, 0xb0, 0x58, 0x2e, 0xd9, 0xab, 0xab, 0x71, 0xb5, 0x5e, 0xdd, 0xd4, 0xae, 0x2d, 0xc8, 0xca,
+	0xb0, 0x2d, 0xaf, 0x67, 0x69, 0xd7, 0x17, 0x16, 0x06, 0x60, 0xc7, 0x32, 0xb4, 0x1b, 0x2b, 0xe0,
+	0xae, 0x65, 0x68, 0x37, 0x57, 0xd1, 0x37, 0x0d, 0xad, 0xb4, 0x8a, 0xbe, 0x69, 0x68, 0xb7, 0x96,
+	0x25, 0xfb, 0x84, 0x6f, 0xf0, 0xf6, 0x2a, 0x04, 0x6c, 0x70, 0x77, 0x71, 0x13, 0x80, 0x68, 0xb4,
+	0x8d, 0xaa, 0xd9, 0xd6, 0xee, 0xac, 0xda, 0xe0, 0x13, 0xdc, 0xfc, 0xdd, 0xd5, 0x38, 0xbe, 0xf9,
+	0x0f, 0xf4, 0xbb, 0xec, 0xd6, 0x22, 0xcf, 0x6e, 0xdd, 0x73, 0x0d, 0x7b, 0xcf, 0x74, 0xb5, 0x7b,
+	0xab, 0xa6, 0xec, 0xd6, 0x3d, 0xa7, 0xdd, 0xd6, 0xee, 0xaf, 0xc1, 0xb9, 0xed, 0xb6, 0xf6, 0x80,
+	0xa2, 0xb5, 0xb4, 0x15, 0xab, 0xed, 0x78, 0xb8, 0xd2, 0xf2, 0x82, 0x3c, 0x38, 0xca, 0xad, 0x69,
+	0x5f, 0x59, 0x34, 0x2f, 0x80, 0x57, 0x7b, 0x8e, 0xf6, 0x70, 0x01, 0x61, 0x55, 0xab, 0x5e, 0xcb,
+	0x69, 0xd5, 0xb5, 0x0f, 0x29, 0x75, 0x91, 0xaa, 0xb6, 0xdf, 0xed, 0x9a, 0x6d, 0xaf, 0x55, 0xd7,
+	0xbe, 0xba, 0x6a, 0x69, 0xe6, 0x4b, 0xb7, 0x59, 0xb7, 0xb5, 0xaf, 0x55, 0x3e, 0xc3, 0xea, 0x85,
+	0x7f, 0x47, 0x3c, 0x1a, 0xea, 0x97, 0xb9, 0xd3, 0x3c, 0x68, 0xd5, 0xbd, 0x6e, 0xaf, 0x6b, 0xf2,
+	0x90, 0xb5, 0x43, 0x00, 0xcb, 0x36, 0x1d, 0xb3, 0xeb, 0x6a, 0xef, 0xee, 0x57, 0xfe, 0x5d, 0x0a,
+	0x1b, 0x38, 0xa3, 0xf9, 0xe9, 0x13, 0xfa, 0xee, 0x55, 0xdc, 0x1b, 0x04, 0xea, 0x96, 0xd9, 0x5c,
+	0x8a, 0x49, 0x00, 0x03, 0x96, 0x2f, 0xc1, 0x77, 0x60, 0x7c, 0x03, 0x90, 0xe9, 0x58, 0x5a, 0x9a,
+	0x66, 0x85, 0x67, 0x63, 0xdf, 0x6d, 0x6a, 0x59, 0x05, 0x50, 0x87, 0x24, 0x30, 0xaf, 0x00, 0x20,
+	0x59, 0xd2, 0x34, 0x85, 0xab, 0xdd, 0xdb, 0x07, 0xff, 0x76, 0x5f, 0xe1, 0xda, 0xec, 0x59, 0xda,
+	0x53, 0x8a, 0x1c, 0xf0, 0xbc, 0xdf, 0xb5, 0x4d, 0x0b, 0xc2, 0x90, 0x0a, 0x72, 0xcc, 0xe7, 0x90,
+	0x30, 0xfc, 0x20, 0x9d, 0xf8, 0xf0, 0x90, 0xee, 0xf3, 0x02, 0x99, 0xc1, 0x73, 0x78, 0x6b, 0x1f,
+	0x3c, 0x21, 0x1e, 0x93, 0x01, 0x49, 0xae, 0xf5, 0xca, 0x73, 0xdd, 0x36, 0x4f, 0xef, 0x8b, 0x64,
+	0x2d, 0x2a, 0xbc, 0xd5, 0x95, 0xee, 0xc0, 0xc0, 0xd4, 0x14, 0x0f, 0xd5, 0x6d, 0x4b, 0xf3, 0x36,
+	0x5c, 0xaf, 0x6e, 0xd6, 0x62, 0xb8, 0x46, 0x89, 0x81, 0xe1, 0x7a, 0xd6, 0xbe, 0xd3, 0xe4, 0x1e,
+	0x4d, 0xbb, 0x42, 0xc2, 0x04, 0x60, 0xcf, 0x42, 0x98, 0xbe, 0x40, 0x08, 0x1c, 0xb4, 0xab, 0x49,
+	0x42, 0x0e, 0xbb, 0x16, 0x13, 0xc2, 0x0a, 0x78, 0xea, 0xa4, 0x5d, 0x27, 0x29, 0x1a, 0x54, 0x7a,
+	0x68, 0x37, 0x28, 0xb7, 0x22, 0xaa, 0xee, 0x0b, 0xbe, 0x9a, 0x9b, 0x31, 0x14, 0x56, 0x49, 0xd0,
+	0x52, 0x92, 0x63, 0xa3, 0x65, 0xb6, 0xeb, 0xda, 0x2d, 0x65, 0x6a, 0x58, 0x8f, 0x55, 0xad, 0x6a,
+	0xb7, 0xe9, 0x68, 0x68, 0x39, 0x00, 0xda, 0xd5, 0x4b, 0x62, 0xdf, 0x4b, 0x21, 0xe9, 0x00, 0x6f,
+	0x16, 0x28, 0x0d, 0x26, 0xfa, 0xa0, 0x54, 0x64, 0xc7, 0x9d, 0x76, 0xa2, 0x94, 0x66, 0x04, 0x83,
+	0xe4, 0xf5, 0xbf, 0xbe, 0xcf, 0x50, 0x48, 0x07, 0x48, 0xb7, 0xe7, 0x55, 0xf7, 0x1b, 0x0d, 0xe2,
+	0xfb, 0x9f, 0x84, 0x8a, 0x2a, 0x1f, 0x8d, 0xf1, 0xb3, 0x25, 0xc5, 0x51, 0x33, 0x62, 0xdc, 0x6f,
+	0xcb, 0xf5, 0xf6, 0x7a, 0x6e, 0x8f, 0xca, 0xef, 0x14, 0xd9, 0x53, 0xcb, 0xf5, 0x5e, 0xd8, 0x2d,
+	0xd7, 0x54, 0x23, 0x1c, 0x9a, 0xa0, 0xc4, 0x18, 0x35, 0xb7, 0xd5, 0xeb, 0x3a, 0x5a, 0x26, 0x46,
+	0x18, 0x96, 0xd5, 0x7e, 0x25, 0x11, 0xd9, 0x18, 0x51, 0x6b, 0x9b, 0x86, 0x2d, 0x11, 0x1b, 0x42,
+	0xaf, 0xa9, 0x5e, 0xd1, 0x36, 0x49, 0x52, 0xad, 0x15, 0x92, 0xfa, 0x8b, 0xb8, 0xa1, 0xc5, 0x8f,
+	0xc5, 0x28, 0xa1, 0x68, 0xd4, 0x12, 0x99, 0x4a, 0xa3, 0x26, 0xf2, 0x12, 0x11, 0xa9, 0x25, 0xc4,
+	0x73, 0x5c, 0xbb, 0x55, 0x83, 0xf2, 0x5c, 0x92, 0x52, 0x52, 0x93, 0x89, 0x49, 0x11, 0x22, 0x48,
+	0xb3, 0x95, 0x7f, 0x48, 0x6f, 0x8e, 0xe4, 0xec, 0x68, 0xef, 0x28, 0xcc, 0x86, 0x9a, 0x82, 0x12,
+	0x8b, 0x86, 0xe7, 0x98, 0xdd, 0xba, 0x2c, 0x9c, 0xe3, 0x65, 0x34, 0xbc, 0x5a, 0xd3, 0xac, 0x3d,
+	0xf3, 0x7a, 0x07, 0xa6, 0xdd, 0x36, 0x2c, 0x99, 0x30, 0x34, 0x1a, 0x1e, 0x38, 0x18, 0xb0, 0xa4,
+	0xfd, 0xae, 0x1b, 0x0b, 0xad, 0xd1, 0xe0, 0xa9, 0xf6, 0x33, 0x89, 0xc8, 0x27, 0x10, 0xd5, 0x57,
+	0x12, 0xa1, 0x55, 0x1c, 0x2c, 0x7d, 0xf0, 0xb3, 0x5e, 0xdc, 0xdd, 0xde, 0x52, 0x23, 0x66, 0x4f,
+	0x69, 0xc4, 0x08, 0x48, 0xdc, 0x35, 0x91, 0x10, 0xd9, 0x08, 0xf9, 0x2e, 0xbe, 0x9d, 0x59, 0xfa,
+	0xfc, 0x8a, 0x04, 0xbf, 0x97, 0x14, 0xfc, 0x9e, 0x22, 0x78, 0x09, 0x21, 0xf9, 0xa6, 0x2b, 0x8e,
+	0xfa, 0x2e, 0x9e, 0xab, 0x23, 0x31, 0xc1, 0xea, 0x4b, 0x32, 0x01, 0x23, 0x6b, 0x9b, 0x35, 0xf0,
+	0x95, 0x68, 0x06, 0x7b, 0xa0, 0xaf, 0xf5, 0x96, 0x6d, 0xf2, 0x83, 0xdb, 0xc2, 0x45, 0xba, 0x5e,
+	0xa3, 0xa1, 0x65, 0x2a, 0x16, 0x2a, 0xc6, 0xe2, 0x47, 0x4a, 0x74, 0x38, 0x36, 0x48, 0xa9, 0x63,
+	0xb8, 0xb5, 0xa6, 0x76, 0x89, 0xd4, 0x4d, 0x28, 0xa0, 0x2c, 0xd8, 0x6c, 0x21, 0x24, 0x6e, 0xea,
+	0xe9, 0xca, 0xdf, 0x48, 0x61, 0x67, 0x7d, 0xc5, 0xe7, 0x3f, 0x74, 0x5a, 0xb6, 0xed, 0xb5, 0xea,
+	0x6d, 0xd3, 0x73, 0x5b, 0x1d, 0xb3, 0xa7, 0x78, 0x48, 0xdb, 0xf6, 0x9a, 0x86, 0x5d, 0x97, 0x70,
+	0x21, 0x04, 0x5b, 0x66, 0xce, 0xe9, 0x98, 0x12, 0x4b, 0x3f, 0xa9, 0x7c, 0x12, 0x8e, 0xb5, 0x3b,
+	0xc1, 0xb3, 0x95, 0x29, 0xfd, 0x8f, 0x27, 0xfe, 0x3a, 0x92, 0xd2, 0x67, 0xef, 0x97, 0x4c, 0xbb,
+	0x27, 0x8f, 0xb4, 0x83, 0x47, 0xfa, 0xee, 0x07, 0xef, 0x73, 0xfa, 0x75, 0xbe, 0xeb, 0x8e, 0xe7,
+	0xb4, 0x7b, 0x2f, 0x2c, 0xc3, 0x6d, 0x52, 0xd3, 0x0b, 0xbb, 0x61, 0x1d, 0xb5, 0x1b, 0xa6, 0x76,
+	0xbe, 0x3a, 0x58, 0xfd, 0xf2, 0x03, 0x9f, 0x2c, 0x7d, 0x2a, 0xa3, 0x26, 0xf3, 0x55, 0xd5, 0x73,
+	0xa0, 0x3c, 0x01, 0x46, 0x75, 0x3e, 0xee, 0x81, 0x03, 0x9c, 0x1a, 0xd4, 0xb0, 0x1d, 0xc3, 0x7e,
+	0xa6, 0x89, 0xa4, 0x1c, 0xe0, 0x4b, 0x76, 0xfd, 0x5d, 0xf5, 0x6b, 0xa1, 0x65, 0xfd, 0xea, 0x24,
+	0xf5, 0xab, 0xb3, 0xa4, 0x5f, 0x1d, 0x45, 0xbf, 0x8e, 0xd4, 0x57, 0xf0, 0xaa, 0x89, 0x76, 0x1a,
+	0x89, 0x0e, 0x00, 0x43, 0xd0, 0xb3, 0xaa, 0x05, 0x55, 0x3b, 0xed, 0xa2, 0x01, 0x56, 0x66, 0x39,
+	0x32, 0x1e, 0x77, 0x1a, 0x5e, 0x75, 0xdf, 0x76, 0x5c, 0x19, 0x8f, 0x3b, 0x0d, 0x51, 0xa7, 0x57,
+	0x7e, 0x9f, 0x6e, 0x77, 0xe1, 0x07, 0x18, 0x5c, 0x3e, 0xb8, 0x75, 0x93, 0x9a, 0x84, 0x5e, 0xc3,
+	0x68, 0xb5, 0x4d, 0x98, 0x0d, 0x43, 0xa4, 0xe9, 0x7a, 0x55, 0xa3, 0x2e, 0xdb, 0x3a, 0x42, 0xf3,
+	0x08, 0x4c, 0xfa, 0x98, 0xa6, 0x4c, 0x89, 0xa0, 0xad, 0xae, 0xe3, 0xda, 0xfb, 0x88, 0xca, 0x50,
+	0xfc, 0x21, 0x14, 0x2a, 0x74, 0x36, 0xa6, 0x17, 0xfd, 0x35, 0x31, 0xef, 0x06, 0x65, 0x3d, 0xa6,
+	0xd2, 0x67, 0x13, 0xb8, 0xcd, 0x78, 0x98, 0xe8, 0xb7, 0x09, 0x54, 0x2e, 0x1e, 0x26, 0xfb, 0x6e,
+	0x02, 0x97, 0x8f, 0x87, 0x61, 0x2f, 0xa2, 0x67, 0x09, 0x54, 0x41, 0xff, 0x80, 0xdd, 0x46, 0x94,
+	0xf3, 0xa2, 0xe5, 0xd6, 0x9a, 0xa2, 0x19, 0x46, 0x78, 0x46, 0x99, 0xa5, 0x99, 0x6c, 0x87, 0x09,
+	0x74, 0x31, 0x9e, 0x55, 0xf6, 0xad, 0x04, 0x6e, 0x8b, 0x3a, 0x6d, 0x72, 0x45, 0xb2, 0x0b, 0x4a,
+	0x04, 0xdb, 0x14, 0x33, 0xcc, 0x15, 0xba, 0x55, 0x55, 0xff, 0x83, 0xe3, 0xeb, 0xfe, 0x68, 0xcc,
+	0x6f, 0xf9, 0xf1, 0x7f, 0x80, 0x04, 0xfa, 0xd8, 0x6c, 0xd4, 0xbc, 0x56, 0xb7, 0xd6, 0xeb, 0x58,
+	0x86, 0xdb, 0x82, 0xa8, 0x27, 0xb4, 0x0c, 0x10, 0xa6, 0x65, 0xda, 0x50, 0xa1, 0xfe, 0x49, 0x1a,
+	0xfd, 0xcb, 0x61, 0x7f, 0x28, 0xde, 0x17, 0x21, 0x0f, 0x3c, 0xf0, 0xaa, 0x5d, 0xe3, 0x27, 0x42,
+	0xfd, 0x32, 0xd9, 0xe5, 0x10, 0x70, 0x9e, 0x75, 0x8b, 0x68, 0x2a, 0x80, 0xb2, 0x47, 0xa9, 0xa5,
+	0xa9, 0x89, 0x2b, 0x30, 0x89, 0x2d, 0x88, 0x80, 0xa4, 0x20, 0x91, 0x9f, 0xe8, 0xcc, 0x00, 0x02,
+	0xd7, 0xb9, 0x41, 0xf6, 0x29, 0x48, 0xdb, 0x66, 0x57, 0x56, 0x8a, 0x1c, 0xc6, 0x53, 0x03, 0xcf,
+	0xec, 0x58, 0xee, 0x2b, 0xd9, 0x1c, 0x56, 0x10, 0xfb, 0xdd, 0x67, 0xdd, 0xde, 0x8b, 0xae, 0x8c,
+	0x2e, 0x72, 0xf9, 0x5c, 0xe6, 0x2d, 0x38, 0xe2, 0x78, 0x5f, 0x2d, 0xc7, 0x73, 0xda, 0xc6, 0x81,
+	0xa9, 0xb1, 0x85, 0xcd, 0xf2, 0xda, 0x58, 0x64, 0x85, 0x12, 0xc8, 0xdb, 0x44, 0xda, 0x96, 0xfe,
+	0x90, 0xdd, 0x27, 0x70, 0xdc, 0xa3, 0xa5, 0xe9, 0x21, 0x1a, 0x82, 0x0a, 0x6b, 0xdb, 0x95, 0xdf,
+	0xcd, 0xa0, 0xff, 0x01, 0x79, 0x53, 0x52, 0xca, 0xc5, 0x4d, 0x33, 0x19, 0x8a, 0x58, 0x45, 0xaf,
+	0x51, 0x00, 0x61, 0xd3, 0x29, 0x21, 0x50, 0x63, 0x85, 0x40, 0x45, 0xee, 0xa2, 0x20, 0x91, 0x53,
+	0x66, 0x01, 0xd1, 0xdb, 0x47, 0xdb, 0x90, 0x61, 0x58, 0x20, 0x0c, 0x7b, 0x6f, 0x1f, 0x98, 0x69,
+	0x1b, 0xe2, 0x08, 0x0c, 0x71, 0x04, 0x9b, 0xca, 0x12, 0xdd, 0x1e, 0x04, 0x9d, 0x2e, 0x88, 0x1a,
+	0x0d, 0x5d, 0x8c, 0xc7, 0x54, 0x34, 0x2f, 0xf4, 0x41, 0x99, 0x0e, 0x73, 0xd2, 0x02, 0x59, 0x0a,
+	0x60, 0xb8, 0x91, 0x73, 0x05, 0xed, 0x3a, 0x2d, 0xc7, 0x85, 0x59, 0x99, 0x7e, 0x87, 0x95, 0x08,
+	0xbd, 0xdf, 0x75, 0xf6, 0x2d, 0x58, 0xa4, 0x59, 0xf7, 0x7a, 0x76, 0xdd, 0xb4, 0xb5, 0xe2, 0x82,
+	0x3c, 0x5c, 0x63, 0x4f, 0xdb, 0x5a, 0xd8, 0x00, 0xa4, 0x18, 0x7c, 0xcb, 0xa2, 0x38, 0x57, 0x11,
+	0x20, 0xc0, 0x9d, 0x05, 0x01, 0xf2, 0xee, 0xb2, 0xd8, 0xf5, 0xe5, 0xca, 0x9f, 0xa6, 0x58, 0x49,
+	0x1c, 0x8f, 0x9a, 0x5c, 0x2a, 0x66, 0x55, 0x6d, 0xd5, 0x84, 0x3e, 0x71, 0x1f, 0x26, 0x9d, 0x20,
+	0x22, 0x9c, 0x7d, 0x0b, 0xc1, 0x29, 0x85, 0x3e, 0xa1, 0x6b, 0xc2, 0x0f, 0xc6, 0xf4, 0x32, 0xfb,
+	0xcc, 0x90, 0xa7, 0x59, 0x46, 0x61, 0xff, 0x37, 0x2b, 0x56, 0xdf, 0x5a, 0x71, 0xfc, 0x1b, 0x0b,
+	0x13, 0xca, 0xe3, 0xdf, 0x14, 0x82, 0x6b, 0xc5, 0x8a, 0x94, 0x13, 0x07, 0xdc, 0x12, 0x07, 0x9c,
+	0xaf, 0xfc, 0x23, 0xba, 0xb7, 0x0d, 0x9b, 0xc7, 0x3e, 0x97, 0xaa, 0x9a, 0x9d, 0x55, 0xaa, 0xd9,
+	0x51, 0x55, 0x33, 0x09, 0x83, 0xe3, 0x91, 0xf6, 0x4f, 0xb0, 0x7a, 0x1b, 0xc2, 0x9d, 0x4d, 0xcd,
+	0xec, 0x05, 0x64, 0xf7, 0x85, 0x82, 0xcc, 0x0a, 0x1d, 0x22, 0xe4, 0x8b, 0x56, 0xbb, 0x5e, 0x33,
+	0xec, 0x3a, 0xa4, 0xd5, 0xa4, 0x73, 0x84, 0xc1, 0x62, 0x65, 0x73, 0x01, 0x7a, 0x60, 0xb4, 0xf7,
+	0x4d, 0x2d, 0xb7, 0xb0, 0x78, 0xce, 0x5a, 0x74, 0x8c, 0x04, 0xd0, 0xb2, 0x4d, 0xdb, 0x7c, 0xae,
+	0x15, 0x14, 0x0e, 0xf5, 0x7d, 0x8b, 0xf8, 0x32, 0x21, 0xa7, 0x8e, 0x90, 0x53, 0xb1, 0xf2, 0x07,
+	0xa4, 0x24, 0x71, 0xba, 0xac, 0xf8, 0x5e, 0x9c, 0xb0, 0xd1, 0x69, 0x48, 0x2d, 0x91, 0xe9, 0x13,
+	0x07, 0x92, 0x9b, 0xdf, 0x6f, 0xb7, 0xa5, 0xdf, 0xe4, 0xf0, 0x05, 0x15, 0x51, 0xd8, 0x88, 0x5c,
+	0x3a, 0x23, 0x12, 0xf2, 0x8e, 0xf4, 0xdf, 0x32, 0x8d, 0x96, 0x1c, 0x28, 0x33, 0xdb, 0x58, 0x44,
+	0xd4, 0x7a, 0x9d, 0x8e, 0xd1, 0x05, 0x39, 0xe1, 0xe6, 0x25, 0xa2, 0xd1, 0x36, 0xf6, 0x1c, 0x2d,
+	0x57, 0xf9, 0xbd, 0x0c, 0x7e, 0xf8, 0x13, 0x67, 0xc2, 0xea, 0xae, 0x70, 0xa1, 0x7b, 0x30, 0x08,
+	0x03, 0xae, 0xf9, 0xb2, 0xe5, 0xb8, 0x8e, 0x7c, 0x57, 0xc1, 0x31, 0x22, 0xcd, 0x44, 0x5b, 0x4f,
+	0x91, 0x2e, 0x73, 0xd4, 0x0b, 0xb3, 0xb5, 0xd7, 0x74, 0x55, 0xa3, 0x96, 0x66, 0xc0, 0xf1, 0xe0,
+	0x22, 0x7a, 0x0d, 0x1c, 0x09, 0xb5, 0x16, 0x46, 0x4c, 0x15, 0x55, 0xdd, 0x07, 0x3f, 0x0b, 0x95,
+	0xc3, 0x7d, 0x76, 0x47, 0xe0, 0x6a, 0x4d, 0xa3, 0xd5, 0x6d, 0x75, 0xf7, 0x12, 0x8c, 0x37, 0xc8,
+	0xc9, 0xe0, 0xc4, 0xdc, 0xcb, 0xa8, 0xe8, 0x4d, 0x91, 0x86, 0x03, 0xba, 0xdd, 0xeb, 0x59, 0x32,
+	0x60, 0xec, 0x29, 0x87, 0x46, 0x9b, 0xc8, 0xab, 0x28, 0x3e, 0x9b, 0x59, 0x97, 0xbe, 0x0c, 0xf5,
+	0x65, 0x4f, 0xca, 0x1e, 0x2c, 0x43, 0xb4, 0x17, 0xf7, 0x16, 0x05, 0x5f, 0x24, 0x25, 0x90, 0x08,
+	0xdc, 0x90, 0xb6, 0x45, 0x07, 0x22, 0xe1, 0x7c, 0xc5, 0xf2, 0xdd, 0xe2, 0x5e, 0x7c, 0xd8, 0x3b,
+	0x95, 0xdf, 0x26, 0xc5, 0x13, 0xff, 0x9c, 0x35, 0x71, 0x44, 0xb8, 0x1a, 0x4b, 0xb0, 0xa1, 0x26,
+	0x2f, 0xae, 0x46, 0x42, 0x9b, 0x68, 0x63, 0x32, 0x97, 0xb5, 0xe2, 0x65, 0xf2, 0x17, 0xa5, 0xe2,
+	0x50, 0x24, 0xdc, 0xa8, 0x1f, 0x98, 0xb6, 0xdb, 0x72, 0x4c, 0xa9, 0x7e, 0x96, 0xa2, 0x7e, 0x95,
+	0x5f, 0x46, 0xa5, 0x91, 0xff, 0xc1, 0x38, 0xb1, 0x22, 0x7a, 0x47, 0x98, 0xd0, 0x6e, 0x69, 0x0c,
+	0xee, 0xc2, 0xcc, 0xe2, 0x5d, 0x86, 0x1b, 0xb3, 0x4f, 0x57, 0x7e, 0x09, 0xf7, 0x8b, 0x77, 0x71,
+	0x66, 0xf3, 0x15, 0xfb, 0x7d, 0xde, 0x4b, 0xee, 0x17, 0xe7, 0x94, 0x50, 0x0c, 0x48, 0x82, 0x37,
+	0x07, 0x0b, 0xde, 0x7f, 0x81, 0xdd, 0x5d, 0xfa, 0x5f, 0xce, 0x2b, 0x96, 0xef, 0xd4, 0x12, 0x86,
+	0x22, 0x12, 0x20, 0x09, 0x46, 0xd7, 0x87, 0xfc, 0x39, 0x30, 0x5e, 0xfb, 0x9d, 0xc5, 0x9b, 0x38,
+	0x09, 0xf6, 0x54, 0xc0, 0xd9, 0x8d, 0x1a, 0xe4, 0xdd, 0x5c, 0x32, 0x0a, 0x88, 0x6b, 0x6c, 0x5c,
+	0xc2, 0xd9, 0x34, 0x1b, 0xe4, 0x97, 0x5a, 0xba, 0xf2, 0xaf, 0xd3, 0x28, 0xf7, 0xb8, 0xac, 0x58,
+	0x76, 0x41, 0x9d, 0xa4, 0x0b, 0x42, 0x0b, 0xe6, 0x40, 0xcc, 0x42, 0xc9, 0x82, 0x53, 0x74, 0xe2,
+	0x1d, 0xd5, 0x82, 0xb1, 0x5f, 0x91, 0x56, 0x51, 0xc2, 0x2e, 0x10, 0x25, 0x32, 0x8a, 0xce, 0xa2,
+	0x9a, 0x67, 0x49, 0x6c, 0x9d, 0xa4, 0x7f, 0x11, 0x4e, 0x5b, 0x82, 0x6d, 0xc3, 0x35, 0xa5, 0x33,
+	0xea, 0xc4, 0x36, 0x61, 0xf3, 0xb7, 0xfb, 0x0b, 0xc4, 0x55, 0xe0, 0x9c, 0x27, 0xa7, 0x90, 0x80,
+	0x92, 0x9f, 0x2f, 0xa8, 0x2b, 0x25, 0x87, 0xc1, 0x17, 0xea, 0x68, 0x4c, 0xdd, 0xb9, 0xf0, 0x25,
+	0x46, 0xb7, 0xee, 0x68, 0xc5, 0xca, 0x3f, 0x4e, 0xad, 0xf8, 0x92, 0x2b, 0x5c, 0xa5, 0xc3, 0x8d,
+	0x05, 0x1d, 0xa6, 0xd7, 0xd6, 0x02, 0x2c, 0x03, 0xb8, 0x38, 0xb0, 0x78, 0x00, 0x38, 0x05, 0x79,
+	0x57, 0xa2, 0xa1, 0x28, 0x4d, 0x66, 0x91, 0x89, 0x4c, 0x43, 0xb2, 0xc2, 0x14, 0x1a, 0x52, 0x9d,
+	0x36, 0x2a, 0xff, 0x91, 0x82, 0x73, 0xf2, 0x3b, 0x6f, 0x51, 0xed, 0x41, 0xa1, 0xed, 0xd4, 0xe2,
+	0xea, 0x8f, 0x5f, 0x1f, 0x79, 0x21, 0x5f, 0x4d, 0x77, 0x2c, 0xcf, 0xd8, 0xdb, 0xb3, 0xcd, 0x3d,
+	0x83, 0xd7, 0xe8, 0x54, 0xf0, 0x89, 0xcb, 0x28, 0x19, 0x21, 0x6f, 0x2b, 0xf9, 0x12, 0x57, 0x92,
+	0xa1, 0x15, 0x6d, 0xc4, 0x00, 0xf4, 0x80, 0x9b, 0xf1, 0x38, 0x51, 0xec, 0x3b, 0x35, 0x2d, 0x27,
+	0x04, 0x2e, 0xa0, 0xa2, 0xa4, 0x91, 0x8d, 0xde, 0x8e, 0x45, 0x5a, 0x54, 0x10, 0x15, 0x35, 0x01,
+	0x84, 0x2f, 0x60, 0x31, 0x0b, 0x84, 0x4b, 0x16, 0xc5, 0x18, 0x93, 0xac, 0x97, 0xe4, 0x0d, 0x0d,
+	0xb1, 0x09, 0xbe, 0x16, 0x51, 0x3d, 0x75, 0xac, 0x55, 0x95, 0xf9, 0xee, 0xca, 0xef, 0xfb, 0x3d,
+	0xf1, 0xad, 0x32, 0x0e, 0x6c, 0x40, 0x39, 0xb7, 0xf4, 0x96, 0x57, 0xc0, 0x3b, 0x3d, 0xdb, 0xd4,
+	0x52, 0x95, 0x36, 0x99, 0x63, 0xf2, 0x9b, 0x7d, 0xe2, 0x24, 0x56, 0xdc, 0xc0, 0xab, 0x0d, 0x0a,
+	0x2f, 0xd2, 0x7e, 0x89, 0x21, 0x6e, 0x7f, 0x9c, 0xc1, 0xa5, 0xad, 0xf9, 0x9a, 0x55, 0xea, 0x8d,
+	0xe5, 0xaa, 0x45, 0x34, 0xf8, 0x26, 0x0c, 0x7c, 0x4b, 0x18, 0xaf, 0xd3, 0x72, 0x1c, 0x99, 0x90,
+	0x72, 0x74, 0xd7, 0x7c, 0x49, 0x25, 0xa7, 0xa3, 0xa5, 0x29, 0xed, 0x5e, 0x44, 0xe0, 0xb0, 0x8c,
+	0xb8, 0x8e, 0x00, 0xd8, 0x64, 0x4f, 0x34, 0x4b, 0x21, 0x7e, 0x19, 0x85, 0x43, 0x37, 0xd4, 0xa1,
+	0xc9, 0xae, 0xe9, 0xa6, 0x3a, 0x34, 0x81, 0xc2, 0xa1, 0x39, 0x69, 0x03, 0x96, 0x4b, 0xfd, 0x80,
+	0xbc, 0x34, 0x46, 0x98, 0x4d, 0xe6, 0x83, 0x4c, 0xdc, 0x2f, 0x89, 0x17, 0xe1, 0x98, 0x2e, 0x66,
+	0x6f, 0xa2, 0xbc, 0x5e, 0x81, 0xc3, 0x69, 0xb6, 0xd5, 0xc1, 0xb8, 0x0c, 0x39, 0x78, 0x47, 0x1d,
+	0x9c, 0xc4, 0xe1, 0xe0, 0xcb, 0xfa, 0xed, 0xf8, 0x24, 0x12, 0xfa, 0xf5, 0xc3, 0xf7, 0x19, 0xfd,
+	0x5e, 0x7c, 0x16, 0x2a, 0x0e, 0x87, 0x82, 0x02, 0xfe, 0x0e, 0xfd, 0x83, 0x03, 0xcc, 0xb8, 0x12,
+	0x17, 0x32, 0xa8, 0x2d, 0xd8, 0xa8, 0x2d, 0x5d, 0x5e, 0x01, 0x18, 0x76, 0x0f, 0x29, 0xa7, 0xd2,
+	0x52, 0x22, 0x59, 0x8a, 0x31, 0xed, 0xd6, 0x81, 0xd9, 0x35, 0x9d, 0xf8, 0x76, 0xc6, 0x9e, 0x92,
+	0x2b, 0x69, 0x59, 0x65, 0x80, 0x4c, 0xa0, 0x78, 0xdb, 0xd6, 0xd1, 0xf2, 0x95, 0xcf, 0xb1, 0x1f,
+	0x10, 0xdf, 0x3f, 0xc6, 0x2b, 0xc7, 0x22, 0x82, 0xaa, 0xfd, 0x31, 0x5c, 0xe5, 0x73, 0xd7, 0xeb,
+	0xb4, 0xba, 0xe8, 0xd0, 0x53, 0x0a, 0xcc, 0x78, 0x89, 0xb0, 0x34, 0xd9, 0xe0, 0xf3, 0x15, 0x1d,
+	0x8c, 0xef, 0x61, 0x31, 0xbc, 0x70, 0x01, 0x95, 0xf4, 0xb4, 0x66, 0x63, 0x3b, 0xa5, 0xdb, 0xab,
+	0x35, 0x8d, 0xee, 0x9e, 0x29, 0x7b, 0xf9, 0x02, 0x61, 0x3e, 0xdf, 0x37, 0xda, 0xf2, 0x7e, 0x9a,
+	0x80, 0x76, 0x0c, 0x07, 0x83, 0x57, 0x92, 0x18, 0x4b, 0xfa, 0x8c, 0x95, 0x3a, 0xdc, 0xe4, 0xff,
+	0x5c, 0xfb, 0xb3, 0xff, 0x13, 0x00, 0x00, 0xff, 0xff, 0xcb, 0xda, 0xf6, 0x7f, 0xb9, 0x63, 0x00,
+	0x00,
+}
diff --git a/netopeer/voltha-grpc-client/voltha/ponsim/ponsim.pb.go b/netopeer/voltha-grpc-client/voltha/ponsim/ponsim.pb.go
new file mode 100644
index 0000000..6831013
--- /dev/null
+++ b/netopeer/voltha-grpc-client/voltha/ponsim/ponsim.pb.go
@@ -0,0 +1,337 @@
+// Code generated by protoc-gen-go.
+// source: ponsim.proto
+// DO NOT EDIT!
+
+/*
+Package voltha is a generated protocol buffer package.
+
+It is generated from these files:
+	ponsim.proto
+
+It has these top-level messages:
+	PonSimDeviceInfo
+	FlowTable
+	PonSimPacketCounter
+	PonSimPortMetrics
+	PonSimMetrics
+*/
+package ponsim
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+import google_protobuf "github.com/golang/protobuf/ptypes/empty"
+import openflow_13 "github.com/opencord/voltha/netconf/translator/voltha/openflow_13"
+
+import (
+	context "golang.org/x/net/context"
+	grpc "google.golang.org/grpc"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+type PonSimDeviceInfo struct {
+	NniPort  int32   `protobuf:"varint,1,opt,name=nni_port,json=nniPort" json:"nni_port,omitempty"`
+	UniPorts []int32 `protobuf:"varint,2,rep,packed,name=uni_ports,json=uniPorts" json:"uni_ports,omitempty"`
+}
+
+func (m *PonSimDeviceInfo) Reset()                    { *m = PonSimDeviceInfo{} }
+func (m *PonSimDeviceInfo) String() string            { return proto.CompactTextString(m) }
+func (*PonSimDeviceInfo) ProtoMessage()               {}
+func (*PonSimDeviceInfo) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
+
+func (m *PonSimDeviceInfo) GetNniPort() int32 {
+	if m != nil {
+		return m.NniPort
+	}
+	return 0
+}
+
+func (m *PonSimDeviceInfo) GetUniPorts() []int32 {
+	if m != nil {
+		return m.UniPorts
+	}
+	return nil
+}
+
+type FlowTable struct {
+	Port  int32                       `protobuf:"varint,1,opt,name=port" json:"port,omitempty"`
+	Flows []*openflow_13.OfpFlowStats `protobuf:"bytes,2,rep,name=flows" json:"flows,omitempty"`
+}
+
+func (m *FlowTable) Reset()                    { *m = FlowTable{} }
+func (m *FlowTable) String() string            { return proto.CompactTextString(m) }
+func (*FlowTable) ProtoMessage()               {}
+func (*FlowTable) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
+
+func (m *FlowTable) GetPort() int32 {
+	if m != nil {
+		return m.Port
+	}
+	return 0
+}
+
+func (m *FlowTable) GetFlows() []*openflow_13.OfpFlowStats {
+	if m != nil {
+		return m.Flows
+	}
+	return nil
+}
+
+type PonSimPacketCounter struct {
+	Name  string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
+	Value int64  `protobuf:"varint,2,opt,name=value" json:"value,omitempty"`
+}
+
+func (m *PonSimPacketCounter) Reset()                    { *m = PonSimPacketCounter{} }
+func (m *PonSimPacketCounter) String() string            { return proto.CompactTextString(m) }
+func (*PonSimPacketCounter) ProtoMessage()               {}
+func (*PonSimPacketCounter) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }
+
+func (m *PonSimPacketCounter) GetName() string {
+	if m != nil {
+		return m.Name
+	}
+	return ""
+}
+
+func (m *PonSimPacketCounter) GetValue() int64 {
+	if m != nil {
+		return m.Value
+	}
+	return 0
+}
+
+type PonSimPortMetrics struct {
+	PortName string                 `protobuf:"bytes,1,opt,name=port_name,json=portName" json:"port_name,omitempty"`
+	Packets  []*PonSimPacketCounter `protobuf:"bytes,2,rep,name=packets" json:"packets,omitempty"`
+}
+
+func (m *PonSimPortMetrics) Reset()                    { *m = PonSimPortMetrics{} }
+func (m *PonSimPortMetrics) String() string            { return proto.CompactTextString(m) }
+func (*PonSimPortMetrics) ProtoMessage()               {}
+func (*PonSimPortMetrics) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} }
+
+func (m *PonSimPortMetrics) GetPortName() string {
+	if m != nil {
+		return m.PortName
+	}
+	return ""
+}
+
+func (m *PonSimPortMetrics) GetPackets() []*PonSimPacketCounter {
+	if m != nil {
+		return m.Packets
+	}
+	return nil
+}
+
+type PonSimMetrics struct {
+	Device  string               `protobuf:"bytes,1,opt,name=device" json:"device,omitempty"`
+	Metrics []*PonSimPortMetrics `protobuf:"bytes,2,rep,name=metrics" json:"metrics,omitempty"`
+}
+
+func (m *PonSimMetrics) Reset()                    { *m = PonSimMetrics{} }
+func (m *PonSimMetrics) String() string            { return proto.CompactTextString(m) }
+func (*PonSimMetrics) ProtoMessage()               {}
+func (*PonSimMetrics) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} }
+
+func (m *PonSimMetrics) GetDevice() string {
+	if m != nil {
+		return m.Device
+	}
+	return ""
+}
+
+func (m *PonSimMetrics) GetMetrics() []*PonSimPortMetrics {
+	if m != nil {
+		return m.Metrics
+	}
+	return nil
+}
+
+func init() {
+	proto.RegisterType((*PonSimDeviceInfo)(nil), "voltha.PonSimDeviceInfo")
+	proto.RegisterType((*FlowTable)(nil), "voltha.FlowTable")
+	proto.RegisterType((*PonSimPacketCounter)(nil), "voltha.PonSimPacketCounter")
+	proto.RegisterType((*PonSimPortMetrics)(nil), "voltha.PonSimPortMetrics")
+	proto.RegisterType((*PonSimMetrics)(nil), "voltha.PonSimMetrics")
+}
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ context.Context
+var _ grpc.ClientConn
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+const _ = grpc.SupportPackageIsVersion4
+
+// Client API for PonSim service
+
+type PonSimClient interface {
+	GetDeviceInfo(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*PonSimDeviceInfo, error)
+	UpdateFlowTable(ctx context.Context, in *FlowTable, opts ...grpc.CallOption) (*google_protobuf.Empty, error)
+	GetStats(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*PonSimMetrics, error)
+}
+
+type ponSimClient struct {
+	cc *grpc.ClientConn
+}
+
+func NewPonSimClient(cc *grpc.ClientConn) PonSimClient {
+	return &ponSimClient{cc}
+}
+
+func (c *ponSimClient) GetDeviceInfo(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*PonSimDeviceInfo, error) {
+	out := new(PonSimDeviceInfo)
+	err := grpc.Invoke(ctx, "/voltha.PonSim/GetDeviceInfo", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *ponSimClient) UpdateFlowTable(ctx context.Context, in *FlowTable, opts ...grpc.CallOption) (*google_protobuf.Empty, error) {
+	out := new(google_protobuf.Empty)
+	err := grpc.Invoke(ctx, "/voltha.PonSim/UpdateFlowTable", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *ponSimClient) GetStats(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*PonSimMetrics, error) {
+	out := new(PonSimMetrics)
+	err := grpc.Invoke(ctx, "/voltha.PonSim/GetStats", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// Server API for PonSim service
+
+type PonSimServer interface {
+	GetDeviceInfo(context.Context, *google_protobuf.Empty) (*PonSimDeviceInfo, error)
+	UpdateFlowTable(context.Context, *FlowTable) (*google_protobuf.Empty, error)
+	GetStats(context.Context, *google_protobuf.Empty) (*PonSimMetrics, error)
+}
+
+func RegisterPonSimServer(s *grpc.Server, srv PonSimServer) {
+	s.RegisterService(&_PonSim_serviceDesc, srv)
+}
+
+func _PonSim_GetDeviceInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(google_protobuf.Empty)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(PonSimServer).GetDeviceInfo(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/voltha.PonSim/GetDeviceInfo",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(PonSimServer).GetDeviceInfo(ctx, req.(*google_protobuf.Empty))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _PonSim_UpdateFlowTable_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(FlowTable)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(PonSimServer).UpdateFlowTable(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/voltha.PonSim/UpdateFlowTable",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(PonSimServer).UpdateFlowTable(ctx, req.(*FlowTable))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _PonSim_GetStats_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(google_protobuf.Empty)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(PonSimServer).GetStats(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/voltha.PonSim/GetStats",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(PonSimServer).GetStats(ctx, req.(*google_protobuf.Empty))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+var _PonSim_serviceDesc = grpc.ServiceDesc{
+	ServiceName: "voltha.PonSim",
+	HandlerType: (*PonSimServer)(nil),
+	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "GetDeviceInfo",
+			Handler:    _PonSim_GetDeviceInfo_Handler,
+		},
+		{
+			MethodName: "UpdateFlowTable",
+			Handler:    _PonSim_UpdateFlowTable_Handler,
+		},
+		{
+			MethodName: "GetStats",
+			Handler:    _PonSim_GetStats_Handler,
+		},
+	},
+	Streams:  []grpc.StreamDesc{},
+	Metadata: "ponsim.proto",
+}
+
+func init() { proto.RegisterFile("ponsim.proto", fileDescriptor0) }
+
+var fileDescriptor0 = []byte{
+	// 391 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x91, 0x41, 0x8f, 0xd3, 0x30,
+	0x10, 0x85, 0x9b, 0x5d, 0x92, 0xa6, 0x03, 0x2b, 0xa8, 0x81, 0x55, 0x36, 0xbd, 0x54, 0x3e, 0xf5,
+	0x94, 0xd5, 0xb6, 0xe2, 0x84, 0x04, 0x87, 0x02, 0x15, 0x48, 0xa0, 0xca, 0x85, 0x1b, 0x52, 0x94,
+	0xb6, 0x4e, 0x89, 0x48, 0x3c, 0x56, 0xe2, 0xb4, 0xe2, 0x2f, 0xf2, 0xab, 0x90, 0xed, 0x84, 0xa4,
+	0x88, 0xde, 0xc6, 0x33, 0xcf, 0xdf, 0x3c, 0xfb, 0xc1, 0x13, 0x89, 0xa2, 0xca, 0x8a, 0x48, 0x96,
+	0xa8, 0x90, 0x78, 0x47, 0xcc, 0xd5, 0x8f, 0x24, 0x9c, 0x1c, 0x10, 0x0f, 0x39, 0xbf, 0x37, 0xdd,
+	0x6d, 0x9d, 0xde, 0xf3, 0x42, 0xaa, 0x5f, 0x56, 0x14, 0x8e, 0x51, 0x72, 0x91, 0xe6, 0x78, 0x8a,
+	0x1f, 0x16, 0xb6, 0x45, 0x3f, 0xc1, 0xb3, 0x35, 0x8a, 0x4d, 0x56, 0xbc, 0xe3, 0xc7, 0x6c, 0xc7,
+	0x3f, 0x8a, 0x14, 0xc9, 0x1d, 0xf8, 0x42, 0x64, 0xb1, 0xc4, 0x52, 0x05, 0xce, 0xd4, 0x99, 0xb9,
+	0x6c, 0x28, 0x44, 0xb6, 0xc6, 0x52, 0x91, 0x09, 0x8c, 0xea, 0x66, 0x54, 0x05, 0x57, 0xd3, 0xeb,
+	0x99, 0xcb, 0xfc, 0xda, 0xce, 0x2a, 0xca, 0x60, 0xf4, 0x21, 0xc7, 0xd3, 0xd7, 0x64, 0x9b, 0x73,
+	0x42, 0xe0, 0x51, 0x0f, 0x60, 0x6a, 0xf2, 0x00, 0xae, 0xde, 0x6e, 0x6f, 0x3e, 0x9e, 0x4f, 0xa2,
+	0xbe, 0x1f, 0x4c, 0x65, 0x6c, 0xea, 0x4a, 0x25, 0xaa, 0x62, 0x56, 0x49, 0xdf, 0xc2, 0x73, 0xeb,
+	0x6f, 0x9d, 0xec, 0x7e, 0x72, 0xb5, 0xc4, 0x5a, 0x28, 0x5e, 0x6a, 0xba, 0x48, 0x0a, 0x6e, 0xe8,
+	0x23, 0x66, 0x6a, 0xf2, 0x02, 0xdc, 0x63, 0x92, 0xd7, 0x3c, 0xb8, 0x9a, 0x3a, 0xb3, 0x6b, 0x66,
+	0x0f, 0xf4, 0x00, 0xe3, 0x06, 0x80, 0xa5, 0xfa, 0xcc, 0x55, 0x99, 0xed, 0x2a, 0xfd, 0x0c, 0x6d,
+	0x28, 0xee, 0x31, 0x7c, 0xdd, 0xf8, 0xa2, 0x39, 0xaf, 0x60, 0x28, 0xcd, 0xb2, 0xce, 0xa7, 0xfd,
+	0xdc, 0xe8, 0x3f, 0x4e, 0x58, 0xab, 0xa5, 0xdf, 0xe1, 0xc6, 0xce, 0xdb, 0x25, 0xb7, 0xe0, 0xed,
+	0xcd, 0xa7, 0x36, 0x1b, 0x9a, 0x13, 0x59, 0xc0, 0xb0, 0xb0, 0x92, 0x86, 0x7f, 0xf7, 0x0f, 0xbf,
+	0x33, 0xca, 0x5a, 0xe5, 0xfc, 0xb7, 0x03, 0x9e, 0x1d, 0x93, 0x25, 0xdc, 0xac, 0xb8, 0xea, 0xe5,
+	0x75, 0x1b, 0xd9, 0xd0, 0xa3, 0x36, 0xf4, 0xe8, 0xbd, 0x0e, 0x3d, 0x0c, 0xce, 0xb9, 0xdd, 0x0d,
+	0x3a, 0x20, 0x6f, 0xe0, 0xe9, 0x37, 0xb9, 0x4f, 0x14, 0xef, 0x12, 0x1b, 0xb7, 0xf2, 0xbf, 0xad,
+	0xf0, 0x02, 0x99, 0x0e, 0xc8, 0x6b, 0xf0, 0x57, 0x5c, 0x6d, 0x74, 0x54, 0x17, 0xf7, 0xbf, 0x3c,
+	0xdf, 0xdf, 0xbc, 0x89, 0x0e, 0xb6, 0x9e, 0x11, 0x2e, 0xfe, 0x04, 0x00, 0x00, 0xff, 0xff, 0x68,
+	0x97, 0xc4, 0x14, 0xc3, 0x02, 0x00, 0x00,
+}
diff --git a/netopeer/voltha-grpc-client/voltha/schema/schema.pb.go b/netopeer/voltha-grpc-client/voltha/schema/schema.pb.go
new file mode 100644
index 0000000..d46e1a4
--- /dev/null
+++ b/netopeer/voltha-grpc-client/voltha/schema/schema.pb.go
@@ -0,0 +1,208 @@
+// Code generated by protoc-gen-go.
+// source: schema.proto
+// DO NOT EDIT!
+
+/*
+Package schema is a generated protocol buffer package.
+
+It is generated from these files:
+	schema.proto
+
+It has these top-level messages:
+	ProtoFile
+	Schemas
+*/
+package schema
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+import google_protobuf1 "github.com/golang/protobuf/ptypes/empty"
+
+import (
+	context "golang.org/x/net/context"
+	grpc "google.golang.org/grpc"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+// Contains the name and content of a *.proto file
+type ProtoFile struct {
+	FileName    string `protobuf:"bytes,1,opt,name=file_name,json=fileName" json:"file_name,omitempty"`
+	Proto       string `protobuf:"bytes,2,opt,name=proto" json:"proto,omitempty"`
+	Descriptor_ []byte `protobuf:"bytes,3,opt,name=descriptor,proto3" json:"descriptor,omitempty"`
+}
+
+func (m *ProtoFile) Reset()                    { *m = ProtoFile{} }
+func (m *ProtoFile) String() string            { return proto.CompactTextString(m) }
+func (*ProtoFile) ProtoMessage()               {}
+func (*ProtoFile) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
+
+func (m *ProtoFile) GetFileName() string {
+	if m != nil {
+		return m.FileName
+	}
+	return ""
+}
+
+func (m *ProtoFile) GetProto() string {
+	if m != nil {
+		return m.Proto
+	}
+	return ""
+}
+
+func (m *ProtoFile) GetDescriptor_() []byte {
+	if m != nil {
+		return m.Descriptor_
+	}
+	return nil
+}
+
+// Proto files and compiled descriptors for this interface
+type Schemas struct {
+	// Proto files
+	Protos []*ProtoFile `protobuf:"bytes,1,rep,name=protos" json:"protos,omitempty"`
+	// Proto file name from which swagger.json shall be generated
+	SwaggerFrom string `protobuf:"bytes,2,opt,name=swagger_from,json=swaggerFrom" json:"swagger_from,omitempty"`
+	// Proto file name from which yang schemas shall be generated
+	YangFrom string `protobuf:"bytes,3,opt,name=yang_from,json=yangFrom" json:"yang_from,omitempty"`
+}
+
+func (m *Schemas) Reset()                    { *m = Schemas{} }
+func (m *Schemas) String() string            { return proto.CompactTextString(m) }
+func (*Schemas) ProtoMessage()               {}
+func (*Schemas) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
+
+func (m *Schemas) GetProtos() []*ProtoFile {
+	if m != nil {
+		return m.Protos
+	}
+	return nil
+}
+
+func (m *Schemas) GetSwaggerFrom() string {
+	if m != nil {
+		return m.SwaggerFrom
+	}
+	return ""
+}
+
+func (m *Schemas) GetYangFrom() string {
+	if m != nil {
+		return m.YangFrom
+	}
+	return ""
+}
+
+func init() {
+	proto.RegisterType((*ProtoFile)(nil), "schema.ProtoFile")
+	proto.RegisterType((*Schemas)(nil), "schema.Schemas")
+}
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ context.Context
+var _ grpc.ClientConn
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+const _ = grpc.SupportPackageIsVersion4
+
+// Client API for SchemaService service
+
+type SchemaServiceClient interface {
+	// Return active grpc schemas
+	GetSchema(ctx context.Context, in *google_protobuf1.Empty, opts ...grpc.CallOption) (*Schemas, error)
+}
+
+type schemaServiceClient struct {
+	cc *grpc.ClientConn
+}
+
+func NewSchemaServiceClient(cc *grpc.ClientConn) SchemaServiceClient {
+	return &schemaServiceClient{cc}
+}
+
+func (c *schemaServiceClient) GetSchema(ctx context.Context, in *google_protobuf1.Empty, opts ...grpc.CallOption) (*Schemas, error) {
+	out := new(Schemas)
+	err := grpc.Invoke(ctx, "/schema.SchemaService/GetSchema", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// Server API for SchemaService service
+
+type SchemaServiceServer interface {
+	// Return active grpc schemas
+	GetSchema(context.Context, *google_protobuf1.Empty) (*Schemas, error)
+}
+
+func RegisterSchemaServiceServer(s *grpc.Server, srv SchemaServiceServer) {
+	s.RegisterService(&_SchemaService_serviceDesc, srv)
+}
+
+func _SchemaService_GetSchema_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(google_protobuf1.Empty)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(SchemaServiceServer).GetSchema(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/schema.SchemaService/GetSchema",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(SchemaServiceServer).GetSchema(ctx, req.(*google_protobuf1.Empty))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+var _SchemaService_serviceDesc = grpc.ServiceDesc{
+	ServiceName: "schema.SchemaService",
+	HandlerType: (*SchemaServiceServer)(nil),
+	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "GetSchema",
+			Handler:    _SchemaService_GetSchema_Handler,
+		},
+	},
+	Streams:  []grpc.StreamDesc{},
+	Metadata: "schema.proto",
+}
+
+func init() { proto.RegisterFile("schema.proto", fileDescriptor0) }
+
+var fileDescriptor0 = []byte{
+	// 278 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x4c, 0x90, 0xc1, 0x4a, 0xc3, 0x40,
+	0x10, 0x86, 0x49, 0x8b, 0xad, 0x99, 0x56, 0x8a, 0x8b, 0x48, 0x48, 0x45, 0x62, 0x4e, 0xf1, 0x92,
+	0x40, 0x7d, 0x86, 0xd6, 0x9b, 0x48, 0x0a, 0x1e, 0x2d, 0xdb, 0x38, 0x89, 0x0b, 0xd9, 0x6c, 0xd8,
+	0x5d, 0x95, 0x5e, 0x7d, 0x05, 0x1f, 0xcd, 0x57, 0xf0, 0x41, 0x64, 0x33, 0x5b, 0xf1, 0xb6, 0xf3,
+	0x7f, 0x33, 0xcc, 0xb7, 0x03, 0x73, 0x53, 0xbd, 0xa2, 0xe4, 0x79, 0xaf, 0x95, 0x55, 0x6c, 0x42,
+	0x55, 0x7c, 0xd5, 0x28, 0xd5, 0xb4, 0x58, 0xf0, 0x5e, 0x14, 0xbc, 0xeb, 0x94, 0xe5, 0x56, 0xa8,
+	0xce, 0x50, 0x57, 0xbc, 0xf4, 0x74, 0xa8, 0xf6, 0x6f, 0x75, 0x81, 0xb2, 0xb7, 0x07, 0x82, 0xe9,
+	0x33, 0x84, 0x8f, 0xee, 0xb1, 0x11, 0x2d, 0xb2, 0x25, 0x84, 0xb5, 0x68, 0x71, 0xd7, 0x71, 0x89,
+	0x51, 0x90, 0x04, 0x59, 0x58, 0x9e, 0xba, 0xe0, 0x81, 0x4b, 0x64, 0x17, 0x70, 0x32, 0x8c, 0x44,
+	0xa3, 0x01, 0x50, 0xc1, 0xae, 0x01, 0x5e, 0xd0, 0x54, 0x5a, 0xf4, 0x56, 0xe9, 0x68, 0x9c, 0x04,
+	0xd9, 0xbc, 0xfc, 0x97, 0xa4, 0x16, 0xa6, 0xdb, 0x41, 0xd2, 0xb0, 0x5b, 0x98, 0x0c, 0x33, 0x26,
+	0x0a, 0x92, 0x71, 0x36, 0x5b, 0x9d, 0xe7, 0xfe, 0x33, 0x7f, 0x02, 0xa5, 0x6f, 0x60, 0x37, 0x30,
+	0x37, 0x1f, 0xbc, 0x69, 0x50, 0xef, 0x6a, 0xad, 0xa4, 0x5f, 0x39, 0xf3, 0xd9, 0x46, 0x2b, 0xe9,
+	0x5c, 0x0f, 0xbc, 0x6b, 0x88, 0x8f, 0xc9, 0xd5, 0x05, 0x0e, 0xae, 0x9e, 0xe0, 0x8c, 0xb6, 0x6e,
+	0x51, 0xbf, 0x8b, 0x0a, 0xd9, 0x1a, 0xc2, 0x7b, 0xb4, 0x94, 0xb1, 0xcb, 0x9c, 0x2e, 0x92, 0x1f,
+	0x2f, 0x92, 0xaf, 0xdd, 0x45, 0xe2, 0xc5, 0x51, 0xc8, 0x1b, 0xa7, 0x8b, 0xcf, 0xef, 0x9f, 0xaf,
+	0x51, 0xc8, 0xa6, 0x05, 0x81, 0x3d, 0xf9, 0xdd, 0xfd, 0x06, 0x00, 0x00, 0xff, 0xff, 0xae, 0xf9,
+	0x7e, 0x49, 0x87, 0x01, 0x00, 0x00,
+}
diff --git a/netopeer/voltha-grpc-client/voltha/voltha.pb.go b/netopeer/voltha-grpc-client/voltha/voltha.pb.go
new file mode 100644
index 0000000..f1656f6
--- /dev/null
+++ b/netopeer/voltha-grpc-client/voltha/voltha.pb.go
@@ -0,0 +1,6114 @@
+// Code generated by protoc-gen-go.
+// source: voltha.proto
+// DO NOT EDIT!
+
+/*
+Package voltha is a generated protocol buffer package.
+
+It is generated from these files:
+	voltha.proto
+
+It has these top-level messages:
+	DeviceGroup
+	DeviceGroups
+	AlarmFilterRuleKey
+	AlarmFilterRule
+	AlarmFilter
+	AlarmFilters
+	VolthaInstance
+	VolthaInstances
+	Voltha
+*/
+package voltha
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+import google_protobuf "github.com/golang/protobuf/ptypes/empty"
+import _ "github.com/golang/protobuf/ptypes/any"
+import voltha2 "github.com/opencord/voltha/netconf/translator/voltha/meta"
+import voltha3 "github.com/opencord/voltha/netconf/translator/voltha/common"
+import voltha4 "github.com/opencord/voltha/netconf/translator/voltha/health"
+import voltha5 "github.com/opencord/voltha/netconf/translator/voltha/logical_device"
+import voltha6 "github.com/opencord/voltha/netconf/translator/voltha/device"
+import voltha7 "github.com/opencord/voltha/netconf/translator/voltha/adapter"
+import openflow_13 "github.com/opencord/voltha/netconf/translator/voltha/openflow_13"
+
+import (
+	context "golang.org/x/net/context"
+	grpc "google.golang.org/grpc"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+// ChildNode from public import meta.proto
+type ChildNode voltha2.ChildNode
+
+func (m *ChildNode) Reset()         { (*voltha2.ChildNode)(m).Reset() }
+func (m *ChildNode) String() string { return (*voltha2.ChildNode)(m).String() }
+func (*ChildNode) ProtoMessage()    {}
+func (m *ChildNode) GetKey() string { return (*voltha2.ChildNode)(m).GetKey() }
+
+// Access from public import meta.proto
+type Access voltha2.Access
+
+var Access_name = voltha2.Access_name
+var Access_value = voltha2.Access_value
+
+func (x Access) String() string { return (voltha2.Access)(x).String() }
+
+const Access_CONFIG = Access(voltha2.Access_CONFIG)
+const Access_READ_ONLY = Access(voltha2.Access_READ_ONLY)
+const Access_REAL_TIME = Access(voltha2.Access_REAL_TIME)
+
+// child_node from public import meta.proto
+var E_ChildNode = voltha2.E_ChildNode
+
+// access from public import meta.proto
+var E_Access = voltha2.E_Access
+
+// ID from public import common.proto
+type ID voltha3.ID
+
+func (m *ID) Reset()         { (*voltha3.ID)(m).Reset() }
+func (m *ID) String() string { return (*voltha3.ID)(m).String() }
+func (*ID) ProtoMessage()    {}
+func (m *ID) GetId() string  { return (*voltha3.ID)(m).GetId() }
+
+// LogLevel from public import common.proto
+type LogLevel voltha3.LogLevel
+
+func (m *LogLevel) Reset()         { (*voltha3.LogLevel)(m).Reset() }
+func (m *LogLevel) String() string { return (*voltha3.LogLevel)(m).String() }
+func (*LogLevel) ProtoMessage()    {}
+
+// AdminState from public import common.proto
+type AdminState voltha3.AdminState
+
+func (m *AdminState) Reset()         { (*voltha3.AdminState)(m).Reset() }
+func (m *AdminState) String() string { return (*voltha3.AdminState)(m).String() }
+func (*AdminState) ProtoMessage()    {}
+
+// OperStatus from public import common.proto
+type OperStatus voltha3.OperStatus
+
+func (m *OperStatus) Reset()         { (*voltha3.OperStatus)(m).Reset() }
+func (m *OperStatus) String() string { return (*voltha3.OperStatus)(m).String() }
+func (*OperStatus) ProtoMessage()    {}
+
+// ConnectStatus from public import common.proto
+type ConnectStatus voltha3.ConnectStatus
+
+func (m *ConnectStatus) Reset()         { (*voltha3.ConnectStatus)(m).Reset() }
+func (m *ConnectStatus) String() string { return (*voltha3.ConnectStatus)(m).String() }
+func (*ConnectStatus) ProtoMessage()    {}
+
+// LogLevel from public import common.proto
+type LogLevel_LogLevel voltha3.LogLevel_LogLevel
+
+var LogLevel_LogLevel_name = voltha3.LogLevel_LogLevel_name
+var LogLevel_LogLevel_value = voltha3.LogLevel_LogLevel_value
+
+func (x LogLevel_LogLevel) String() string { return (voltha3.LogLevel_LogLevel)(x).String() }
+
+const LogLevel_DEBUG = LogLevel_LogLevel(voltha3.LogLevel_DEBUG)
+const LogLevel_INFO = LogLevel_LogLevel(voltha3.LogLevel_INFO)
+const LogLevel_WARNING = LogLevel_LogLevel(voltha3.LogLevel_WARNING)
+const LogLevel_ERROR = LogLevel_LogLevel(voltha3.LogLevel_ERROR)
+const LogLevel_CRITICAL = LogLevel_LogLevel(voltha3.LogLevel_CRITICAL)
+
+// AdminState from public import common.proto
+type AdminState_AdminState voltha3.AdminState_AdminState
+
+var AdminState_AdminState_name = voltha3.AdminState_AdminState_name
+var AdminState_AdminState_value = voltha3.AdminState_AdminState_value
+
+func (x AdminState_AdminState) String() string { return (voltha3.AdminState_AdminState)(x).String() }
+
+const AdminState_UNKNOWN = AdminState_AdminState(voltha3.AdminState_UNKNOWN)
+const AdminState_PREPROVISIONED = AdminState_AdminState(voltha3.AdminState_PREPROVISIONED)
+const AdminState_ENABLED = AdminState_AdminState(voltha3.AdminState_ENABLED)
+const AdminState_DISABLED = AdminState_AdminState(voltha3.AdminState_DISABLED)
+
+// OperStatus from public import common.proto
+type OperStatus_OperStatus voltha3.OperStatus_OperStatus
+
+var OperStatus_OperStatus_name = voltha3.OperStatus_OperStatus_name
+var OperStatus_OperStatus_value = voltha3.OperStatus_OperStatus_value
+
+func (x OperStatus_OperStatus) String() string { return (voltha3.OperStatus_OperStatus)(x).String() }
+
+const OperStatus_UNKNOWN = OperStatus_OperStatus(voltha3.OperStatus_UNKNOWN)
+const OperStatus_DISCOVERED = OperStatus_OperStatus(voltha3.OperStatus_DISCOVERED)
+const OperStatus_ACTIVATING = OperStatus_OperStatus(voltha3.OperStatus_ACTIVATING)
+const OperStatus_TESTING = OperStatus_OperStatus(voltha3.OperStatus_TESTING)
+const OperStatus_ACTIVE = OperStatus_OperStatus(voltha3.OperStatus_ACTIVE)
+const OperStatus_FAILED = OperStatus_OperStatus(voltha3.OperStatus_FAILED)
+
+// ConnectStatus from public import common.proto
+type ConnectStatus_ConnectStatus voltha3.ConnectStatus_ConnectStatus
+
+var ConnectStatus_ConnectStatus_name = voltha3.ConnectStatus_ConnectStatus_name
+var ConnectStatus_ConnectStatus_value = voltha3.ConnectStatus_ConnectStatus_value
+
+func (x ConnectStatus_ConnectStatus) String() string {
+	return (voltha3.ConnectStatus_ConnectStatus)(x).String()
+}
+
+const ConnectStatus_UNKNOWN = ConnectStatus_ConnectStatus(voltha3.ConnectStatus_UNKNOWN)
+const ConnectStatus_UNREACHABLE = ConnectStatus_ConnectStatus(voltha3.ConnectStatus_UNREACHABLE)
+const ConnectStatus_REACHABLE = ConnectStatus_ConnectStatus(voltha3.ConnectStatus_REACHABLE)
+
+// HealthStatus from public import health.proto
+type HealthStatus voltha4.HealthStatus
+
+func (m *HealthStatus) Reset()         { (*voltha4.HealthStatus)(m).Reset() }
+func (m *HealthStatus) String() string { return (*voltha4.HealthStatus)(m).String() }
+func (*HealthStatus) ProtoMessage()    {}
+func (m *HealthStatus) GetState() HealthStatus_HealthState {
+	return (HealthStatus_HealthState)((*voltha4.HealthStatus)(m).GetState())
+}
+
+// HealthState from public import health.proto
+type HealthStatus_HealthState voltha4.HealthStatus_HealthState
+
+var HealthStatus_HealthState_name = voltha4.HealthStatus_HealthState_name
+var HealthStatus_HealthState_value = voltha4.HealthStatus_HealthState_value
+
+func (x HealthStatus_HealthState) String() string {
+	return (voltha4.HealthStatus_HealthState)(x).String()
+}
+
+const HealthStatus_HEALTHY = HealthStatus_HealthState(voltha4.HealthStatus_HEALTHY)
+const HealthStatus_OVERLOADED = HealthStatus_HealthState(voltha4.HealthStatus_OVERLOADED)
+const HealthStatus_DYING = HealthStatus_HealthState(voltha4.HealthStatus_DYING)
+
+// LogicalPort from public import logical_device.proto
+type LogicalPort voltha5.LogicalPort
+
+func (m *LogicalPort) Reset()                  { (*voltha5.LogicalPort)(m).Reset() }
+func (m *LogicalPort) String() string          { return (*voltha5.LogicalPort)(m).String() }
+func (*LogicalPort) ProtoMessage()             {}
+func (m *LogicalPort) GetId() string           { return (*voltha5.LogicalPort)(m).GetId() }
+func (m *LogicalPort) GetDeviceId() string     { return (*voltha5.LogicalPort)(m).GetDeviceId() }
+func (m *LogicalPort) GetDevicePortNo() uint32 { return (*voltha5.LogicalPort)(m).GetDevicePortNo() }
+func (m *LogicalPort) GetRootPort() bool       { return (*voltha5.LogicalPort)(m).GetRootPort() }
+
+// LogicalPorts from public import logical_device.proto
+type LogicalPorts voltha5.LogicalPorts
+
+func (m *LogicalPorts) Reset()         { (*voltha5.LogicalPorts)(m).Reset() }
+func (m *LogicalPorts) String() string { return (*voltha5.LogicalPorts)(m).String() }
+func (*LogicalPorts) ProtoMessage()    {}
+func (m *LogicalPorts) GetItems() []*LogicalPort {
+	o := (*voltha5.LogicalPorts)(m).GetItems()
+	if o == nil {
+		return nil
+	}
+	s := make([]*LogicalPort, len(o))
+	for i, x := range o {
+		s[i] = (*LogicalPort)(x)
+	}
+	return s
+}
+
+// LogicalDevice from public import logical_device.proto
+type LogicalDevice voltha5.LogicalDevice
+
+func (m *LogicalDevice) Reset()                  { (*voltha5.LogicalDevice)(m).Reset() }
+func (m *LogicalDevice) String() string          { return (*voltha5.LogicalDevice)(m).String() }
+func (*LogicalDevice) ProtoMessage()             {}
+func (m *LogicalDevice) GetId() string           { return (*voltha5.LogicalDevice)(m).GetId() }
+func (m *LogicalDevice) GetDatapathId() uint64   { return (*voltha5.LogicalDevice)(m).GetDatapathId() }
+func (m *LogicalDevice) GetRootDeviceId() string { return (*voltha5.LogicalDevice)(m).GetRootDeviceId() }
+func (m *LogicalDevice) GetPorts() []*LogicalPort {
+	o := (*voltha5.LogicalDevice)(m).GetPorts()
+	if o == nil {
+		return nil
+	}
+	s := make([]*LogicalPort, len(o))
+	for i, x := range o {
+		s[i] = (*LogicalPort)(x)
+	}
+	return s
+}
+
+// LogicalDevices from public import logical_device.proto
+type LogicalDevices voltha5.LogicalDevices
+
+func (m *LogicalDevices) Reset()         { (*voltha5.LogicalDevices)(m).Reset() }
+func (m *LogicalDevices) String() string { return (*voltha5.LogicalDevices)(m).String() }
+func (*LogicalDevices) ProtoMessage()    {}
+func (m *LogicalDevices) GetItems() []*LogicalDevice {
+	o := (*voltha5.LogicalDevices)(m).GetItems()
+	if o == nil {
+		return nil
+	}
+	s := make([]*LogicalDevice, len(o))
+	for i, x := range o {
+		s[i] = (*LogicalDevice)(x)
+	}
+	return s
+}
+
+// DeviceType from public import device.proto
+type DeviceType voltha6.DeviceType
+
+func (m *DeviceType) Reset()             { (*voltha6.DeviceType)(m).Reset() }
+func (m *DeviceType) String() string     { return (*voltha6.DeviceType)(m).String() }
+func (*DeviceType) ProtoMessage()        {}
+func (m *DeviceType) GetId() string      { return (*voltha6.DeviceType)(m).GetId() }
+func (m *DeviceType) GetAdapter() string { return (*voltha6.DeviceType)(m).GetAdapter() }
+func (m *DeviceType) GetAcceptsBulkFlowUpdate() bool {
+	return (*voltha6.DeviceType)(m).GetAcceptsBulkFlowUpdate()
+}
+func (m *DeviceType) GetAcceptsAddRemoveFlowUpdates() bool {
+	return (*voltha6.DeviceType)(m).GetAcceptsAddRemoveFlowUpdates()
+}
+
+// DeviceTypes from public import device.proto
+type DeviceTypes voltha6.DeviceTypes
+
+func (m *DeviceTypes) Reset()         { (*voltha6.DeviceTypes)(m).Reset() }
+func (m *DeviceTypes) String() string { return (*voltha6.DeviceTypes)(m).String() }
+func (*DeviceTypes) ProtoMessage()    {}
+func (m *DeviceTypes) GetItems() []*DeviceType {
+	o := (*voltha6.DeviceTypes)(m).GetItems()
+	if o == nil {
+		return nil
+	}
+	s := make([]*DeviceType, len(o))
+	for i, x := range o {
+		s[i] = (*DeviceType)(x)
+	}
+	return s
+}
+
+// PmConfig from public import device.proto
+type PmConfig voltha6.PmConfig
+
+func (m *PmConfig) Reset()          { (*voltha6.PmConfig)(m).Reset() }
+func (m *PmConfig) String() string  { return (*voltha6.PmConfig)(m).String() }
+func (*PmConfig) ProtoMessage()     {}
+func (m *PmConfig) GetName() string { return (*voltha6.PmConfig)(m).GetName() }
+func (m *PmConfig) GetType() PmConfig_PmType {
+	return (PmConfig_PmType)((*voltha6.PmConfig)(m).GetType())
+}
+func (m *PmConfig) GetEnabled() bool      { return (*voltha6.PmConfig)(m).GetEnabled() }
+func (m *PmConfig) GetSampleFreq() uint32 { return (*voltha6.PmConfig)(m).GetSampleFreq() }
+
+// PmGroupConfig from public import device.proto
+type PmGroupConfig voltha6.PmGroupConfig
+
+func (m *PmGroupConfig) Reset()               { (*voltha6.PmGroupConfig)(m).Reset() }
+func (m *PmGroupConfig) String() string       { return (*voltha6.PmGroupConfig)(m).String() }
+func (*PmGroupConfig) ProtoMessage()          {}
+func (m *PmGroupConfig) GetGroupName() string { return (*voltha6.PmGroupConfig)(m).GetGroupName() }
+func (m *PmGroupConfig) GetGroupFreq() uint32 { return (*voltha6.PmGroupConfig)(m).GetGroupFreq() }
+func (m *PmGroupConfig) GetEnabled() bool     { return (*voltha6.PmGroupConfig)(m).GetEnabled() }
+func (m *PmGroupConfig) GetMetrics() []*PmConfig {
+	o := (*voltha6.PmGroupConfig)(m).GetMetrics()
+	if o == nil {
+		return nil
+	}
+	s := make([]*PmConfig, len(o))
+	for i, x := range o {
+		s[i] = (*PmConfig)(x)
+	}
+	return s
+}
+
+// PmConfigs from public import device.proto
+type PmConfigs voltha6.PmConfigs
+
+func (m *PmConfigs) Reset()                 { (*voltha6.PmConfigs)(m).Reset() }
+func (m *PmConfigs) String() string         { return (*voltha6.PmConfigs)(m).String() }
+func (*PmConfigs) ProtoMessage()            {}
+func (m *PmConfigs) GetId() string          { return (*voltha6.PmConfigs)(m).GetId() }
+func (m *PmConfigs) GetDefaultFreq() uint32 { return (*voltha6.PmConfigs)(m).GetDefaultFreq() }
+func (m *PmConfigs) GetGrouped() bool       { return (*voltha6.PmConfigs)(m).GetGrouped() }
+func (m *PmConfigs) GetFreqOverride() bool  { return (*voltha6.PmConfigs)(m).GetFreqOverride() }
+func (m *PmConfigs) GetGroups() []*PmGroupConfig {
+	o := (*voltha6.PmConfigs)(m).GetGroups()
+	if o == nil {
+		return nil
+	}
+	s := make([]*PmGroupConfig, len(o))
+	for i, x := range o {
+		s[i] = (*PmGroupConfig)(x)
+	}
+	return s
+}
+func (m *PmConfigs) GetMetrics() []*PmConfig {
+	o := (*voltha6.PmConfigs)(m).GetMetrics()
+	if o == nil {
+		return nil
+	}
+	s := make([]*PmConfig, len(o))
+	for i, x := range o {
+		s[i] = (*PmConfig)(x)
+	}
+	return s
+}
+
+// Port from public import device.proto
+type Port voltha6.Port
+
+func (m *Port) Reset()                 { (*voltha6.Port)(m).Reset() }
+func (m *Port) String() string         { return (*voltha6.Port)(m).String() }
+func (*Port) ProtoMessage()            {}
+func (m *Port) GetPortNo() uint32      { return (*voltha6.Port)(m).GetPortNo() }
+func (m *Port) GetLabel() string       { return (*voltha6.Port)(m).GetLabel() }
+func (m *Port) GetType() Port_PortType { return (Port_PortType)((*voltha6.Port)(m).GetType()) }
+func (m *Port) GetDeviceId() string    { return (*voltha6.Port)(m).GetDeviceId() }
+func (m *Port) GetPeers() []*Port_PeerPort {
+	o := (*voltha6.Port)(m).GetPeers()
+	if o == nil {
+		return nil
+	}
+	s := make([]*Port_PeerPort, len(o))
+	for i, x := range o {
+		s[i] = (*Port_PeerPort)(x)
+	}
+	return s
+}
+
+// PeerPort from public import device.proto
+type Port_PeerPort voltha6.Port_PeerPort
+
+func (m *Port_PeerPort) Reset()              { (*voltha6.Port_PeerPort)(m).Reset() }
+func (m *Port_PeerPort) String() string      { return (*voltha6.Port_PeerPort)(m).String() }
+func (*Port_PeerPort) ProtoMessage()         {}
+func (m *Port_PeerPort) GetDeviceId() string { return (*voltha6.Port_PeerPort)(m).GetDeviceId() }
+func (m *Port_PeerPort) GetPortNo() uint32   { return (*voltha6.Port_PeerPort)(m).GetPortNo() }
+
+// Ports from public import device.proto
+type Ports voltha6.Ports
+
+func (m *Ports) Reset()         { (*voltha6.Ports)(m).Reset() }
+func (m *Ports) String() string { return (*voltha6.Ports)(m).String() }
+func (*Ports) ProtoMessage()    {}
+func (m *Ports) GetItems() []*Port {
+	o := (*voltha6.Ports)(m).GetItems()
+	if o == nil {
+		return nil
+	}
+	s := make([]*Port, len(o))
+	for i, x := range o {
+		s[i] = (*Port)(x)
+	}
+	return s
+}
+
+// Device from public import device.proto
+type Device voltha6.Device
+
+func (m *Device) Reset()         { (*voltha6.Device)(m).Reset() }
+func (m *Device) String() string { return (*voltha6.Device)(m).String() }
+func (*Device) ProtoMessage()    {}
+func (m *Device) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) int, []interface{}) {
+	return _Device_OneofMarshaler, _Device_OneofUnmarshaler, _Device_OneofSizer, nil
+}
+func _Device_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
+	m := msg.(*Device)
+	m0 := (*voltha6.Device)(m)
+	enc, _, _, _ := m0.XXX_OneofFuncs()
+	return enc(m0, b)
+}
+func _Device_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
+	m := msg.(*Device)
+	m0 := (*voltha6.Device)(m)
+	_, dec, _, _ := m0.XXX_OneofFuncs()
+	return dec(m0, tag, wire, b)
+}
+func _Device_OneofSizer(msg proto.Message) int {
+	m := msg.(*Device)
+	m0 := (*voltha6.Device)(m)
+	_, _, size, _ := m0.XXX_OneofFuncs()
+	return size(m0)
+}
+func (m *Device) GetId() string              { return (*voltha6.Device)(m).GetId() }
+func (m *Device) GetType() string            { return (*voltha6.Device)(m).GetType() }
+func (m *Device) GetRoot() bool              { return (*voltha6.Device)(m).GetRoot() }
+func (m *Device) GetParentId() string        { return (*voltha6.Device)(m).GetParentId() }
+func (m *Device) GetParentPortNo() uint32    { return (*voltha6.Device)(m).GetParentPortNo() }
+func (m *Device) GetVendor() string          { return (*voltha6.Device)(m).GetVendor() }
+func (m *Device) GetModel() string           { return (*voltha6.Device)(m).GetModel() }
+func (m *Device) GetHardwareVersion() string { return (*voltha6.Device)(m).GetHardwareVersion() }
+func (m *Device) GetFirmwareVersion() string { return (*voltha6.Device)(m).GetFirmwareVersion() }
+func (m *Device) GetSoftwareVersion() string { return (*voltha6.Device)(m).GetSoftwareVersion() }
+func (m *Device) GetSerialNumber() string    { return (*voltha6.Device)(m).GetSerialNumber() }
+func (m *Device) GetAdapter() string         { return (*voltha6.Device)(m).GetAdapter() }
+func (m *Device) GetVlan() uint32            { return (*voltha6.Device)(m).GetVlan() }
+func (m *Device) GetMacAddress() string      { return (*voltha6.Device)(m).GetMacAddress() }
+func (m *Device) GetIpv4Address() string     { return (*voltha6.Device)(m).GetIpv4Address() }
+func (m *Device) GetIpv6Address() string     { return (*voltha6.Device)(m).GetIpv6Address() }
+func (m *Device) GetHostAndPort() string     { return (*voltha6.Device)(m).GetHostAndPort() }
+func (m *Device) GetProxyAddress() *Device_ProxyAddress {
+	return (*Device_ProxyAddress)((*voltha6.Device)(m).GetProxyAddress())
+}
+func (m *Device) GetReason() string { return (*voltha6.Device)(m).GetReason() }
+func (m *Device) GetPorts() []*Port {
+	o := (*voltha6.Device)(m).GetPorts()
+	if o == nil {
+		return nil
+	}
+	s := make([]*Port, len(o))
+	for i, x := range o {
+		s[i] = (*Port)(x)
+	}
+	return s
+}
+func (m *Device) GetPmConfigs() *PmConfigs { return (*PmConfigs)((*voltha6.Device)(m).GetPmConfigs()) }
+
+// ProxyAddress from public import device.proto
+type Device_ProxyAddress voltha6.Device_ProxyAddress
+
+func (m *Device_ProxyAddress) Reset()         { (*voltha6.Device_ProxyAddress)(m).Reset() }
+func (m *Device_ProxyAddress) String() string { return (*voltha6.Device_ProxyAddress)(m).String() }
+func (*Device_ProxyAddress) ProtoMessage()    {}
+func (m *Device_ProxyAddress) GetDeviceId() string {
+	return (*voltha6.Device_ProxyAddress)(m).GetDeviceId()
+}
+func (m *Device_ProxyAddress) GetChannelId() uint32 {
+	return (*voltha6.Device_ProxyAddress)(m).GetChannelId()
+}
+func (m *Device_ProxyAddress) GetOnuId() uint32 { return (*voltha6.Device_ProxyAddress)(m).GetOnuId() }
+func (m *Device_ProxyAddress) GetOnuSessionId() uint32 {
+	return (*voltha6.Device_ProxyAddress)(m).GetOnuSessionId()
+}
+
+// Devices from public import device.proto
+type Devices voltha6.Devices
+
+func (m *Devices) Reset()         { (*voltha6.Devices)(m).Reset() }
+func (m *Devices) String() string { return (*voltha6.Devices)(m).String() }
+func (*Devices) ProtoMessage()    {}
+func (m *Devices) GetItems() []*Device {
+	o := (*voltha6.Devices)(m).GetItems()
+	if o == nil {
+		return nil
+	}
+	s := make([]*Device, len(o))
+	for i, x := range o {
+		s[i] = (*Device)(x)
+	}
+	return s
+}
+
+// PmType from public import device.proto
+type PmConfig_PmType voltha6.PmConfig_PmType
+
+var PmConfig_PmType_name = voltha6.PmConfig_PmType_name
+var PmConfig_PmType_value = voltha6.PmConfig_PmType_value
+
+func (x PmConfig_PmType) String() string { return (voltha6.PmConfig_PmType)(x).String() }
+
+const PmConfig_COUNTER = PmConfig_PmType(voltha6.PmConfig_COUNTER)
+const PmConfig_GUAGE = PmConfig_PmType(voltha6.PmConfig_GUAGE)
+const PmConfig_STATE = PmConfig_PmType(voltha6.PmConfig_STATE)
+
+// PortType from public import device.proto
+type Port_PortType voltha6.Port_PortType
+
+var Port_PortType_name = voltha6.Port_PortType_name
+var Port_PortType_value = voltha6.Port_PortType_value
+
+func (x Port_PortType) String() string { return (voltha6.Port_PortType)(x).String() }
+
+const Port_UNKNOWN = Port_PortType(voltha6.Port_UNKNOWN)
+const Port_ETHERNET_NNI = Port_PortType(voltha6.Port_ETHERNET_NNI)
+const Port_ETHERNET_UNI = Port_PortType(voltha6.Port_ETHERNET_UNI)
+const Port_PON_OLT = Port_PortType(voltha6.Port_PON_OLT)
+const Port_PON_ONU = Port_PortType(voltha6.Port_PON_ONU)
+
+// AdapterConfig from public import adapter.proto
+type AdapterConfig voltha7.AdapterConfig
+
+func (m *AdapterConfig) Reset()         { (*voltha7.AdapterConfig)(m).Reset() }
+func (m *AdapterConfig) String() string { return (*voltha7.AdapterConfig)(m).String() }
+func (*AdapterConfig) ProtoMessage()    {}
+
+// Adapter from public import adapter.proto
+type Adapter voltha7.Adapter
+
+func (m *Adapter) Reset()             { (*voltha7.Adapter)(m).Reset() }
+func (m *Adapter) String() string     { return (*voltha7.Adapter)(m).String() }
+func (*Adapter) ProtoMessage()        {}
+func (m *Adapter) GetId() string      { return (*voltha7.Adapter)(m).GetId() }
+func (m *Adapter) GetVendor() string  { return (*voltha7.Adapter)(m).GetVendor() }
+func (m *Adapter) GetVersion() string { return (*voltha7.Adapter)(m).GetVersion() }
+func (m *Adapter) GetConfig() *AdapterConfig {
+	return (*AdapterConfig)((*voltha7.Adapter)(m).GetConfig())
+}
+func (m *Adapter) GetLogicalDeviceIds() []string { return (*voltha7.Adapter)(m).GetLogicalDeviceIds() }
+
+// Adapters from public import adapter.proto
+type Adapters voltha7.Adapters
+
+func (m *Adapters) Reset()         { (*voltha7.Adapters)(m).Reset() }
+func (m *Adapters) String() string { return (*voltha7.Adapters)(m).String() }
+func (*Adapters) ProtoMessage()    {}
+func (m *Adapters) GetItems() []*Adapter {
+	o := (*voltha7.Adapters)(m).GetItems()
+	if o == nil {
+		return nil
+	}
+	s := make([]*Adapter, len(o))
+	for i, x := range o {
+		s[i] = (*Adapter)(x)
+	}
+	return s
+}
+
+// ofp_header from public import openflow_13.proto
+type OfpHeader openflow_13.OfpHeader
+
+func (m *OfpHeader) Reset()             { (*openflow_13.OfpHeader)(m).Reset() }
+func (m *OfpHeader) String() string     { return (*openflow_13.OfpHeader)(m).String() }
+func (*OfpHeader) ProtoMessage()        {}
+func (m *OfpHeader) GetVersion() uint32 { return (*openflow_13.OfpHeader)(m).GetVersion() }
+func (m *OfpHeader) GetType() OfpType   { return (OfpType)((*openflow_13.OfpHeader)(m).GetType()) }
+func (m *OfpHeader) GetXid() uint32     { return (*openflow_13.OfpHeader)(m).GetXid() }
+
+// ofp_hello_elem_header from public import openflow_13.proto
+type OfpHelloElemHeader openflow_13.OfpHelloElemHeader
+
+func (m *OfpHelloElemHeader) Reset()         { (*openflow_13.OfpHelloElemHeader)(m).Reset() }
+func (m *OfpHelloElemHeader) String() string { return (*openflow_13.OfpHelloElemHeader)(m).String() }
+func (*OfpHelloElemHeader) ProtoMessage()    {}
+func (m *OfpHelloElemHeader) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) int, []interface{}) {
+	return _OfpHelloElemHeader_OneofMarshaler, _OfpHelloElemHeader_OneofUnmarshaler, _OfpHelloElemHeader_OneofSizer, nil
+}
+func _OfpHelloElemHeader_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
+	m := msg.(*OfpHelloElemHeader)
+	m0 := (*openflow_13.OfpHelloElemHeader)(m)
+	enc, _, _, _ := m0.XXX_OneofFuncs()
+	return enc(m0, b)
+}
+func _OfpHelloElemHeader_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
+	m := msg.(*OfpHelloElemHeader)
+	m0 := (*openflow_13.OfpHelloElemHeader)(m)
+	_, dec, _, _ := m0.XXX_OneofFuncs()
+	return dec(m0, tag, wire, b)
+}
+func _OfpHelloElemHeader_OneofSizer(msg proto.Message) int {
+	m := msg.(*OfpHelloElemHeader)
+	m0 := (*openflow_13.OfpHelloElemHeader)(m)
+	_, _, size, _ := m0.XXX_OneofFuncs()
+	return size(m0)
+}
+func (m *OfpHelloElemHeader) GetType() OfpHelloElemType {
+	return (OfpHelloElemType)((*openflow_13.OfpHelloElemHeader)(m).GetType())
+}
+func (m *OfpHelloElemHeader) GetVersionbitmap() *OfpHelloElemVersionbitmap {
+	return (*OfpHelloElemVersionbitmap)((*openflow_13.OfpHelloElemHeader)(m).GetVersionbitmap())
+}
+
+// ofp_hello_elem_versionbitmap from public import openflow_13.proto
+type OfpHelloElemVersionbitmap openflow_13.OfpHelloElemVersionbitmap
+
+func (m *OfpHelloElemVersionbitmap) Reset() { (*openflow_13.OfpHelloElemVersionbitmap)(m).Reset() }
+func (m *OfpHelloElemVersionbitmap) String() string {
+	return (*openflow_13.OfpHelloElemVersionbitmap)(m).String()
+}
+func (*OfpHelloElemVersionbitmap) ProtoMessage() {}
+func (m *OfpHelloElemVersionbitmap) GetBitmaps() []uint32 {
+	return (*openflow_13.OfpHelloElemVersionbitmap)(m).GetBitmaps()
+}
+
+// ofp_hello from public import openflow_13.proto
+type OfpHello openflow_13.OfpHello
+
+func (m *OfpHello) Reset()         { (*openflow_13.OfpHello)(m).Reset() }
+func (m *OfpHello) String() string { return (*openflow_13.OfpHello)(m).String() }
+func (*OfpHello) ProtoMessage()    {}
+func (m *OfpHello) GetElements() []*OfpHelloElemHeader {
+	o := (*openflow_13.OfpHello)(m).GetElements()
+	if o == nil {
+		return nil
+	}
+	s := make([]*OfpHelloElemHeader, len(o))
+	for i, x := range o {
+		s[i] = (*OfpHelloElemHeader)(x)
+	}
+	return s
+}
+
+// ofp_switch_config from public import openflow_13.proto
+type OfpSwitchConfig openflow_13.OfpSwitchConfig
+
+func (m *OfpSwitchConfig) Reset()           { (*openflow_13.OfpSwitchConfig)(m).Reset() }
+func (m *OfpSwitchConfig) String() string   { return (*openflow_13.OfpSwitchConfig)(m).String() }
+func (*OfpSwitchConfig) ProtoMessage()      {}
+func (m *OfpSwitchConfig) GetFlags() uint32 { return (*openflow_13.OfpSwitchConfig)(m).GetFlags() }
+func (m *OfpSwitchConfig) GetMissSendLen() uint32 {
+	return (*openflow_13.OfpSwitchConfig)(m).GetMissSendLen()
+}
+
+// ofp_table_mod from public import openflow_13.proto
+type OfpTableMod openflow_13.OfpTableMod
+
+func (m *OfpTableMod) Reset()             { (*openflow_13.OfpTableMod)(m).Reset() }
+func (m *OfpTableMod) String() string     { return (*openflow_13.OfpTableMod)(m).String() }
+func (*OfpTableMod) ProtoMessage()        {}
+func (m *OfpTableMod) GetTableId() uint32 { return (*openflow_13.OfpTableMod)(m).GetTableId() }
+func (m *OfpTableMod) GetConfig() uint32  { return (*openflow_13.OfpTableMod)(m).GetConfig() }
+
+// ofp_port from public import openflow_13.proto
+type OfpPort openflow_13.OfpPort
+
+func (m *OfpPort) Reset()                { (*openflow_13.OfpPort)(m).Reset() }
+func (m *OfpPort) String() string        { return (*openflow_13.OfpPort)(m).String() }
+func (*OfpPort) ProtoMessage()           {}
+func (m *OfpPort) GetPortNo() uint32     { return (*openflow_13.OfpPort)(m).GetPortNo() }
+func (m *OfpPort) GetHwAddr() []uint32   { return (*openflow_13.OfpPort)(m).GetHwAddr() }
+func (m *OfpPort) GetName() string       { return (*openflow_13.OfpPort)(m).GetName() }
+func (m *OfpPort) GetConfig() uint32     { return (*openflow_13.OfpPort)(m).GetConfig() }
+func (m *OfpPort) GetState() uint32      { return (*openflow_13.OfpPort)(m).GetState() }
+func (m *OfpPort) GetCurr() uint32       { return (*openflow_13.OfpPort)(m).GetCurr() }
+func (m *OfpPort) GetAdvertised() uint32 { return (*openflow_13.OfpPort)(m).GetAdvertised() }
+func (m *OfpPort) GetSupported() uint32  { return (*openflow_13.OfpPort)(m).GetSupported() }
+func (m *OfpPort) GetPeer() uint32       { return (*openflow_13.OfpPort)(m).GetPeer() }
+func (m *OfpPort) GetCurrSpeed() uint32  { return (*openflow_13.OfpPort)(m).GetCurrSpeed() }
+func (m *OfpPort) GetMaxSpeed() uint32   { return (*openflow_13.OfpPort)(m).GetMaxSpeed() }
+
+// ofp_switch_features from public import openflow_13.proto
+type OfpSwitchFeatures openflow_13.OfpSwitchFeatures
+
+func (m *OfpSwitchFeatures) Reset()         { (*openflow_13.OfpSwitchFeatures)(m).Reset() }
+func (m *OfpSwitchFeatures) String() string { return (*openflow_13.OfpSwitchFeatures)(m).String() }
+func (*OfpSwitchFeatures) ProtoMessage()    {}
+func (m *OfpSwitchFeatures) GetDatapathId() uint64 {
+	return (*openflow_13.OfpSwitchFeatures)(m).GetDatapathId()
+}
+func (m *OfpSwitchFeatures) GetNBuffers() uint32 {
+	return (*openflow_13.OfpSwitchFeatures)(m).GetNBuffers()
+}
+func (m *OfpSwitchFeatures) GetNTables() uint32 {
+	return (*openflow_13.OfpSwitchFeatures)(m).GetNTables()
+}
+func (m *OfpSwitchFeatures) GetAuxiliaryId() uint32 {
+	return (*openflow_13.OfpSwitchFeatures)(m).GetAuxiliaryId()
+}
+func (m *OfpSwitchFeatures) GetCapabilities() uint32 {
+	return (*openflow_13.OfpSwitchFeatures)(m).GetCapabilities()
+}
+
+// ofp_port_status from public import openflow_13.proto
+type OfpPortStatus openflow_13.OfpPortStatus
+
+func (m *OfpPortStatus) Reset()         { (*openflow_13.OfpPortStatus)(m).Reset() }
+func (m *OfpPortStatus) String() string { return (*openflow_13.OfpPortStatus)(m).String() }
+func (*OfpPortStatus) ProtoMessage()    {}
+func (m *OfpPortStatus) GetReason() OfpPortReason {
+	return (OfpPortReason)((*openflow_13.OfpPortStatus)(m).GetReason())
+}
+func (m *OfpPortStatus) GetDesc() *OfpPort {
+	return (*OfpPort)((*openflow_13.OfpPortStatus)(m).GetDesc())
+}
+
+// ofp_port_mod from public import openflow_13.proto
+type OfpPortMod openflow_13.OfpPortMod
+
+func (m *OfpPortMod) Reset()               { (*openflow_13.OfpPortMod)(m).Reset() }
+func (m *OfpPortMod) String() string       { return (*openflow_13.OfpPortMod)(m).String() }
+func (*OfpPortMod) ProtoMessage()          {}
+func (m *OfpPortMod) GetPortNo() uint32    { return (*openflow_13.OfpPortMod)(m).GetPortNo() }
+func (m *OfpPortMod) GetHwAddr() []uint32  { return (*openflow_13.OfpPortMod)(m).GetHwAddr() }
+func (m *OfpPortMod) GetConfig() uint32    { return (*openflow_13.OfpPortMod)(m).GetConfig() }
+func (m *OfpPortMod) GetMask() uint32      { return (*openflow_13.OfpPortMod)(m).GetMask() }
+func (m *OfpPortMod) GetAdvertise() uint32 { return (*openflow_13.OfpPortMod)(m).GetAdvertise() }
+
+// ofp_match from public import openflow_13.proto
+type OfpMatch openflow_13.OfpMatch
+
+func (m *OfpMatch) Reset()                { (*openflow_13.OfpMatch)(m).Reset() }
+func (m *OfpMatch) String() string        { return (*openflow_13.OfpMatch)(m).String() }
+func (*OfpMatch) ProtoMessage()           {}
+func (m *OfpMatch) GetType() OfpMatchType { return (OfpMatchType)((*openflow_13.OfpMatch)(m).GetType()) }
+func (m *OfpMatch) GetOxmFields() []*OfpOxmField {
+	o := (*openflow_13.OfpMatch)(m).GetOxmFields()
+	if o == nil {
+		return nil
+	}
+	s := make([]*OfpOxmField, len(o))
+	for i, x := range o {
+		s[i] = (*OfpOxmField)(x)
+	}
+	return s
+}
+
+// ofp_oxm_field from public import openflow_13.proto
+type OfpOxmField openflow_13.OfpOxmField
+
+func (m *OfpOxmField) Reset()         { (*openflow_13.OfpOxmField)(m).Reset() }
+func (m *OfpOxmField) String() string { return (*openflow_13.OfpOxmField)(m).String() }
+func (*OfpOxmField) ProtoMessage()    {}
+func (m *OfpOxmField) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) int, []interface{}) {
+	return _OfpOxmField_OneofMarshaler, _OfpOxmField_OneofUnmarshaler, _OfpOxmField_OneofSizer, nil
+}
+func _OfpOxmField_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
+	m := msg.(*OfpOxmField)
+	m0 := (*openflow_13.OfpOxmField)(m)
+	enc, _, _, _ := m0.XXX_OneofFuncs()
+	return enc(m0, b)
+}
+func _OfpOxmField_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
+	m := msg.(*OfpOxmField)
+	m0 := (*openflow_13.OfpOxmField)(m)
+	_, dec, _, _ := m0.XXX_OneofFuncs()
+	return dec(m0, tag, wire, b)
+}
+func _OfpOxmField_OneofSizer(msg proto.Message) int {
+	m := msg.(*OfpOxmField)
+	m0 := (*openflow_13.OfpOxmField)(m)
+	_, _, size, _ := m0.XXX_OneofFuncs()
+	return size(m0)
+}
+func (m *OfpOxmField) GetOxmClass() OfpOxmClass {
+	return (OfpOxmClass)((*openflow_13.OfpOxmField)(m).GetOxmClass())
+}
+func (m *OfpOxmField) GetOfbField() *OfpOxmOfbField {
+	return (*OfpOxmOfbField)((*openflow_13.OfpOxmField)(m).GetOfbField())
+}
+func (m *OfpOxmField) GetExperimenterField() *OfpOxmExperimenterField {
+	return (*OfpOxmExperimenterField)((*openflow_13.OfpOxmField)(m).GetExperimenterField())
+}
+
+// ofp_oxm_ofb_field from public import openflow_13.proto
+type OfpOxmOfbField openflow_13.OfpOxmOfbField
+
+func (m *OfpOxmOfbField) Reset()         { (*openflow_13.OfpOxmOfbField)(m).Reset() }
+func (m *OfpOxmOfbField) String() string { return (*openflow_13.OfpOxmOfbField)(m).String() }
+func (*OfpOxmOfbField) ProtoMessage()    {}
+func (m *OfpOxmOfbField) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) int, []interface{}) {
+	return _OfpOxmOfbField_OneofMarshaler, _OfpOxmOfbField_OneofUnmarshaler, _OfpOxmOfbField_OneofSizer, nil
+}
+func _OfpOxmOfbField_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
+	m := msg.(*OfpOxmOfbField)
+	m0 := (*openflow_13.OfpOxmOfbField)(m)
+	enc, _, _, _ := m0.XXX_OneofFuncs()
+	return enc(m0, b)
+}
+func _OfpOxmOfbField_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
+	m := msg.(*OfpOxmOfbField)
+	m0 := (*openflow_13.OfpOxmOfbField)(m)
+	_, dec, _, _ := m0.XXX_OneofFuncs()
+	return dec(m0, tag, wire, b)
+}
+func _OfpOxmOfbField_OneofSizer(msg proto.Message) int {
+	m := msg.(*OfpOxmOfbField)
+	m0 := (*openflow_13.OfpOxmOfbField)(m)
+	_, _, size, _ := m0.XXX_OneofFuncs()
+	return size(m0)
+}
+func (m *OfpOxmOfbField) GetType() OxmOfbFieldTypes {
+	return (OxmOfbFieldTypes)((*openflow_13.OfpOxmOfbField)(m).GetType())
+}
+func (m *OfpOxmOfbField) GetHasMask() bool { return (*openflow_13.OfpOxmOfbField)(m).GetHasMask() }
+func (m *OfpOxmOfbField) GetPort() uint32  { return (*openflow_13.OfpOxmOfbField)(m).GetPort() }
+func (m *OfpOxmOfbField) GetPhysicalPort() uint32 {
+	return (*openflow_13.OfpOxmOfbField)(m).GetPhysicalPort()
+}
+func (m *OfpOxmOfbField) GetTableMetadata() uint64 {
+	return (*openflow_13.OfpOxmOfbField)(m).GetTableMetadata()
+}
+func (m *OfpOxmOfbField) GetEthDst() []byte  { return (*openflow_13.OfpOxmOfbField)(m).GetEthDst() }
+func (m *OfpOxmOfbField) GetEthSrc() []byte  { return (*openflow_13.OfpOxmOfbField)(m).GetEthSrc() }
+func (m *OfpOxmOfbField) GetEthType() uint32 { return (*openflow_13.OfpOxmOfbField)(m).GetEthType() }
+func (m *OfpOxmOfbField) GetVlanVid() uint32 { return (*openflow_13.OfpOxmOfbField)(m).GetVlanVid() }
+func (m *OfpOxmOfbField) GetVlanPcp() uint32 { return (*openflow_13.OfpOxmOfbField)(m).GetVlanPcp() }
+func (m *OfpOxmOfbField) GetIpDscp() uint32  { return (*openflow_13.OfpOxmOfbField)(m).GetIpDscp() }
+func (m *OfpOxmOfbField) GetIpEcn() uint32   { return (*openflow_13.OfpOxmOfbField)(m).GetIpEcn() }
+func (m *OfpOxmOfbField) GetIpProto() uint32 { return (*openflow_13.OfpOxmOfbField)(m).GetIpProto() }
+func (m *OfpOxmOfbField) GetIpv4Src() uint32 { return (*openflow_13.OfpOxmOfbField)(m).GetIpv4Src() }
+func (m *OfpOxmOfbField) GetIpv4Dst() uint32 { return (*openflow_13.OfpOxmOfbField)(m).GetIpv4Dst() }
+func (m *OfpOxmOfbField) GetTcpSrc() uint32  { return (*openflow_13.OfpOxmOfbField)(m).GetTcpSrc() }
+func (m *OfpOxmOfbField) GetTcpDst() uint32  { return (*openflow_13.OfpOxmOfbField)(m).GetTcpDst() }
+func (m *OfpOxmOfbField) GetUdpSrc() uint32  { return (*openflow_13.OfpOxmOfbField)(m).GetUdpSrc() }
+func (m *OfpOxmOfbField) GetUdpDst() uint32  { return (*openflow_13.OfpOxmOfbField)(m).GetUdpDst() }
+func (m *OfpOxmOfbField) GetSctpSrc() uint32 { return (*openflow_13.OfpOxmOfbField)(m).GetSctpSrc() }
+func (m *OfpOxmOfbField) GetSctpDst() uint32 { return (*openflow_13.OfpOxmOfbField)(m).GetSctpDst() }
+func (m *OfpOxmOfbField) GetIcmpv4Type() uint32 {
+	return (*openflow_13.OfpOxmOfbField)(m).GetIcmpv4Type()
+}
+func (m *OfpOxmOfbField) GetIcmpv4Code() uint32 {
+	return (*openflow_13.OfpOxmOfbField)(m).GetIcmpv4Code()
+}
+func (m *OfpOxmOfbField) GetArpOp() uint32   { return (*openflow_13.OfpOxmOfbField)(m).GetArpOp() }
+func (m *OfpOxmOfbField) GetArpSpa() uint32  { return (*openflow_13.OfpOxmOfbField)(m).GetArpSpa() }
+func (m *OfpOxmOfbField) GetArpTpa() uint32  { return (*openflow_13.OfpOxmOfbField)(m).GetArpTpa() }
+func (m *OfpOxmOfbField) GetArpSha() []byte  { return (*openflow_13.OfpOxmOfbField)(m).GetArpSha() }
+func (m *OfpOxmOfbField) GetArpTha() []byte  { return (*openflow_13.OfpOxmOfbField)(m).GetArpTha() }
+func (m *OfpOxmOfbField) GetIpv6Src() []byte { return (*openflow_13.OfpOxmOfbField)(m).GetIpv6Src() }
+func (m *OfpOxmOfbField) GetIpv6Dst() []byte { return (*openflow_13.OfpOxmOfbField)(m).GetIpv6Dst() }
+func (m *OfpOxmOfbField) GetIpv6Flabel() uint32 {
+	return (*openflow_13.OfpOxmOfbField)(m).GetIpv6Flabel()
+}
+func (m *OfpOxmOfbField) GetIcmpv6Type() uint32 {
+	return (*openflow_13.OfpOxmOfbField)(m).GetIcmpv6Type()
+}
+func (m *OfpOxmOfbField) GetIcmpv6Code() uint32 {
+	return (*openflow_13.OfpOxmOfbField)(m).GetIcmpv6Code()
+}
+func (m *OfpOxmOfbField) GetIpv6NdTarget() []byte {
+	return (*openflow_13.OfpOxmOfbField)(m).GetIpv6NdTarget()
+}
+func (m *OfpOxmOfbField) GetIpv6NdSsl() []byte { return (*openflow_13.OfpOxmOfbField)(m).GetIpv6NdSsl() }
+func (m *OfpOxmOfbField) GetIpv6NdTll() []byte { return (*openflow_13.OfpOxmOfbField)(m).GetIpv6NdTll() }
+func (m *OfpOxmOfbField) GetMplsLabel() uint32 { return (*openflow_13.OfpOxmOfbField)(m).GetMplsLabel() }
+func (m *OfpOxmOfbField) GetMplsTc() uint32    { return (*openflow_13.OfpOxmOfbField)(m).GetMplsTc() }
+func (m *OfpOxmOfbField) GetMplsBos() uint32   { return (*openflow_13.OfpOxmOfbField)(m).GetMplsBos() }
+func (m *OfpOxmOfbField) GetPbbIsid() uint32   { return (*openflow_13.OfpOxmOfbField)(m).GetPbbIsid() }
+func (m *OfpOxmOfbField) GetTunnelId() uint64  { return (*openflow_13.OfpOxmOfbField)(m).GetTunnelId() }
+func (m *OfpOxmOfbField) GetIpv6Exthdr() uint32 {
+	return (*openflow_13.OfpOxmOfbField)(m).GetIpv6Exthdr()
+}
+func (m *OfpOxmOfbField) GetTableMetadataMask() uint64 {
+	return (*openflow_13.OfpOxmOfbField)(m).GetTableMetadataMask()
+}
+func (m *OfpOxmOfbField) GetEthDstMask() []byte {
+	return (*openflow_13.OfpOxmOfbField)(m).GetEthDstMask()
+}
+func (m *OfpOxmOfbField) GetEthSrcMask() []byte {
+	return (*openflow_13.OfpOxmOfbField)(m).GetEthSrcMask()
+}
+func (m *OfpOxmOfbField) GetVlanVidMask() uint32 {
+	return (*openflow_13.OfpOxmOfbField)(m).GetVlanVidMask()
+}
+func (m *OfpOxmOfbField) GetIpv4SrcMask() uint32 {
+	return (*openflow_13.OfpOxmOfbField)(m).GetIpv4SrcMask()
+}
+func (m *OfpOxmOfbField) GetIpv4DstMask() uint32 {
+	return (*openflow_13.OfpOxmOfbField)(m).GetIpv4DstMask()
+}
+func (m *OfpOxmOfbField) GetArpSpaMask() uint32 {
+	return (*openflow_13.OfpOxmOfbField)(m).GetArpSpaMask()
+}
+func (m *OfpOxmOfbField) GetArpTpaMask() uint32 {
+	return (*openflow_13.OfpOxmOfbField)(m).GetArpTpaMask()
+}
+func (m *OfpOxmOfbField) GetIpv6SrcMask() []byte {
+	return (*openflow_13.OfpOxmOfbField)(m).GetIpv6SrcMask()
+}
+func (m *OfpOxmOfbField) GetIpv6DstMask() []byte {
+	return (*openflow_13.OfpOxmOfbField)(m).GetIpv6DstMask()
+}
+func (m *OfpOxmOfbField) GetIpv6FlabelMask() uint32 {
+	return (*openflow_13.OfpOxmOfbField)(m).GetIpv6FlabelMask()
+}
+func (m *OfpOxmOfbField) GetPbbIsidMask() uint32 {
+	return (*openflow_13.OfpOxmOfbField)(m).GetPbbIsidMask()
+}
+func (m *OfpOxmOfbField) GetTunnelIdMask() uint64 {
+	return (*openflow_13.OfpOxmOfbField)(m).GetTunnelIdMask()
+}
+func (m *OfpOxmOfbField) GetIpv6ExthdrMask() uint32 {
+	return (*openflow_13.OfpOxmOfbField)(m).GetIpv6ExthdrMask()
+}
+
+// ofp_oxm_experimenter_field from public import openflow_13.proto
+type OfpOxmExperimenterField openflow_13.OfpOxmExperimenterField
+
+func (m *OfpOxmExperimenterField) Reset() { (*openflow_13.OfpOxmExperimenterField)(m).Reset() }
+func (m *OfpOxmExperimenterField) String() string {
+	return (*openflow_13.OfpOxmExperimenterField)(m).String()
+}
+func (*OfpOxmExperimenterField) ProtoMessage() {}
+func (m *OfpOxmExperimenterField) GetOxmHeader() uint32 {
+	return (*openflow_13.OfpOxmExperimenterField)(m).GetOxmHeader()
+}
+func (m *OfpOxmExperimenterField) GetExperimenter() uint32 {
+	return (*openflow_13.OfpOxmExperimenterField)(m).GetExperimenter()
+}
+
+// ofp_action from public import openflow_13.proto
+type OfpAction openflow_13.OfpAction
+
+func (m *OfpAction) Reset()         { (*openflow_13.OfpAction)(m).Reset() }
+func (m *OfpAction) String() string { return (*openflow_13.OfpAction)(m).String() }
+func (*OfpAction) ProtoMessage()    {}
+func (m *OfpAction) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) int, []interface{}) {
+	return _OfpAction_OneofMarshaler, _OfpAction_OneofUnmarshaler, _OfpAction_OneofSizer, nil
+}
+func _OfpAction_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
+	m := msg.(*OfpAction)
+	m0 := (*openflow_13.OfpAction)(m)
+	enc, _, _, _ := m0.XXX_OneofFuncs()
+	return enc(m0, b)
+}
+func _OfpAction_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
+	m := msg.(*OfpAction)
+	m0 := (*openflow_13.OfpAction)(m)
+	_, dec, _, _ := m0.XXX_OneofFuncs()
+	return dec(m0, tag, wire, b)
+}
+func _OfpAction_OneofSizer(msg proto.Message) int {
+	m := msg.(*OfpAction)
+	m0 := (*openflow_13.OfpAction)(m)
+	_, _, size, _ := m0.XXX_OneofFuncs()
+	return size(m0)
+}
+func (m *OfpAction) GetType() OfpActionType {
+	return (OfpActionType)((*openflow_13.OfpAction)(m).GetType())
+}
+func (m *OfpAction) GetOutput() *OfpActionOutput {
+	return (*OfpActionOutput)((*openflow_13.OfpAction)(m).GetOutput())
+}
+func (m *OfpAction) GetMplsTtl() *OfpActionMplsTtl {
+	return (*OfpActionMplsTtl)((*openflow_13.OfpAction)(m).GetMplsTtl())
+}
+func (m *OfpAction) GetPush() *OfpActionPush {
+	return (*OfpActionPush)((*openflow_13.OfpAction)(m).GetPush())
+}
+func (m *OfpAction) GetPopMpls() *OfpActionPopMpls {
+	return (*OfpActionPopMpls)((*openflow_13.OfpAction)(m).GetPopMpls())
+}
+func (m *OfpAction) GetGroup() *OfpActionGroup {
+	return (*OfpActionGroup)((*openflow_13.OfpAction)(m).GetGroup())
+}
+func (m *OfpAction) GetNwTtl() *OfpActionNwTtl {
+	return (*OfpActionNwTtl)((*openflow_13.OfpAction)(m).GetNwTtl())
+}
+func (m *OfpAction) GetSetField() *OfpActionSetField {
+	return (*OfpActionSetField)((*openflow_13.OfpAction)(m).GetSetField())
+}
+func (m *OfpAction) GetExperimenter() *OfpActionExperimenter {
+	return (*OfpActionExperimenter)((*openflow_13.OfpAction)(m).GetExperimenter())
+}
+
+// ofp_action_output from public import openflow_13.proto
+type OfpActionOutput openflow_13.OfpActionOutput
+
+func (m *OfpActionOutput) Reset()            { (*openflow_13.OfpActionOutput)(m).Reset() }
+func (m *OfpActionOutput) String() string    { return (*openflow_13.OfpActionOutput)(m).String() }
+func (*OfpActionOutput) ProtoMessage()       {}
+func (m *OfpActionOutput) GetPort() uint32   { return (*openflow_13.OfpActionOutput)(m).GetPort() }
+func (m *OfpActionOutput) GetMaxLen() uint32 { return (*openflow_13.OfpActionOutput)(m).GetMaxLen() }
+
+// ofp_action_mpls_ttl from public import openflow_13.proto
+type OfpActionMplsTtl openflow_13.OfpActionMplsTtl
+
+func (m *OfpActionMplsTtl) Reset()             { (*openflow_13.OfpActionMplsTtl)(m).Reset() }
+func (m *OfpActionMplsTtl) String() string     { return (*openflow_13.OfpActionMplsTtl)(m).String() }
+func (*OfpActionMplsTtl) ProtoMessage()        {}
+func (m *OfpActionMplsTtl) GetMplsTtl() uint32 { return (*openflow_13.OfpActionMplsTtl)(m).GetMplsTtl() }
+
+// ofp_action_push from public import openflow_13.proto
+type OfpActionPush openflow_13.OfpActionPush
+
+func (m *OfpActionPush) Reset()               { (*openflow_13.OfpActionPush)(m).Reset() }
+func (m *OfpActionPush) String() string       { return (*openflow_13.OfpActionPush)(m).String() }
+func (*OfpActionPush) ProtoMessage()          {}
+func (m *OfpActionPush) GetEthertype() uint32 { return (*openflow_13.OfpActionPush)(m).GetEthertype() }
+
+// ofp_action_pop_mpls from public import openflow_13.proto
+type OfpActionPopMpls openflow_13.OfpActionPopMpls
+
+func (m *OfpActionPopMpls) Reset()         { (*openflow_13.OfpActionPopMpls)(m).Reset() }
+func (m *OfpActionPopMpls) String() string { return (*openflow_13.OfpActionPopMpls)(m).String() }
+func (*OfpActionPopMpls) ProtoMessage()    {}
+func (m *OfpActionPopMpls) GetEthertype() uint32 {
+	return (*openflow_13.OfpActionPopMpls)(m).GetEthertype()
+}
+
+// ofp_action_group from public import openflow_13.proto
+type OfpActionGroup openflow_13.OfpActionGroup
+
+func (m *OfpActionGroup) Reset()             { (*openflow_13.OfpActionGroup)(m).Reset() }
+func (m *OfpActionGroup) String() string     { return (*openflow_13.OfpActionGroup)(m).String() }
+func (*OfpActionGroup) ProtoMessage()        {}
+func (m *OfpActionGroup) GetGroupId() uint32 { return (*openflow_13.OfpActionGroup)(m).GetGroupId() }
+
+// ofp_action_nw_ttl from public import openflow_13.proto
+type OfpActionNwTtl openflow_13.OfpActionNwTtl
+
+func (m *OfpActionNwTtl) Reset()           { (*openflow_13.OfpActionNwTtl)(m).Reset() }
+func (m *OfpActionNwTtl) String() string   { return (*openflow_13.OfpActionNwTtl)(m).String() }
+func (*OfpActionNwTtl) ProtoMessage()      {}
+func (m *OfpActionNwTtl) GetNwTtl() uint32 { return (*openflow_13.OfpActionNwTtl)(m).GetNwTtl() }
+
+// ofp_action_set_field from public import openflow_13.proto
+type OfpActionSetField openflow_13.OfpActionSetField
+
+func (m *OfpActionSetField) Reset()         { (*openflow_13.OfpActionSetField)(m).Reset() }
+func (m *OfpActionSetField) String() string { return (*openflow_13.OfpActionSetField)(m).String() }
+func (*OfpActionSetField) ProtoMessage()    {}
+func (m *OfpActionSetField) GetField() *OfpOxmField {
+	return (*OfpOxmField)((*openflow_13.OfpActionSetField)(m).GetField())
+}
+
+// ofp_action_experimenter from public import openflow_13.proto
+type OfpActionExperimenter openflow_13.OfpActionExperimenter
+
+func (m *OfpActionExperimenter) Reset() { (*openflow_13.OfpActionExperimenter)(m).Reset() }
+func (m *OfpActionExperimenter) String() string {
+	return (*openflow_13.OfpActionExperimenter)(m).String()
+}
+func (*OfpActionExperimenter) ProtoMessage() {}
+func (m *OfpActionExperimenter) GetExperimenter() uint32 {
+	return (*openflow_13.OfpActionExperimenter)(m).GetExperimenter()
+}
+func (m *OfpActionExperimenter) GetData() []byte {
+	return (*openflow_13.OfpActionExperimenter)(m).GetData()
+}
+
+// ofp_instruction from public import openflow_13.proto
+type OfpInstruction openflow_13.OfpInstruction
+
+func (m *OfpInstruction) Reset()         { (*openflow_13.OfpInstruction)(m).Reset() }
+func (m *OfpInstruction) String() string { return (*openflow_13.OfpInstruction)(m).String() }
+func (*OfpInstruction) ProtoMessage()    {}
+func (m *OfpInstruction) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) int, []interface{}) {
+	return _OfpInstruction_OneofMarshaler, _OfpInstruction_OneofUnmarshaler, _OfpInstruction_OneofSizer, nil
+}
+func _OfpInstruction_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
+	m := msg.(*OfpInstruction)
+	m0 := (*openflow_13.OfpInstruction)(m)
+	enc, _, _, _ := m0.XXX_OneofFuncs()
+	return enc(m0, b)
+}
+func _OfpInstruction_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
+	m := msg.(*OfpInstruction)
+	m0 := (*openflow_13.OfpInstruction)(m)
+	_, dec, _, _ := m0.XXX_OneofFuncs()
+	return dec(m0, tag, wire, b)
+}
+func _OfpInstruction_OneofSizer(msg proto.Message) int {
+	m := msg.(*OfpInstruction)
+	m0 := (*openflow_13.OfpInstruction)(m)
+	_, _, size, _ := m0.XXX_OneofFuncs()
+	return size(m0)
+}
+func (m *OfpInstruction) GetType() uint32 { return (*openflow_13.OfpInstruction)(m).GetType() }
+func (m *OfpInstruction) GetGotoTable() *OfpInstructionGotoTable {
+	return (*OfpInstructionGotoTable)((*openflow_13.OfpInstruction)(m).GetGotoTable())
+}
+func (m *OfpInstruction) GetWriteMetadata() *OfpInstructionWriteMetadata {
+	return (*OfpInstructionWriteMetadata)((*openflow_13.OfpInstruction)(m).GetWriteMetadata())
+}
+func (m *OfpInstruction) GetActions() *OfpInstructionActions {
+	return (*OfpInstructionActions)((*openflow_13.OfpInstruction)(m).GetActions())
+}
+func (m *OfpInstruction) GetMeter() *OfpInstructionMeter {
+	return (*OfpInstructionMeter)((*openflow_13.OfpInstruction)(m).GetMeter())
+}
+func (m *OfpInstruction) GetExperimenter() *OfpInstructionExperimenter {
+	return (*OfpInstructionExperimenter)((*openflow_13.OfpInstruction)(m).GetExperimenter())
+}
+
+// ofp_instruction_goto_table from public import openflow_13.proto
+type OfpInstructionGotoTable openflow_13.OfpInstructionGotoTable
+
+func (m *OfpInstructionGotoTable) Reset() { (*openflow_13.OfpInstructionGotoTable)(m).Reset() }
+func (m *OfpInstructionGotoTable) String() string {
+	return (*openflow_13.OfpInstructionGotoTable)(m).String()
+}
+func (*OfpInstructionGotoTable) ProtoMessage() {}
+func (m *OfpInstructionGotoTable) GetTableId() uint32 {
+	return (*openflow_13.OfpInstructionGotoTable)(m).GetTableId()
+}
+
+// ofp_instruction_write_metadata from public import openflow_13.proto
+type OfpInstructionWriteMetadata openflow_13.OfpInstructionWriteMetadata
+
+func (m *OfpInstructionWriteMetadata) Reset() { (*openflow_13.OfpInstructionWriteMetadata)(m).Reset() }
+func (m *OfpInstructionWriteMetadata) String() string {
+	return (*openflow_13.OfpInstructionWriteMetadata)(m).String()
+}
+func (*OfpInstructionWriteMetadata) ProtoMessage() {}
+func (m *OfpInstructionWriteMetadata) GetMetadata() uint64 {
+	return (*openflow_13.OfpInstructionWriteMetadata)(m).GetMetadata()
+}
+func (m *OfpInstructionWriteMetadata) GetMetadataMask() uint64 {
+	return (*openflow_13.OfpInstructionWriteMetadata)(m).GetMetadataMask()
+}
+
+// ofp_instruction_actions from public import openflow_13.proto
+type OfpInstructionActions openflow_13.OfpInstructionActions
+
+func (m *OfpInstructionActions) Reset() { (*openflow_13.OfpInstructionActions)(m).Reset() }
+func (m *OfpInstructionActions) String() string {
+	return (*openflow_13.OfpInstructionActions)(m).String()
+}
+func (*OfpInstructionActions) ProtoMessage() {}
+func (m *OfpInstructionActions) GetActions() []*OfpAction {
+	o := (*openflow_13.OfpInstructionActions)(m).GetActions()
+	if o == nil {
+		return nil
+	}
+	s := make([]*OfpAction, len(o))
+	for i, x := range o {
+		s[i] = (*OfpAction)(x)
+	}
+	return s
+}
+
+// ofp_instruction_meter from public import openflow_13.proto
+type OfpInstructionMeter openflow_13.OfpInstructionMeter
+
+func (m *OfpInstructionMeter) Reset()         { (*openflow_13.OfpInstructionMeter)(m).Reset() }
+func (m *OfpInstructionMeter) String() string { return (*openflow_13.OfpInstructionMeter)(m).String() }
+func (*OfpInstructionMeter) ProtoMessage()    {}
+func (m *OfpInstructionMeter) GetMeterId() uint32 {
+	return (*openflow_13.OfpInstructionMeter)(m).GetMeterId()
+}
+
+// ofp_instruction_experimenter from public import openflow_13.proto
+type OfpInstructionExperimenter openflow_13.OfpInstructionExperimenter
+
+func (m *OfpInstructionExperimenter) Reset() { (*openflow_13.OfpInstructionExperimenter)(m).Reset() }
+func (m *OfpInstructionExperimenter) String() string {
+	return (*openflow_13.OfpInstructionExperimenter)(m).String()
+}
+func (*OfpInstructionExperimenter) ProtoMessage() {}
+func (m *OfpInstructionExperimenter) GetExperimenter() uint32 {
+	return (*openflow_13.OfpInstructionExperimenter)(m).GetExperimenter()
+}
+func (m *OfpInstructionExperimenter) GetData() []byte {
+	return (*openflow_13.OfpInstructionExperimenter)(m).GetData()
+}
+
+// ofp_flow_mod from public import openflow_13.proto
+type OfpFlowMod openflow_13.OfpFlowMod
+
+func (m *OfpFlowMod) Reset()                { (*openflow_13.OfpFlowMod)(m).Reset() }
+func (m *OfpFlowMod) String() string        { return (*openflow_13.OfpFlowMod)(m).String() }
+func (*OfpFlowMod) ProtoMessage()           {}
+func (m *OfpFlowMod) GetCookie() uint64     { return (*openflow_13.OfpFlowMod)(m).GetCookie() }
+func (m *OfpFlowMod) GetCookieMask() uint64 { return (*openflow_13.OfpFlowMod)(m).GetCookieMask() }
+func (m *OfpFlowMod) GetTableId() uint32    { return (*openflow_13.OfpFlowMod)(m).GetTableId() }
+func (m *OfpFlowMod) GetCommand() OfpFlowModCommand {
+	return (OfpFlowModCommand)((*openflow_13.OfpFlowMod)(m).GetCommand())
+}
+func (m *OfpFlowMod) GetIdleTimeout() uint32 { return (*openflow_13.OfpFlowMod)(m).GetIdleTimeout() }
+func (m *OfpFlowMod) GetHardTimeout() uint32 { return (*openflow_13.OfpFlowMod)(m).GetHardTimeout() }
+func (m *OfpFlowMod) GetPriority() uint32    { return (*openflow_13.OfpFlowMod)(m).GetPriority() }
+func (m *OfpFlowMod) GetBufferId() uint32    { return (*openflow_13.OfpFlowMod)(m).GetBufferId() }
+func (m *OfpFlowMod) GetOutPort() uint32     { return (*openflow_13.OfpFlowMod)(m).GetOutPort() }
+func (m *OfpFlowMod) GetOutGroup() uint32    { return (*openflow_13.OfpFlowMod)(m).GetOutGroup() }
+func (m *OfpFlowMod) GetFlags() uint32       { return (*openflow_13.OfpFlowMod)(m).GetFlags() }
+func (m *OfpFlowMod) GetMatch() *OfpMatch    { return (*OfpMatch)((*openflow_13.OfpFlowMod)(m).GetMatch()) }
+func (m *OfpFlowMod) GetInstructions() []*OfpInstruction {
+	o := (*openflow_13.OfpFlowMod)(m).GetInstructions()
+	if o == nil {
+		return nil
+	}
+	s := make([]*OfpInstruction, len(o))
+	for i, x := range o {
+		s[i] = (*OfpInstruction)(x)
+	}
+	return s
+}
+
+// ofp_bucket from public import openflow_13.proto
+type OfpBucket openflow_13.OfpBucket
+
+func (m *OfpBucket) Reset()                { (*openflow_13.OfpBucket)(m).Reset() }
+func (m *OfpBucket) String() string        { return (*openflow_13.OfpBucket)(m).String() }
+func (*OfpBucket) ProtoMessage()           {}
+func (m *OfpBucket) GetWeight() uint32     { return (*openflow_13.OfpBucket)(m).GetWeight() }
+func (m *OfpBucket) GetWatchPort() uint32  { return (*openflow_13.OfpBucket)(m).GetWatchPort() }
+func (m *OfpBucket) GetWatchGroup() uint32 { return (*openflow_13.OfpBucket)(m).GetWatchGroup() }
+func (m *OfpBucket) GetActions() []*OfpAction {
+	o := (*openflow_13.OfpBucket)(m).GetActions()
+	if o == nil {
+		return nil
+	}
+	s := make([]*OfpAction, len(o))
+	for i, x := range o {
+		s[i] = (*OfpAction)(x)
+	}
+	return s
+}
+
+// ofp_group_mod from public import openflow_13.proto
+type OfpGroupMod openflow_13.OfpGroupMod
+
+func (m *OfpGroupMod) Reset()         { (*openflow_13.OfpGroupMod)(m).Reset() }
+func (m *OfpGroupMod) String() string { return (*openflow_13.OfpGroupMod)(m).String() }
+func (*OfpGroupMod) ProtoMessage()    {}
+func (m *OfpGroupMod) GetCommand() OfpGroupModCommand {
+	return (OfpGroupModCommand)((*openflow_13.OfpGroupMod)(m).GetCommand())
+}
+func (m *OfpGroupMod) GetType() OfpGroupType {
+	return (OfpGroupType)((*openflow_13.OfpGroupMod)(m).GetType())
+}
+func (m *OfpGroupMod) GetGroupId() uint32 { return (*openflow_13.OfpGroupMod)(m).GetGroupId() }
+func (m *OfpGroupMod) GetBuckets() []*OfpBucket {
+	o := (*openflow_13.OfpGroupMod)(m).GetBuckets()
+	if o == nil {
+		return nil
+	}
+	s := make([]*OfpBucket, len(o))
+	for i, x := range o {
+		s[i] = (*OfpBucket)(x)
+	}
+	return s
+}
+
+// ofp_packet_out from public import openflow_13.proto
+type OfpPacketOut openflow_13.OfpPacketOut
+
+func (m *OfpPacketOut) Reset()              { (*openflow_13.OfpPacketOut)(m).Reset() }
+func (m *OfpPacketOut) String() string      { return (*openflow_13.OfpPacketOut)(m).String() }
+func (*OfpPacketOut) ProtoMessage()         {}
+func (m *OfpPacketOut) GetBufferId() uint32 { return (*openflow_13.OfpPacketOut)(m).GetBufferId() }
+func (m *OfpPacketOut) GetInPort() uint32   { return (*openflow_13.OfpPacketOut)(m).GetInPort() }
+func (m *OfpPacketOut) GetActions() []*OfpAction {
+	o := (*openflow_13.OfpPacketOut)(m).GetActions()
+	if o == nil {
+		return nil
+	}
+	s := make([]*OfpAction, len(o))
+	for i, x := range o {
+		s[i] = (*OfpAction)(x)
+	}
+	return s
+}
+func (m *OfpPacketOut) GetData() []byte { return (*openflow_13.OfpPacketOut)(m).GetData() }
+
+// ofp_packet_in from public import openflow_13.proto
+type OfpPacketIn openflow_13.OfpPacketIn
+
+func (m *OfpPacketIn) Reset()              { (*openflow_13.OfpPacketIn)(m).Reset() }
+func (m *OfpPacketIn) String() string      { return (*openflow_13.OfpPacketIn)(m).String() }
+func (*OfpPacketIn) ProtoMessage()         {}
+func (m *OfpPacketIn) GetBufferId() uint32 { return (*openflow_13.OfpPacketIn)(m).GetBufferId() }
+func (m *OfpPacketIn) GetReason() OfpPacketInReason {
+	return (OfpPacketInReason)((*openflow_13.OfpPacketIn)(m).GetReason())
+}
+func (m *OfpPacketIn) GetTableId() uint32 { return (*openflow_13.OfpPacketIn)(m).GetTableId() }
+func (m *OfpPacketIn) GetCookie() uint64  { return (*openflow_13.OfpPacketIn)(m).GetCookie() }
+func (m *OfpPacketIn) GetMatch() *OfpMatch {
+	return (*OfpMatch)((*openflow_13.OfpPacketIn)(m).GetMatch())
+}
+func (m *OfpPacketIn) GetData() []byte { return (*openflow_13.OfpPacketIn)(m).GetData() }
+
+// ofp_flow_removed from public import openflow_13.proto
+type OfpFlowRemoved openflow_13.OfpFlowRemoved
+
+func (m *OfpFlowRemoved) Reset()              { (*openflow_13.OfpFlowRemoved)(m).Reset() }
+func (m *OfpFlowRemoved) String() string      { return (*openflow_13.OfpFlowRemoved)(m).String() }
+func (*OfpFlowRemoved) ProtoMessage()         {}
+func (m *OfpFlowRemoved) GetCookie() uint64   { return (*openflow_13.OfpFlowRemoved)(m).GetCookie() }
+func (m *OfpFlowRemoved) GetPriority() uint32 { return (*openflow_13.OfpFlowRemoved)(m).GetPriority() }
+func (m *OfpFlowRemoved) GetReason() OfpFlowRemovedReason {
+	return (OfpFlowRemovedReason)((*openflow_13.OfpFlowRemoved)(m).GetReason())
+}
+func (m *OfpFlowRemoved) GetTableId() uint32 { return (*openflow_13.OfpFlowRemoved)(m).GetTableId() }
+func (m *OfpFlowRemoved) GetDurationSec() uint32 {
+	return (*openflow_13.OfpFlowRemoved)(m).GetDurationSec()
+}
+func (m *OfpFlowRemoved) GetDurationNsec() uint32 {
+	return (*openflow_13.OfpFlowRemoved)(m).GetDurationNsec()
+}
+func (m *OfpFlowRemoved) GetIdleTimeout() uint32 {
+	return (*openflow_13.OfpFlowRemoved)(m).GetIdleTimeout()
+}
+func (m *OfpFlowRemoved) GetHardTimeout() uint32 {
+	return (*openflow_13.OfpFlowRemoved)(m).GetHardTimeout()
+}
+func (m *OfpFlowRemoved) GetPacketCount() uint64 {
+	return (*openflow_13.OfpFlowRemoved)(m).GetPacketCount()
+}
+func (m *OfpFlowRemoved) GetByteCount() uint64 { return (*openflow_13.OfpFlowRemoved)(m).GetByteCount() }
+func (m *OfpFlowRemoved) GetMatch() *OfpMatch {
+	return (*OfpMatch)((*openflow_13.OfpFlowRemoved)(m).GetMatch())
+}
+
+// ofp_meter_band_header from public import openflow_13.proto
+type OfpMeterBandHeader openflow_13.OfpMeterBandHeader
+
+func (m *OfpMeterBandHeader) Reset()         { (*openflow_13.OfpMeterBandHeader)(m).Reset() }
+func (m *OfpMeterBandHeader) String() string { return (*openflow_13.OfpMeterBandHeader)(m).String() }
+func (*OfpMeterBandHeader) ProtoMessage()    {}
+func (m *OfpMeterBandHeader) GetType() OfpMeterBandType {
+	return (OfpMeterBandType)((*openflow_13.OfpMeterBandHeader)(m).GetType())
+}
+func (m *OfpMeterBandHeader) GetLen() uint32  { return (*openflow_13.OfpMeterBandHeader)(m).GetLen() }
+func (m *OfpMeterBandHeader) GetRate() uint32 { return (*openflow_13.OfpMeterBandHeader)(m).GetRate() }
+func (m *OfpMeterBandHeader) GetBurstSize() uint32 {
+	return (*openflow_13.OfpMeterBandHeader)(m).GetBurstSize()
+}
+
+// ofp_meter_band_drop from public import openflow_13.proto
+type OfpMeterBandDrop openflow_13.OfpMeterBandDrop
+
+func (m *OfpMeterBandDrop) Reset()          { (*openflow_13.OfpMeterBandDrop)(m).Reset() }
+func (m *OfpMeterBandDrop) String() string  { return (*openflow_13.OfpMeterBandDrop)(m).String() }
+func (*OfpMeterBandDrop) ProtoMessage()     {}
+func (m *OfpMeterBandDrop) GetType() uint32 { return (*openflow_13.OfpMeterBandDrop)(m).GetType() }
+func (m *OfpMeterBandDrop) GetLen() uint32  { return (*openflow_13.OfpMeterBandDrop)(m).GetLen() }
+func (m *OfpMeterBandDrop) GetRate() uint32 { return (*openflow_13.OfpMeterBandDrop)(m).GetRate() }
+func (m *OfpMeterBandDrop) GetBurstSize() uint32 {
+	return (*openflow_13.OfpMeterBandDrop)(m).GetBurstSize()
+}
+
+// ofp_meter_band_dscp_remark from public import openflow_13.proto
+type OfpMeterBandDscpRemark openflow_13.OfpMeterBandDscpRemark
+
+func (m *OfpMeterBandDscpRemark) Reset() { (*openflow_13.OfpMeterBandDscpRemark)(m).Reset() }
+func (m *OfpMeterBandDscpRemark) String() string {
+	return (*openflow_13.OfpMeterBandDscpRemark)(m).String()
+}
+func (*OfpMeterBandDscpRemark) ProtoMessage() {}
+func (m *OfpMeterBandDscpRemark) GetType() uint32 {
+	return (*openflow_13.OfpMeterBandDscpRemark)(m).GetType()
+}
+func (m *OfpMeterBandDscpRemark) GetLen() uint32 {
+	return (*openflow_13.OfpMeterBandDscpRemark)(m).GetLen()
+}
+func (m *OfpMeterBandDscpRemark) GetRate() uint32 {
+	return (*openflow_13.OfpMeterBandDscpRemark)(m).GetRate()
+}
+func (m *OfpMeterBandDscpRemark) GetBurstSize() uint32 {
+	return (*openflow_13.OfpMeterBandDscpRemark)(m).GetBurstSize()
+}
+func (m *OfpMeterBandDscpRemark) GetPrecLevel() uint32 {
+	return (*openflow_13.OfpMeterBandDscpRemark)(m).GetPrecLevel()
+}
+
+// ofp_meter_band_experimenter from public import openflow_13.proto
+type OfpMeterBandExperimenter openflow_13.OfpMeterBandExperimenter
+
+func (m *OfpMeterBandExperimenter) Reset() { (*openflow_13.OfpMeterBandExperimenter)(m).Reset() }
+func (m *OfpMeterBandExperimenter) String() string {
+	return (*openflow_13.OfpMeterBandExperimenter)(m).String()
+}
+func (*OfpMeterBandExperimenter) ProtoMessage() {}
+func (m *OfpMeterBandExperimenter) GetType() OfpMeterBandType {
+	return (OfpMeterBandType)((*openflow_13.OfpMeterBandExperimenter)(m).GetType())
+}
+func (m *OfpMeterBandExperimenter) GetLen() uint32 {
+	return (*openflow_13.OfpMeterBandExperimenter)(m).GetLen()
+}
+func (m *OfpMeterBandExperimenter) GetRate() uint32 {
+	return (*openflow_13.OfpMeterBandExperimenter)(m).GetRate()
+}
+func (m *OfpMeterBandExperimenter) GetBurstSize() uint32 {
+	return (*openflow_13.OfpMeterBandExperimenter)(m).GetBurstSize()
+}
+func (m *OfpMeterBandExperimenter) GetExperimenter() uint32 {
+	return (*openflow_13.OfpMeterBandExperimenter)(m).GetExperimenter()
+}
+
+// ofp_meter_mod from public import openflow_13.proto
+type OfpMeterMod openflow_13.OfpMeterMod
+
+func (m *OfpMeterMod) Reset()         { (*openflow_13.OfpMeterMod)(m).Reset() }
+func (m *OfpMeterMod) String() string { return (*openflow_13.OfpMeterMod)(m).String() }
+func (*OfpMeterMod) ProtoMessage()    {}
+func (m *OfpMeterMod) GetCommand() OfpMeterModCommand {
+	return (OfpMeterModCommand)((*openflow_13.OfpMeterMod)(m).GetCommand())
+}
+func (m *OfpMeterMod) GetFlags() uint32   { return (*openflow_13.OfpMeterMod)(m).GetFlags() }
+func (m *OfpMeterMod) GetMeterId() uint32 { return (*openflow_13.OfpMeterMod)(m).GetMeterId() }
+func (m *OfpMeterMod) GetBands() []*OfpMeterBandHeader {
+	o := (*openflow_13.OfpMeterMod)(m).GetBands()
+	if o == nil {
+		return nil
+	}
+	s := make([]*OfpMeterBandHeader, len(o))
+	for i, x := range o {
+		s[i] = (*OfpMeterBandHeader)(x)
+	}
+	return s
+}
+
+// ofp_error_msg from public import openflow_13.proto
+type OfpErrorMsg openflow_13.OfpErrorMsg
+
+func (m *OfpErrorMsg) Reset()          { (*openflow_13.OfpErrorMsg)(m).Reset() }
+func (m *OfpErrorMsg) String() string  { return (*openflow_13.OfpErrorMsg)(m).String() }
+func (*OfpErrorMsg) ProtoMessage()     {}
+func (m *OfpErrorMsg) GetType() uint32 { return (*openflow_13.OfpErrorMsg)(m).GetType() }
+func (m *OfpErrorMsg) GetCode() uint32 { return (*openflow_13.OfpErrorMsg)(m).GetCode() }
+func (m *OfpErrorMsg) GetData() []byte { return (*openflow_13.OfpErrorMsg)(m).GetData() }
+
+// ofp_error_experimenter_msg from public import openflow_13.proto
+type OfpErrorExperimenterMsg openflow_13.OfpErrorExperimenterMsg
+
+func (m *OfpErrorExperimenterMsg) Reset() { (*openflow_13.OfpErrorExperimenterMsg)(m).Reset() }
+func (m *OfpErrorExperimenterMsg) String() string {
+	return (*openflow_13.OfpErrorExperimenterMsg)(m).String()
+}
+func (*OfpErrorExperimenterMsg) ProtoMessage() {}
+func (m *OfpErrorExperimenterMsg) GetType() uint32 {
+	return (*openflow_13.OfpErrorExperimenterMsg)(m).GetType()
+}
+func (m *OfpErrorExperimenterMsg) GetExpType() uint32 {
+	return (*openflow_13.OfpErrorExperimenterMsg)(m).GetExpType()
+}
+func (m *OfpErrorExperimenterMsg) GetExperimenter() uint32 {
+	return (*openflow_13.OfpErrorExperimenterMsg)(m).GetExperimenter()
+}
+func (m *OfpErrorExperimenterMsg) GetData() []byte {
+	return (*openflow_13.OfpErrorExperimenterMsg)(m).GetData()
+}
+
+// ofp_multipart_request from public import openflow_13.proto
+type OfpMultipartRequest openflow_13.OfpMultipartRequest
+
+func (m *OfpMultipartRequest) Reset()         { (*openflow_13.OfpMultipartRequest)(m).Reset() }
+func (m *OfpMultipartRequest) String() string { return (*openflow_13.OfpMultipartRequest)(m).String() }
+func (*OfpMultipartRequest) ProtoMessage()    {}
+func (m *OfpMultipartRequest) GetType() OfpMultipartType {
+	return (OfpMultipartType)((*openflow_13.OfpMultipartRequest)(m).GetType())
+}
+func (m *OfpMultipartRequest) GetFlags() uint32 {
+	return (*openflow_13.OfpMultipartRequest)(m).GetFlags()
+}
+func (m *OfpMultipartRequest) GetBody() []byte { return (*openflow_13.OfpMultipartRequest)(m).GetBody() }
+
+// ofp_multipart_reply from public import openflow_13.proto
+type OfpMultipartReply openflow_13.OfpMultipartReply
+
+func (m *OfpMultipartReply) Reset()         { (*openflow_13.OfpMultipartReply)(m).Reset() }
+func (m *OfpMultipartReply) String() string { return (*openflow_13.OfpMultipartReply)(m).String() }
+func (*OfpMultipartReply) ProtoMessage()    {}
+func (m *OfpMultipartReply) GetType() OfpMultipartType {
+	return (OfpMultipartType)((*openflow_13.OfpMultipartReply)(m).GetType())
+}
+func (m *OfpMultipartReply) GetFlags() uint32 { return (*openflow_13.OfpMultipartReply)(m).GetFlags() }
+func (m *OfpMultipartReply) GetBody() []byte  { return (*openflow_13.OfpMultipartReply)(m).GetBody() }
+
+// ofp_desc from public import openflow_13.proto
+type OfpDesc openflow_13.OfpDesc
+
+func (m *OfpDesc) Reset()               { (*openflow_13.OfpDesc)(m).Reset() }
+func (m *OfpDesc) String() string       { return (*openflow_13.OfpDesc)(m).String() }
+func (*OfpDesc) ProtoMessage()          {}
+func (m *OfpDesc) GetMfrDesc() string   { return (*openflow_13.OfpDesc)(m).GetMfrDesc() }
+func (m *OfpDesc) GetHwDesc() string    { return (*openflow_13.OfpDesc)(m).GetHwDesc() }
+func (m *OfpDesc) GetSwDesc() string    { return (*openflow_13.OfpDesc)(m).GetSwDesc() }
+func (m *OfpDesc) GetSerialNum() string { return (*openflow_13.OfpDesc)(m).GetSerialNum() }
+func (m *OfpDesc) GetDpDesc() string    { return (*openflow_13.OfpDesc)(m).GetDpDesc() }
+
+// ofp_flow_stats_request from public import openflow_13.proto
+type OfpFlowStatsRequest openflow_13.OfpFlowStatsRequest
+
+func (m *OfpFlowStatsRequest) Reset()         { (*openflow_13.OfpFlowStatsRequest)(m).Reset() }
+func (m *OfpFlowStatsRequest) String() string { return (*openflow_13.OfpFlowStatsRequest)(m).String() }
+func (*OfpFlowStatsRequest) ProtoMessage()    {}
+func (m *OfpFlowStatsRequest) GetTableId() uint32 {
+	return (*openflow_13.OfpFlowStatsRequest)(m).GetTableId()
+}
+func (m *OfpFlowStatsRequest) GetOutPort() uint32 {
+	return (*openflow_13.OfpFlowStatsRequest)(m).GetOutPort()
+}
+func (m *OfpFlowStatsRequest) GetOutGroup() uint32 {
+	return (*openflow_13.OfpFlowStatsRequest)(m).GetOutGroup()
+}
+func (m *OfpFlowStatsRequest) GetCookie() uint64 {
+	return (*openflow_13.OfpFlowStatsRequest)(m).GetCookie()
+}
+func (m *OfpFlowStatsRequest) GetCookieMask() uint64 {
+	return (*openflow_13.OfpFlowStatsRequest)(m).GetCookieMask()
+}
+func (m *OfpFlowStatsRequest) GetMatch() *OfpMatch {
+	return (*OfpMatch)((*openflow_13.OfpFlowStatsRequest)(m).GetMatch())
+}
+
+// ofp_flow_stats from public import openflow_13.proto
+type OfpFlowStats openflow_13.OfpFlowStats
+
+func (m *OfpFlowStats) Reset()                 { (*openflow_13.OfpFlowStats)(m).Reset() }
+func (m *OfpFlowStats) String() string         { return (*openflow_13.OfpFlowStats)(m).String() }
+func (*OfpFlowStats) ProtoMessage()            {}
+func (m *OfpFlowStats) GetId() uint64          { return (*openflow_13.OfpFlowStats)(m).GetId() }
+func (m *OfpFlowStats) GetTableId() uint32     { return (*openflow_13.OfpFlowStats)(m).GetTableId() }
+func (m *OfpFlowStats) GetDurationSec() uint32 { return (*openflow_13.OfpFlowStats)(m).GetDurationSec() }
+func (m *OfpFlowStats) GetDurationNsec() uint32 {
+	return (*openflow_13.OfpFlowStats)(m).GetDurationNsec()
+}
+func (m *OfpFlowStats) GetPriority() uint32    { return (*openflow_13.OfpFlowStats)(m).GetPriority() }
+func (m *OfpFlowStats) GetIdleTimeout() uint32 { return (*openflow_13.OfpFlowStats)(m).GetIdleTimeout() }
+func (m *OfpFlowStats) GetHardTimeout() uint32 { return (*openflow_13.OfpFlowStats)(m).GetHardTimeout() }
+func (m *OfpFlowStats) GetFlags() uint32       { return (*openflow_13.OfpFlowStats)(m).GetFlags() }
+func (m *OfpFlowStats) GetCookie() uint64      { return (*openflow_13.OfpFlowStats)(m).GetCookie() }
+func (m *OfpFlowStats) GetPacketCount() uint64 { return (*openflow_13.OfpFlowStats)(m).GetPacketCount() }
+func (m *OfpFlowStats) GetByteCount() uint64   { return (*openflow_13.OfpFlowStats)(m).GetByteCount() }
+func (m *OfpFlowStats) GetMatch() *OfpMatch {
+	return (*OfpMatch)((*openflow_13.OfpFlowStats)(m).GetMatch())
+}
+func (m *OfpFlowStats) GetInstructions() []*OfpInstruction {
+	o := (*openflow_13.OfpFlowStats)(m).GetInstructions()
+	if o == nil {
+		return nil
+	}
+	s := make([]*OfpInstruction, len(o))
+	for i, x := range o {
+		s[i] = (*OfpInstruction)(x)
+	}
+	return s
+}
+
+// ofp_aggregate_stats_request from public import openflow_13.proto
+type OfpAggregateStatsRequest openflow_13.OfpAggregateStatsRequest
+
+func (m *OfpAggregateStatsRequest) Reset() { (*openflow_13.OfpAggregateStatsRequest)(m).Reset() }
+func (m *OfpAggregateStatsRequest) String() string {
+	return (*openflow_13.OfpAggregateStatsRequest)(m).String()
+}
+func (*OfpAggregateStatsRequest) ProtoMessage() {}
+func (m *OfpAggregateStatsRequest) GetTableId() uint32 {
+	return (*openflow_13.OfpAggregateStatsRequest)(m).GetTableId()
+}
+func (m *OfpAggregateStatsRequest) GetOutPort() uint32 {
+	return (*openflow_13.OfpAggregateStatsRequest)(m).GetOutPort()
+}
+func (m *OfpAggregateStatsRequest) GetOutGroup() uint32 {
+	return (*openflow_13.OfpAggregateStatsRequest)(m).GetOutGroup()
+}
+func (m *OfpAggregateStatsRequest) GetCookie() uint64 {
+	return (*openflow_13.OfpAggregateStatsRequest)(m).GetCookie()
+}
+func (m *OfpAggregateStatsRequest) GetCookieMask() uint64 {
+	return (*openflow_13.OfpAggregateStatsRequest)(m).GetCookieMask()
+}
+func (m *OfpAggregateStatsRequest) GetMatch() *OfpMatch {
+	return (*OfpMatch)((*openflow_13.OfpAggregateStatsRequest)(m).GetMatch())
+}
+
+// ofp_aggregate_stats_reply from public import openflow_13.proto
+type OfpAggregateStatsReply openflow_13.OfpAggregateStatsReply
+
+func (m *OfpAggregateStatsReply) Reset() { (*openflow_13.OfpAggregateStatsReply)(m).Reset() }
+func (m *OfpAggregateStatsReply) String() string {
+	return (*openflow_13.OfpAggregateStatsReply)(m).String()
+}
+func (*OfpAggregateStatsReply) ProtoMessage() {}
+func (m *OfpAggregateStatsReply) GetPacketCount() uint64 {
+	return (*openflow_13.OfpAggregateStatsReply)(m).GetPacketCount()
+}
+func (m *OfpAggregateStatsReply) GetByteCount() uint64 {
+	return (*openflow_13.OfpAggregateStatsReply)(m).GetByteCount()
+}
+func (m *OfpAggregateStatsReply) GetFlowCount() uint32 {
+	return (*openflow_13.OfpAggregateStatsReply)(m).GetFlowCount()
+}
+
+// ofp_table_feature_property from public import openflow_13.proto
+type OfpTableFeatureProperty openflow_13.OfpTableFeatureProperty
+
+func (m *OfpTableFeatureProperty) Reset() { (*openflow_13.OfpTableFeatureProperty)(m).Reset() }
+func (m *OfpTableFeatureProperty) String() string {
+	return (*openflow_13.OfpTableFeatureProperty)(m).String()
+}
+func (*OfpTableFeatureProperty) ProtoMessage() {}
+func (m *OfpTableFeatureProperty) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) int, []interface{}) {
+	return _OfpTableFeatureProperty_OneofMarshaler, _OfpTableFeatureProperty_OneofUnmarshaler, _OfpTableFeatureProperty_OneofSizer, nil
+}
+func _OfpTableFeatureProperty_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
+	m := msg.(*OfpTableFeatureProperty)
+	m0 := (*openflow_13.OfpTableFeatureProperty)(m)
+	enc, _, _, _ := m0.XXX_OneofFuncs()
+	return enc(m0, b)
+}
+func _OfpTableFeatureProperty_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
+	m := msg.(*OfpTableFeatureProperty)
+	m0 := (*openflow_13.OfpTableFeatureProperty)(m)
+	_, dec, _, _ := m0.XXX_OneofFuncs()
+	return dec(m0, tag, wire, b)
+}
+func _OfpTableFeatureProperty_OneofSizer(msg proto.Message) int {
+	m := msg.(*OfpTableFeatureProperty)
+	m0 := (*openflow_13.OfpTableFeatureProperty)(m)
+	_, _, size, _ := m0.XXX_OneofFuncs()
+	return size(m0)
+}
+func (m *OfpTableFeatureProperty) GetType() OfpTableFeaturePropType {
+	return (OfpTableFeaturePropType)((*openflow_13.OfpTableFeatureProperty)(m).GetType())
+}
+func (m *OfpTableFeatureProperty) GetInstructions() *OfpTableFeaturePropInstructions {
+	return (*OfpTableFeaturePropInstructions)((*openflow_13.OfpTableFeatureProperty)(m).GetInstructions())
+}
+func (m *OfpTableFeatureProperty) GetNextTables() *OfpTableFeaturePropNextTables {
+	return (*OfpTableFeaturePropNextTables)((*openflow_13.OfpTableFeatureProperty)(m).GetNextTables())
+}
+func (m *OfpTableFeatureProperty) GetActions() *OfpTableFeaturePropActions {
+	return (*OfpTableFeaturePropActions)((*openflow_13.OfpTableFeatureProperty)(m).GetActions())
+}
+func (m *OfpTableFeatureProperty) GetOxm() *OfpTableFeaturePropOxm {
+	return (*OfpTableFeaturePropOxm)((*openflow_13.OfpTableFeatureProperty)(m).GetOxm())
+}
+func (m *OfpTableFeatureProperty) GetExperimenter() *OfpTableFeaturePropExperimenter {
+	return (*OfpTableFeaturePropExperimenter)((*openflow_13.OfpTableFeatureProperty)(m).GetExperimenter())
+}
+
+// ofp_table_feature_prop_instructions from public import openflow_13.proto
+type OfpTableFeaturePropInstructions openflow_13.OfpTableFeaturePropInstructions
+
+func (m *OfpTableFeaturePropInstructions) Reset() {
+	(*openflow_13.OfpTableFeaturePropInstructions)(m).Reset()
+}
+func (m *OfpTableFeaturePropInstructions) String() string {
+	return (*openflow_13.OfpTableFeaturePropInstructions)(m).String()
+}
+func (*OfpTableFeaturePropInstructions) ProtoMessage() {}
+func (m *OfpTableFeaturePropInstructions) GetInstructions() []*OfpInstruction {
+	o := (*openflow_13.OfpTableFeaturePropInstructions)(m).GetInstructions()
+	if o == nil {
+		return nil
+	}
+	s := make([]*OfpInstruction, len(o))
+	for i, x := range o {
+		s[i] = (*OfpInstruction)(x)
+	}
+	return s
+}
+
+// ofp_table_feature_prop_next_tables from public import openflow_13.proto
+type OfpTableFeaturePropNextTables openflow_13.OfpTableFeaturePropNextTables
+
+func (m *OfpTableFeaturePropNextTables) Reset() {
+	(*openflow_13.OfpTableFeaturePropNextTables)(m).Reset()
+}
+func (m *OfpTableFeaturePropNextTables) String() string {
+	return (*openflow_13.OfpTableFeaturePropNextTables)(m).String()
+}
+func (*OfpTableFeaturePropNextTables) ProtoMessage() {}
+func (m *OfpTableFeaturePropNextTables) GetNextTableIds() []uint32 {
+	return (*openflow_13.OfpTableFeaturePropNextTables)(m).GetNextTableIds()
+}
+
+// ofp_table_feature_prop_actions from public import openflow_13.proto
+type OfpTableFeaturePropActions openflow_13.OfpTableFeaturePropActions
+
+func (m *OfpTableFeaturePropActions) Reset() { (*openflow_13.OfpTableFeaturePropActions)(m).Reset() }
+func (m *OfpTableFeaturePropActions) String() string {
+	return (*openflow_13.OfpTableFeaturePropActions)(m).String()
+}
+func (*OfpTableFeaturePropActions) ProtoMessage() {}
+func (m *OfpTableFeaturePropActions) GetActions() []*OfpAction {
+	o := (*openflow_13.OfpTableFeaturePropActions)(m).GetActions()
+	if o == nil {
+		return nil
+	}
+	s := make([]*OfpAction, len(o))
+	for i, x := range o {
+		s[i] = (*OfpAction)(x)
+	}
+	return s
+}
+
+// ofp_table_feature_prop_oxm from public import openflow_13.proto
+type OfpTableFeaturePropOxm openflow_13.OfpTableFeaturePropOxm
+
+func (m *OfpTableFeaturePropOxm) Reset() { (*openflow_13.OfpTableFeaturePropOxm)(m).Reset() }
+func (m *OfpTableFeaturePropOxm) String() string {
+	return (*openflow_13.OfpTableFeaturePropOxm)(m).String()
+}
+func (*OfpTableFeaturePropOxm) ProtoMessage() {}
+func (m *OfpTableFeaturePropOxm) GetOxmIds() []uint32 {
+	return (*openflow_13.OfpTableFeaturePropOxm)(m).GetOxmIds()
+}
+
+// ofp_table_feature_prop_experimenter from public import openflow_13.proto
+type OfpTableFeaturePropExperimenter openflow_13.OfpTableFeaturePropExperimenter
+
+func (m *OfpTableFeaturePropExperimenter) Reset() {
+	(*openflow_13.OfpTableFeaturePropExperimenter)(m).Reset()
+}
+func (m *OfpTableFeaturePropExperimenter) String() string {
+	return (*openflow_13.OfpTableFeaturePropExperimenter)(m).String()
+}
+func (*OfpTableFeaturePropExperimenter) ProtoMessage() {}
+func (m *OfpTableFeaturePropExperimenter) GetExperimenter() uint32 {
+	return (*openflow_13.OfpTableFeaturePropExperimenter)(m).GetExperimenter()
+}
+func (m *OfpTableFeaturePropExperimenter) GetExpType() uint32 {
+	return (*openflow_13.OfpTableFeaturePropExperimenter)(m).GetExpType()
+}
+func (m *OfpTableFeaturePropExperimenter) GetExperimenterData() []uint32 {
+	return (*openflow_13.OfpTableFeaturePropExperimenter)(m).GetExperimenterData()
+}
+
+// ofp_table_features from public import openflow_13.proto
+type OfpTableFeatures openflow_13.OfpTableFeatures
+
+func (m *OfpTableFeatures) Reset()             { (*openflow_13.OfpTableFeatures)(m).Reset() }
+func (m *OfpTableFeatures) String() string     { return (*openflow_13.OfpTableFeatures)(m).String() }
+func (*OfpTableFeatures) ProtoMessage()        {}
+func (m *OfpTableFeatures) GetTableId() uint32 { return (*openflow_13.OfpTableFeatures)(m).GetTableId() }
+func (m *OfpTableFeatures) GetName() string    { return (*openflow_13.OfpTableFeatures)(m).GetName() }
+func (m *OfpTableFeatures) GetMetadataMatch() uint64 {
+	return (*openflow_13.OfpTableFeatures)(m).GetMetadataMatch()
+}
+func (m *OfpTableFeatures) GetMetadataWrite() uint64 {
+	return (*openflow_13.OfpTableFeatures)(m).GetMetadataWrite()
+}
+func (m *OfpTableFeatures) GetConfig() uint32 { return (*openflow_13.OfpTableFeatures)(m).GetConfig() }
+func (m *OfpTableFeatures) GetMaxEntries() uint32 {
+	return (*openflow_13.OfpTableFeatures)(m).GetMaxEntries()
+}
+func (m *OfpTableFeatures) GetProperties() []*OfpTableFeatureProperty {
+	o := (*openflow_13.OfpTableFeatures)(m).GetProperties()
+	if o == nil {
+		return nil
+	}
+	s := make([]*OfpTableFeatureProperty, len(o))
+	for i, x := range o {
+		s[i] = (*OfpTableFeatureProperty)(x)
+	}
+	return s
+}
+
+// ofp_table_stats from public import openflow_13.proto
+type OfpTableStats openflow_13.OfpTableStats
+
+func (m *OfpTableStats) Reset()             { (*openflow_13.OfpTableStats)(m).Reset() }
+func (m *OfpTableStats) String() string     { return (*openflow_13.OfpTableStats)(m).String() }
+func (*OfpTableStats) ProtoMessage()        {}
+func (m *OfpTableStats) GetTableId() uint32 { return (*openflow_13.OfpTableStats)(m).GetTableId() }
+func (m *OfpTableStats) GetActiveCount() uint32 {
+	return (*openflow_13.OfpTableStats)(m).GetActiveCount()
+}
+func (m *OfpTableStats) GetLookupCount() uint64 {
+	return (*openflow_13.OfpTableStats)(m).GetLookupCount()
+}
+func (m *OfpTableStats) GetMatchedCount() uint64 {
+	return (*openflow_13.OfpTableStats)(m).GetMatchedCount()
+}
+
+// ofp_port_stats_request from public import openflow_13.proto
+type OfpPortStatsRequest openflow_13.OfpPortStatsRequest
+
+func (m *OfpPortStatsRequest) Reset()         { (*openflow_13.OfpPortStatsRequest)(m).Reset() }
+func (m *OfpPortStatsRequest) String() string { return (*openflow_13.OfpPortStatsRequest)(m).String() }
+func (*OfpPortStatsRequest) ProtoMessage()    {}
+func (m *OfpPortStatsRequest) GetPortNo() uint32 {
+	return (*openflow_13.OfpPortStatsRequest)(m).GetPortNo()
+}
+
+// ofp_port_stats from public import openflow_13.proto
+type OfpPortStats openflow_13.OfpPortStats
+
+func (m *OfpPortStats) Reset()                 { (*openflow_13.OfpPortStats)(m).Reset() }
+func (m *OfpPortStats) String() string         { return (*openflow_13.OfpPortStats)(m).String() }
+func (*OfpPortStats) ProtoMessage()            {}
+func (m *OfpPortStats) GetPortNo() uint32      { return (*openflow_13.OfpPortStats)(m).GetPortNo() }
+func (m *OfpPortStats) GetRxPackets() uint64   { return (*openflow_13.OfpPortStats)(m).GetRxPackets() }
+func (m *OfpPortStats) GetTxPackets() uint64   { return (*openflow_13.OfpPortStats)(m).GetTxPackets() }
+func (m *OfpPortStats) GetRxBytes() uint64     { return (*openflow_13.OfpPortStats)(m).GetRxBytes() }
+func (m *OfpPortStats) GetTxBytes() uint64     { return (*openflow_13.OfpPortStats)(m).GetTxBytes() }
+func (m *OfpPortStats) GetRxDropped() uint64   { return (*openflow_13.OfpPortStats)(m).GetRxDropped() }
+func (m *OfpPortStats) GetTxDropped() uint64   { return (*openflow_13.OfpPortStats)(m).GetTxDropped() }
+func (m *OfpPortStats) GetRxErrors() uint64    { return (*openflow_13.OfpPortStats)(m).GetRxErrors() }
+func (m *OfpPortStats) GetTxErrors() uint64    { return (*openflow_13.OfpPortStats)(m).GetTxErrors() }
+func (m *OfpPortStats) GetRxFrameErr() uint64  { return (*openflow_13.OfpPortStats)(m).GetRxFrameErr() }
+func (m *OfpPortStats) GetRxOverErr() uint64   { return (*openflow_13.OfpPortStats)(m).GetRxOverErr() }
+func (m *OfpPortStats) GetRxCrcErr() uint64    { return (*openflow_13.OfpPortStats)(m).GetRxCrcErr() }
+func (m *OfpPortStats) GetCollisions() uint64  { return (*openflow_13.OfpPortStats)(m).GetCollisions() }
+func (m *OfpPortStats) GetDurationSec() uint32 { return (*openflow_13.OfpPortStats)(m).GetDurationSec() }
+func (m *OfpPortStats) GetDurationNsec() uint32 {
+	return (*openflow_13.OfpPortStats)(m).GetDurationNsec()
+}
+
+// ofp_group_stats_request from public import openflow_13.proto
+type OfpGroupStatsRequest openflow_13.OfpGroupStatsRequest
+
+func (m *OfpGroupStatsRequest) Reset()         { (*openflow_13.OfpGroupStatsRequest)(m).Reset() }
+func (m *OfpGroupStatsRequest) String() string { return (*openflow_13.OfpGroupStatsRequest)(m).String() }
+func (*OfpGroupStatsRequest) ProtoMessage()    {}
+func (m *OfpGroupStatsRequest) GetGroupId() uint32 {
+	return (*openflow_13.OfpGroupStatsRequest)(m).GetGroupId()
+}
+
+// ofp_bucket_counter from public import openflow_13.proto
+type OfpBucketCounter openflow_13.OfpBucketCounter
+
+func (m *OfpBucketCounter) Reset()         { (*openflow_13.OfpBucketCounter)(m).Reset() }
+func (m *OfpBucketCounter) String() string { return (*openflow_13.OfpBucketCounter)(m).String() }
+func (*OfpBucketCounter) ProtoMessage()    {}
+func (m *OfpBucketCounter) GetPacketCount() uint64 {
+	return (*openflow_13.OfpBucketCounter)(m).GetPacketCount()
+}
+func (m *OfpBucketCounter) GetByteCount() uint64 {
+	return (*openflow_13.OfpBucketCounter)(m).GetByteCount()
+}
+
+// ofp_group_stats from public import openflow_13.proto
+type OfpGroupStats openflow_13.OfpGroupStats
+
+func (m *OfpGroupStats) Reset()              { (*openflow_13.OfpGroupStats)(m).Reset() }
+func (m *OfpGroupStats) String() string      { return (*openflow_13.OfpGroupStats)(m).String() }
+func (*OfpGroupStats) ProtoMessage()         {}
+func (m *OfpGroupStats) GetGroupId() uint32  { return (*openflow_13.OfpGroupStats)(m).GetGroupId() }
+func (m *OfpGroupStats) GetRefCount() uint32 { return (*openflow_13.OfpGroupStats)(m).GetRefCount() }
+func (m *OfpGroupStats) GetPacketCount() uint64 {
+	return (*openflow_13.OfpGroupStats)(m).GetPacketCount()
+}
+func (m *OfpGroupStats) GetByteCount() uint64 { return (*openflow_13.OfpGroupStats)(m).GetByteCount() }
+func (m *OfpGroupStats) GetDurationSec() uint32 {
+	return (*openflow_13.OfpGroupStats)(m).GetDurationSec()
+}
+func (m *OfpGroupStats) GetDurationNsec() uint32 {
+	return (*openflow_13.OfpGroupStats)(m).GetDurationNsec()
+}
+func (m *OfpGroupStats) GetBucketStats() []*OfpBucketCounter {
+	o := (*openflow_13.OfpGroupStats)(m).GetBucketStats()
+	if o == nil {
+		return nil
+	}
+	s := make([]*OfpBucketCounter, len(o))
+	for i, x := range o {
+		s[i] = (*OfpBucketCounter)(x)
+	}
+	return s
+}
+
+// ofp_group_desc from public import openflow_13.proto
+type OfpGroupDesc openflow_13.OfpGroupDesc
+
+func (m *OfpGroupDesc) Reset()         { (*openflow_13.OfpGroupDesc)(m).Reset() }
+func (m *OfpGroupDesc) String() string { return (*openflow_13.OfpGroupDesc)(m).String() }
+func (*OfpGroupDesc) ProtoMessage()    {}
+func (m *OfpGroupDesc) GetType() OfpGroupType {
+	return (OfpGroupType)((*openflow_13.OfpGroupDesc)(m).GetType())
+}
+func (m *OfpGroupDesc) GetGroupId() uint32 { return (*openflow_13.OfpGroupDesc)(m).GetGroupId() }
+func (m *OfpGroupDesc) GetBuckets() []*OfpBucket {
+	o := (*openflow_13.OfpGroupDesc)(m).GetBuckets()
+	if o == nil {
+		return nil
+	}
+	s := make([]*OfpBucket, len(o))
+	for i, x := range o {
+		s[i] = (*OfpBucket)(x)
+	}
+	return s
+}
+
+// ofp_group_entry from public import openflow_13.proto
+type OfpGroupEntry openflow_13.OfpGroupEntry
+
+func (m *OfpGroupEntry) Reset()         { (*openflow_13.OfpGroupEntry)(m).Reset() }
+func (m *OfpGroupEntry) String() string { return (*openflow_13.OfpGroupEntry)(m).String() }
+func (*OfpGroupEntry) ProtoMessage()    {}
+func (m *OfpGroupEntry) GetDesc() *OfpGroupDesc {
+	return (*OfpGroupDesc)((*openflow_13.OfpGroupEntry)(m).GetDesc())
+}
+func (m *OfpGroupEntry) GetStats() *OfpGroupStats {
+	return (*OfpGroupStats)((*openflow_13.OfpGroupEntry)(m).GetStats())
+}
+
+// ofp_group_features from public import openflow_13.proto
+type OfpGroupFeatures openflow_13.OfpGroupFeatures
+
+func (m *OfpGroupFeatures) Reset()           { (*openflow_13.OfpGroupFeatures)(m).Reset() }
+func (m *OfpGroupFeatures) String() string   { return (*openflow_13.OfpGroupFeatures)(m).String() }
+func (*OfpGroupFeatures) ProtoMessage()      {}
+func (m *OfpGroupFeatures) GetTypes() uint32 { return (*openflow_13.OfpGroupFeatures)(m).GetTypes() }
+func (m *OfpGroupFeatures) GetCapabilities() uint32 {
+	return (*openflow_13.OfpGroupFeatures)(m).GetCapabilities()
+}
+func (m *OfpGroupFeatures) GetMaxGroups() []uint32 {
+	return (*openflow_13.OfpGroupFeatures)(m).GetMaxGroups()
+}
+func (m *OfpGroupFeatures) GetActions() []uint32 {
+	return (*openflow_13.OfpGroupFeatures)(m).GetActions()
+}
+
+// ofp_meter_multipart_request from public import openflow_13.proto
+type OfpMeterMultipartRequest openflow_13.OfpMeterMultipartRequest
+
+func (m *OfpMeterMultipartRequest) Reset() { (*openflow_13.OfpMeterMultipartRequest)(m).Reset() }
+func (m *OfpMeterMultipartRequest) String() string {
+	return (*openflow_13.OfpMeterMultipartRequest)(m).String()
+}
+func (*OfpMeterMultipartRequest) ProtoMessage() {}
+func (m *OfpMeterMultipartRequest) GetMeterId() uint32 {
+	return (*openflow_13.OfpMeterMultipartRequest)(m).GetMeterId()
+}
+
+// ofp_meter_band_stats from public import openflow_13.proto
+type OfpMeterBandStats openflow_13.OfpMeterBandStats
+
+func (m *OfpMeterBandStats) Reset()         { (*openflow_13.OfpMeterBandStats)(m).Reset() }
+func (m *OfpMeterBandStats) String() string { return (*openflow_13.OfpMeterBandStats)(m).String() }
+func (*OfpMeterBandStats) ProtoMessage()    {}
+func (m *OfpMeterBandStats) GetPacketBandCount() uint64 {
+	return (*openflow_13.OfpMeterBandStats)(m).GetPacketBandCount()
+}
+func (m *OfpMeterBandStats) GetByteBandCount() uint64 {
+	return (*openflow_13.OfpMeterBandStats)(m).GetByteBandCount()
+}
+
+// ofp_meter_stats from public import openflow_13.proto
+type OfpMeterStats openflow_13.OfpMeterStats
+
+func (m *OfpMeterStats) Reset()               { (*openflow_13.OfpMeterStats)(m).Reset() }
+func (m *OfpMeterStats) String() string       { return (*openflow_13.OfpMeterStats)(m).String() }
+func (*OfpMeterStats) ProtoMessage()          {}
+func (m *OfpMeterStats) GetMeterId() uint32   { return (*openflow_13.OfpMeterStats)(m).GetMeterId() }
+func (m *OfpMeterStats) GetFlowCount() uint32 { return (*openflow_13.OfpMeterStats)(m).GetFlowCount() }
+func (m *OfpMeterStats) GetPacketInCount() uint64 {
+	return (*openflow_13.OfpMeterStats)(m).GetPacketInCount()
+}
+func (m *OfpMeterStats) GetByteInCount() uint64 {
+	return (*openflow_13.OfpMeterStats)(m).GetByteInCount()
+}
+func (m *OfpMeterStats) GetDurationSec() uint32 {
+	return (*openflow_13.OfpMeterStats)(m).GetDurationSec()
+}
+func (m *OfpMeterStats) GetDurationNsec() uint32 {
+	return (*openflow_13.OfpMeterStats)(m).GetDurationNsec()
+}
+func (m *OfpMeterStats) GetBandStats() []*OfpMeterBandStats {
+	o := (*openflow_13.OfpMeterStats)(m).GetBandStats()
+	if o == nil {
+		return nil
+	}
+	s := make([]*OfpMeterBandStats, len(o))
+	for i, x := range o {
+		s[i] = (*OfpMeterBandStats)(x)
+	}
+	return s
+}
+
+// ofp_meter_config from public import openflow_13.proto
+type OfpMeterConfig openflow_13.OfpMeterConfig
+
+func (m *OfpMeterConfig) Reset()             { (*openflow_13.OfpMeterConfig)(m).Reset() }
+func (m *OfpMeterConfig) String() string     { return (*openflow_13.OfpMeterConfig)(m).String() }
+func (*OfpMeterConfig) ProtoMessage()        {}
+func (m *OfpMeterConfig) GetFlags() uint32   { return (*openflow_13.OfpMeterConfig)(m).GetFlags() }
+func (m *OfpMeterConfig) GetMeterId() uint32 { return (*openflow_13.OfpMeterConfig)(m).GetMeterId() }
+func (m *OfpMeterConfig) GetBands() []*OfpMeterBandHeader {
+	o := (*openflow_13.OfpMeterConfig)(m).GetBands()
+	if o == nil {
+		return nil
+	}
+	s := make([]*OfpMeterBandHeader, len(o))
+	for i, x := range o {
+		s[i] = (*OfpMeterBandHeader)(x)
+	}
+	return s
+}
+
+// ofp_meter_features from public import openflow_13.proto
+type OfpMeterFeatures openflow_13.OfpMeterFeatures
+
+func (m *OfpMeterFeatures) Reset()         { (*openflow_13.OfpMeterFeatures)(m).Reset() }
+func (m *OfpMeterFeatures) String() string { return (*openflow_13.OfpMeterFeatures)(m).String() }
+func (*OfpMeterFeatures) ProtoMessage()    {}
+func (m *OfpMeterFeatures) GetMaxMeter() uint32 {
+	return (*openflow_13.OfpMeterFeatures)(m).GetMaxMeter()
+}
+func (m *OfpMeterFeatures) GetBandTypes() uint32 {
+	return (*openflow_13.OfpMeterFeatures)(m).GetBandTypes()
+}
+func (m *OfpMeterFeatures) GetCapabilities() uint32 {
+	return (*openflow_13.OfpMeterFeatures)(m).GetCapabilities()
+}
+func (m *OfpMeterFeatures) GetMaxBands() uint32 {
+	return (*openflow_13.OfpMeterFeatures)(m).GetMaxBands()
+}
+func (m *OfpMeterFeatures) GetMaxColor() uint32 {
+	return (*openflow_13.OfpMeterFeatures)(m).GetMaxColor()
+}
+
+// ofp_experimenter_multipart_header from public import openflow_13.proto
+type OfpExperimenterMultipartHeader openflow_13.OfpExperimenterMultipartHeader
+
+func (m *OfpExperimenterMultipartHeader) Reset() {
+	(*openflow_13.OfpExperimenterMultipartHeader)(m).Reset()
+}
+func (m *OfpExperimenterMultipartHeader) String() string {
+	return (*openflow_13.OfpExperimenterMultipartHeader)(m).String()
+}
+func (*OfpExperimenterMultipartHeader) ProtoMessage() {}
+func (m *OfpExperimenterMultipartHeader) GetExperimenter() uint32 {
+	return (*openflow_13.OfpExperimenterMultipartHeader)(m).GetExperimenter()
+}
+func (m *OfpExperimenterMultipartHeader) GetExpType() uint32 {
+	return (*openflow_13.OfpExperimenterMultipartHeader)(m).GetExpType()
+}
+func (m *OfpExperimenterMultipartHeader) GetData() []byte {
+	return (*openflow_13.OfpExperimenterMultipartHeader)(m).GetData()
+}
+
+// ofp_experimenter_header from public import openflow_13.proto
+type OfpExperimenterHeader openflow_13.OfpExperimenterHeader
+
+func (m *OfpExperimenterHeader) Reset() { (*openflow_13.OfpExperimenterHeader)(m).Reset() }
+func (m *OfpExperimenterHeader) String() string {
+	return (*openflow_13.OfpExperimenterHeader)(m).String()
+}
+func (*OfpExperimenterHeader) ProtoMessage() {}
+func (m *OfpExperimenterHeader) GetExperimenter() uint32 {
+	return (*openflow_13.OfpExperimenterHeader)(m).GetExperimenter()
+}
+func (m *OfpExperimenterHeader) GetExpType() uint32 {
+	return (*openflow_13.OfpExperimenterHeader)(m).GetExpType()
+}
+func (m *OfpExperimenterHeader) GetData() []byte {
+	return (*openflow_13.OfpExperimenterHeader)(m).GetData()
+}
+
+// ofp_queue_prop_header from public import openflow_13.proto
+type OfpQueuePropHeader openflow_13.OfpQueuePropHeader
+
+func (m *OfpQueuePropHeader) Reset()         { (*openflow_13.OfpQueuePropHeader)(m).Reset() }
+func (m *OfpQueuePropHeader) String() string { return (*openflow_13.OfpQueuePropHeader)(m).String() }
+func (*OfpQueuePropHeader) ProtoMessage()    {}
+func (m *OfpQueuePropHeader) GetProperty() uint32 {
+	return (*openflow_13.OfpQueuePropHeader)(m).GetProperty()
+}
+func (m *OfpQueuePropHeader) GetLen() uint32 { return (*openflow_13.OfpQueuePropHeader)(m).GetLen() }
+
+// ofp_queue_prop_min_rate from public import openflow_13.proto
+type OfpQueuePropMinRate openflow_13.OfpQueuePropMinRate
+
+func (m *OfpQueuePropMinRate) Reset()         { (*openflow_13.OfpQueuePropMinRate)(m).Reset() }
+func (m *OfpQueuePropMinRate) String() string { return (*openflow_13.OfpQueuePropMinRate)(m).String() }
+func (*OfpQueuePropMinRate) ProtoMessage()    {}
+func (m *OfpQueuePropMinRate) GetPropHeader() *OfpQueuePropHeader {
+	return (*OfpQueuePropHeader)((*openflow_13.OfpQueuePropMinRate)(m).GetPropHeader())
+}
+func (m *OfpQueuePropMinRate) GetRate() uint32 { return (*openflow_13.OfpQueuePropMinRate)(m).GetRate() }
+
+// ofp_queue_prop_max_rate from public import openflow_13.proto
+type OfpQueuePropMaxRate openflow_13.OfpQueuePropMaxRate
+
+func (m *OfpQueuePropMaxRate) Reset()         { (*openflow_13.OfpQueuePropMaxRate)(m).Reset() }
+func (m *OfpQueuePropMaxRate) String() string { return (*openflow_13.OfpQueuePropMaxRate)(m).String() }
+func (*OfpQueuePropMaxRate) ProtoMessage()    {}
+func (m *OfpQueuePropMaxRate) GetPropHeader() *OfpQueuePropHeader {
+	return (*OfpQueuePropHeader)((*openflow_13.OfpQueuePropMaxRate)(m).GetPropHeader())
+}
+func (m *OfpQueuePropMaxRate) GetRate() uint32 { return (*openflow_13.OfpQueuePropMaxRate)(m).GetRate() }
+
+// ofp_queue_prop_experimenter from public import openflow_13.proto
+type OfpQueuePropExperimenter openflow_13.OfpQueuePropExperimenter
+
+func (m *OfpQueuePropExperimenter) Reset() { (*openflow_13.OfpQueuePropExperimenter)(m).Reset() }
+func (m *OfpQueuePropExperimenter) String() string {
+	return (*openflow_13.OfpQueuePropExperimenter)(m).String()
+}
+func (*OfpQueuePropExperimenter) ProtoMessage() {}
+func (m *OfpQueuePropExperimenter) GetPropHeader() *OfpQueuePropHeader {
+	return (*OfpQueuePropHeader)((*openflow_13.OfpQueuePropExperimenter)(m).GetPropHeader())
+}
+func (m *OfpQueuePropExperimenter) GetExperimenter() uint32 {
+	return (*openflow_13.OfpQueuePropExperimenter)(m).GetExperimenter()
+}
+func (m *OfpQueuePropExperimenter) GetData() []byte {
+	return (*openflow_13.OfpQueuePropExperimenter)(m).GetData()
+}
+
+// ofp_packet_queue from public import openflow_13.proto
+type OfpPacketQueue openflow_13.OfpPacketQueue
+
+func (m *OfpPacketQueue) Reset()             { (*openflow_13.OfpPacketQueue)(m).Reset() }
+func (m *OfpPacketQueue) String() string     { return (*openflow_13.OfpPacketQueue)(m).String() }
+func (*OfpPacketQueue) ProtoMessage()        {}
+func (m *OfpPacketQueue) GetQueueId() uint32 { return (*openflow_13.OfpPacketQueue)(m).GetQueueId() }
+func (m *OfpPacketQueue) GetPort() uint32    { return (*openflow_13.OfpPacketQueue)(m).GetPort() }
+func (m *OfpPacketQueue) GetProperties() []*OfpQueuePropHeader {
+	o := (*openflow_13.OfpPacketQueue)(m).GetProperties()
+	if o == nil {
+		return nil
+	}
+	s := make([]*OfpQueuePropHeader, len(o))
+	for i, x := range o {
+		s[i] = (*OfpQueuePropHeader)(x)
+	}
+	return s
+}
+
+// ofp_queue_get_config_request from public import openflow_13.proto
+type OfpQueueGetConfigRequest openflow_13.OfpQueueGetConfigRequest
+
+func (m *OfpQueueGetConfigRequest) Reset() { (*openflow_13.OfpQueueGetConfigRequest)(m).Reset() }
+func (m *OfpQueueGetConfigRequest) String() string {
+	return (*openflow_13.OfpQueueGetConfigRequest)(m).String()
+}
+func (*OfpQueueGetConfigRequest) ProtoMessage() {}
+func (m *OfpQueueGetConfigRequest) GetPort() uint32 {
+	return (*openflow_13.OfpQueueGetConfigRequest)(m).GetPort()
+}
+
+// ofp_queue_get_config_reply from public import openflow_13.proto
+type OfpQueueGetConfigReply openflow_13.OfpQueueGetConfigReply
+
+func (m *OfpQueueGetConfigReply) Reset() { (*openflow_13.OfpQueueGetConfigReply)(m).Reset() }
+func (m *OfpQueueGetConfigReply) String() string {
+	return (*openflow_13.OfpQueueGetConfigReply)(m).String()
+}
+func (*OfpQueueGetConfigReply) ProtoMessage() {}
+func (m *OfpQueueGetConfigReply) GetPort() uint32 {
+	return (*openflow_13.OfpQueueGetConfigReply)(m).GetPort()
+}
+func (m *OfpQueueGetConfigReply) GetQueues() []*OfpPacketQueue {
+	o := (*openflow_13.OfpQueueGetConfigReply)(m).GetQueues()
+	if o == nil {
+		return nil
+	}
+	s := make([]*OfpPacketQueue, len(o))
+	for i, x := range o {
+		s[i] = (*OfpPacketQueue)(x)
+	}
+	return s
+}
+
+// ofp_action_set_queue from public import openflow_13.proto
+type OfpActionSetQueue openflow_13.OfpActionSetQueue
+
+func (m *OfpActionSetQueue) Reset()          { (*openflow_13.OfpActionSetQueue)(m).Reset() }
+func (m *OfpActionSetQueue) String() string  { return (*openflow_13.OfpActionSetQueue)(m).String() }
+func (*OfpActionSetQueue) ProtoMessage()     {}
+func (m *OfpActionSetQueue) GetType() uint32 { return (*openflow_13.OfpActionSetQueue)(m).GetType() }
+func (m *OfpActionSetQueue) GetQueueId() uint32 {
+	return (*openflow_13.OfpActionSetQueue)(m).GetQueueId()
+}
+
+// ofp_queue_stats_request from public import openflow_13.proto
+type OfpQueueStatsRequest openflow_13.OfpQueueStatsRequest
+
+func (m *OfpQueueStatsRequest) Reset()         { (*openflow_13.OfpQueueStatsRequest)(m).Reset() }
+func (m *OfpQueueStatsRequest) String() string { return (*openflow_13.OfpQueueStatsRequest)(m).String() }
+func (*OfpQueueStatsRequest) ProtoMessage()    {}
+func (m *OfpQueueStatsRequest) GetPortNo() uint32 {
+	return (*openflow_13.OfpQueueStatsRequest)(m).GetPortNo()
+}
+func (m *OfpQueueStatsRequest) GetQueueId() uint32 {
+	return (*openflow_13.OfpQueueStatsRequest)(m).GetQueueId()
+}
+
+// ofp_queue_stats from public import openflow_13.proto
+type OfpQueueStats openflow_13.OfpQueueStats
+
+func (m *OfpQueueStats) Reset()               { (*openflow_13.OfpQueueStats)(m).Reset() }
+func (m *OfpQueueStats) String() string       { return (*openflow_13.OfpQueueStats)(m).String() }
+func (*OfpQueueStats) ProtoMessage()          {}
+func (m *OfpQueueStats) GetPortNo() uint32    { return (*openflow_13.OfpQueueStats)(m).GetPortNo() }
+func (m *OfpQueueStats) GetQueueId() uint32   { return (*openflow_13.OfpQueueStats)(m).GetQueueId() }
+func (m *OfpQueueStats) GetTxBytes() uint64   { return (*openflow_13.OfpQueueStats)(m).GetTxBytes() }
+func (m *OfpQueueStats) GetTxPackets() uint64 { return (*openflow_13.OfpQueueStats)(m).GetTxPackets() }
+func (m *OfpQueueStats) GetTxErrors() uint64  { return (*openflow_13.OfpQueueStats)(m).GetTxErrors() }
+func (m *OfpQueueStats) GetDurationSec() uint32 {
+	return (*openflow_13.OfpQueueStats)(m).GetDurationSec()
+}
+func (m *OfpQueueStats) GetDurationNsec() uint32 {
+	return (*openflow_13.OfpQueueStats)(m).GetDurationNsec()
+}
+
+// ofp_role_request from public import openflow_13.proto
+type OfpRoleRequest openflow_13.OfpRoleRequest
+
+func (m *OfpRoleRequest) Reset()         { (*openflow_13.OfpRoleRequest)(m).Reset() }
+func (m *OfpRoleRequest) String() string { return (*openflow_13.OfpRoleRequest)(m).String() }
+func (*OfpRoleRequest) ProtoMessage()    {}
+func (m *OfpRoleRequest) GetRole() OfpControllerRole {
+	return (OfpControllerRole)((*openflow_13.OfpRoleRequest)(m).GetRole())
+}
+func (m *OfpRoleRequest) GetGenerationId() uint64 {
+	return (*openflow_13.OfpRoleRequest)(m).GetGenerationId()
+}
+
+// ofp_async_config from public import openflow_13.proto
+type OfpAsyncConfig openflow_13.OfpAsyncConfig
+
+func (m *OfpAsyncConfig) Reset()         { (*openflow_13.OfpAsyncConfig)(m).Reset() }
+func (m *OfpAsyncConfig) String() string { return (*openflow_13.OfpAsyncConfig)(m).String() }
+func (*OfpAsyncConfig) ProtoMessage()    {}
+func (m *OfpAsyncConfig) GetPacketInMask() []uint32 {
+	return (*openflow_13.OfpAsyncConfig)(m).GetPacketInMask()
+}
+func (m *OfpAsyncConfig) GetPortStatusMask() []uint32 {
+	return (*openflow_13.OfpAsyncConfig)(m).GetPortStatusMask()
+}
+func (m *OfpAsyncConfig) GetFlowRemovedMask() []uint32 {
+	return (*openflow_13.OfpAsyncConfig)(m).GetFlowRemovedMask()
+}
+
+// FlowTableUpdate from public import openflow_13.proto
+type FlowTableUpdate openflow_13.FlowTableUpdate
+
+func (m *FlowTableUpdate) Reset()         { (*openflow_13.FlowTableUpdate)(m).Reset() }
+func (m *FlowTableUpdate) String() string { return (*openflow_13.FlowTableUpdate)(m).String() }
+func (*FlowTableUpdate) ProtoMessage()    {}
+func (m *FlowTableUpdate) GetId() string  { return (*openflow_13.FlowTableUpdate)(m).GetId() }
+func (m *FlowTableUpdate) GetFlowMod() *OfpFlowMod {
+	return (*OfpFlowMod)((*openflow_13.FlowTableUpdate)(m).GetFlowMod())
+}
+
+// FlowGroupTableUpdate from public import openflow_13.proto
+type FlowGroupTableUpdate openflow_13.FlowGroupTableUpdate
+
+func (m *FlowGroupTableUpdate) Reset()         { (*openflow_13.FlowGroupTableUpdate)(m).Reset() }
+func (m *FlowGroupTableUpdate) String() string { return (*openflow_13.FlowGroupTableUpdate)(m).String() }
+func (*FlowGroupTableUpdate) ProtoMessage()    {}
+func (m *FlowGroupTableUpdate) GetId() string  { return (*openflow_13.FlowGroupTableUpdate)(m).GetId() }
+func (m *FlowGroupTableUpdate) GetGroupMod() *OfpGroupMod {
+	return (*OfpGroupMod)((*openflow_13.FlowGroupTableUpdate)(m).GetGroupMod())
+}
+
+// Flows from public import openflow_13.proto
+type Flows openflow_13.Flows
+
+func (m *Flows) Reset()         { (*openflow_13.Flows)(m).Reset() }
+func (m *Flows) String() string { return (*openflow_13.Flows)(m).String() }
+func (*Flows) ProtoMessage()    {}
+func (m *Flows) GetItems() []*OfpFlowStats {
+	o := (*openflow_13.Flows)(m).GetItems()
+	if o == nil {
+		return nil
+	}
+	s := make([]*OfpFlowStats, len(o))
+	for i, x := range o {
+		s[i] = (*OfpFlowStats)(x)
+	}
+	return s
+}
+
+// FlowGroups from public import openflow_13.proto
+type FlowGroups openflow_13.FlowGroups
+
+func (m *FlowGroups) Reset()         { (*openflow_13.FlowGroups)(m).Reset() }
+func (m *FlowGroups) String() string { return (*openflow_13.FlowGroups)(m).String() }
+func (*FlowGroups) ProtoMessage()    {}
+func (m *FlowGroups) GetItems() []*OfpGroupEntry {
+	o := (*openflow_13.FlowGroups)(m).GetItems()
+	if o == nil {
+		return nil
+	}
+	s := make([]*OfpGroupEntry, len(o))
+	for i, x := range o {
+		s[i] = (*OfpGroupEntry)(x)
+	}
+	return s
+}
+
+// PacketIn from public import openflow_13.proto
+type PacketIn openflow_13.PacketIn
+
+func (m *PacketIn) Reset()         { (*openflow_13.PacketIn)(m).Reset() }
+func (m *PacketIn) String() string { return (*openflow_13.PacketIn)(m).String() }
+func (*PacketIn) ProtoMessage()    {}
+func (m *PacketIn) GetId() string  { return (*openflow_13.PacketIn)(m).GetId() }
+func (m *PacketIn) GetPacketIn() *OfpPacketIn {
+	return (*OfpPacketIn)((*openflow_13.PacketIn)(m).GetPacketIn())
+}
+
+// PacketOut from public import openflow_13.proto
+type PacketOut openflow_13.PacketOut
+
+func (m *PacketOut) Reset()         { (*openflow_13.PacketOut)(m).Reset() }
+func (m *PacketOut) String() string { return (*openflow_13.PacketOut)(m).String() }
+func (*PacketOut) ProtoMessage()    {}
+func (m *PacketOut) GetId() string  { return (*openflow_13.PacketOut)(m).GetId() }
+func (m *PacketOut) GetPacketOut() *OfpPacketOut {
+	return (*OfpPacketOut)((*openflow_13.PacketOut)(m).GetPacketOut())
+}
+
+// ChangeEvent from public import openflow_13.proto
+type ChangeEvent openflow_13.ChangeEvent
+
+func (m *ChangeEvent) Reset()         { (*openflow_13.ChangeEvent)(m).Reset() }
+func (m *ChangeEvent) String() string { return (*openflow_13.ChangeEvent)(m).String() }
+func (*ChangeEvent) ProtoMessage()    {}
+func (m *ChangeEvent) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) int, []interface{}) {
+	return _ChangeEvent_OneofMarshaler, _ChangeEvent_OneofUnmarshaler, _ChangeEvent_OneofSizer, nil
+}
+func _ChangeEvent_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
+	m := msg.(*ChangeEvent)
+	m0 := (*openflow_13.ChangeEvent)(m)
+	enc, _, _, _ := m0.XXX_OneofFuncs()
+	return enc(m0, b)
+}
+func _ChangeEvent_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
+	m := msg.(*ChangeEvent)
+	m0 := (*openflow_13.ChangeEvent)(m)
+	_, dec, _, _ := m0.XXX_OneofFuncs()
+	return dec(m0, tag, wire, b)
+}
+func _ChangeEvent_OneofSizer(msg proto.Message) int {
+	m := msg.(*ChangeEvent)
+	m0 := (*openflow_13.ChangeEvent)(m)
+	_, _, size, _ := m0.XXX_OneofFuncs()
+	return size(m0)
+}
+func (m *ChangeEvent) GetId() string { return (*openflow_13.ChangeEvent)(m).GetId() }
+func (m *ChangeEvent) GetPortStatus() *OfpPortStatus {
+	return (*OfpPortStatus)((*openflow_13.ChangeEvent)(m).GetPortStatus())
+}
+
+// ofp_port_no from public import openflow_13.proto
+type OfpPortNo openflow_13.OfpPortNo
+
+var OfpPortNo_name = openflow_13.OfpPortNo_name
+var OfpPortNo_value = openflow_13.OfpPortNo_value
+
+func (x OfpPortNo) String() string { return (openflow_13.OfpPortNo)(x).String() }
+
+const OfpPortNo_OFPP_INVALID = OfpPortNo(openflow_13.OfpPortNo_OFPP_INVALID)
+const OfpPortNo_OFPP_MAX = OfpPortNo(openflow_13.OfpPortNo_OFPP_MAX)
+const OfpPortNo_OFPP_IN_PORT = OfpPortNo(openflow_13.OfpPortNo_OFPP_IN_PORT)
+const OfpPortNo_OFPP_TABLE = OfpPortNo(openflow_13.OfpPortNo_OFPP_TABLE)
+const OfpPortNo_OFPP_NORMAL = OfpPortNo(openflow_13.OfpPortNo_OFPP_NORMAL)
+const OfpPortNo_OFPP_FLOOD = OfpPortNo(openflow_13.OfpPortNo_OFPP_FLOOD)
+const OfpPortNo_OFPP_ALL = OfpPortNo(openflow_13.OfpPortNo_OFPP_ALL)
+const OfpPortNo_OFPP_CONTROLLER = OfpPortNo(openflow_13.OfpPortNo_OFPP_CONTROLLER)
+const OfpPortNo_OFPP_LOCAL = OfpPortNo(openflow_13.OfpPortNo_OFPP_LOCAL)
+const OfpPortNo_OFPP_ANY = OfpPortNo(openflow_13.OfpPortNo_OFPP_ANY)
+
+// ofp_type from public import openflow_13.proto
+type OfpType openflow_13.OfpType
+
+var OfpType_name = openflow_13.OfpType_name
+var OfpType_value = openflow_13.OfpType_value
+
+func (x OfpType) String() string { return (openflow_13.OfpType)(x).String() }
+
+const OfpType_OFPT_HELLO = OfpType(openflow_13.OfpType_OFPT_HELLO)
+const OfpType_OFPT_ERROR = OfpType(openflow_13.OfpType_OFPT_ERROR)
+const OfpType_OFPT_ECHO_REQUEST = OfpType(openflow_13.OfpType_OFPT_ECHO_REQUEST)
+const OfpType_OFPT_ECHO_REPLY = OfpType(openflow_13.OfpType_OFPT_ECHO_REPLY)
+const OfpType_OFPT_EXPERIMENTER = OfpType(openflow_13.OfpType_OFPT_EXPERIMENTER)
+const OfpType_OFPT_FEATURES_REQUEST = OfpType(openflow_13.OfpType_OFPT_FEATURES_REQUEST)
+const OfpType_OFPT_FEATURES_REPLY = OfpType(openflow_13.OfpType_OFPT_FEATURES_REPLY)
+const OfpType_OFPT_GET_CONFIG_REQUEST = OfpType(openflow_13.OfpType_OFPT_GET_CONFIG_REQUEST)
+const OfpType_OFPT_GET_CONFIG_REPLY = OfpType(openflow_13.OfpType_OFPT_GET_CONFIG_REPLY)
+const OfpType_OFPT_SET_CONFIG = OfpType(openflow_13.OfpType_OFPT_SET_CONFIG)
+const OfpType_OFPT_PACKET_IN = OfpType(openflow_13.OfpType_OFPT_PACKET_IN)
+const OfpType_OFPT_FLOW_REMOVED = OfpType(openflow_13.OfpType_OFPT_FLOW_REMOVED)
+const OfpType_OFPT_PORT_STATUS = OfpType(openflow_13.OfpType_OFPT_PORT_STATUS)
+const OfpType_OFPT_PACKET_OUT = OfpType(openflow_13.OfpType_OFPT_PACKET_OUT)
+const OfpType_OFPT_FLOW_MOD = OfpType(openflow_13.OfpType_OFPT_FLOW_MOD)
+const OfpType_OFPT_GROUP_MOD = OfpType(openflow_13.OfpType_OFPT_GROUP_MOD)
+const OfpType_OFPT_PORT_MOD = OfpType(openflow_13.OfpType_OFPT_PORT_MOD)
+const OfpType_OFPT_TABLE_MOD = OfpType(openflow_13.OfpType_OFPT_TABLE_MOD)
+const OfpType_OFPT_MULTIPART_REQUEST = OfpType(openflow_13.OfpType_OFPT_MULTIPART_REQUEST)
+const OfpType_OFPT_MULTIPART_REPLY = OfpType(openflow_13.OfpType_OFPT_MULTIPART_REPLY)
+const OfpType_OFPT_BARRIER_REQUEST = OfpType(openflow_13.OfpType_OFPT_BARRIER_REQUEST)
+const OfpType_OFPT_BARRIER_REPLY = OfpType(openflow_13.OfpType_OFPT_BARRIER_REPLY)
+const OfpType_OFPT_QUEUE_GET_CONFIG_REQUEST = OfpType(openflow_13.OfpType_OFPT_QUEUE_GET_CONFIG_REQUEST)
+const OfpType_OFPT_QUEUE_GET_CONFIG_REPLY = OfpType(openflow_13.OfpType_OFPT_QUEUE_GET_CONFIG_REPLY)
+const OfpType_OFPT_ROLE_REQUEST = OfpType(openflow_13.OfpType_OFPT_ROLE_REQUEST)
+const OfpType_OFPT_ROLE_REPLY = OfpType(openflow_13.OfpType_OFPT_ROLE_REPLY)
+const OfpType_OFPT_GET_ASYNC_REQUEST = OfpType(openflow_13.OfpType_OFPT_GET_ASYNC_REQUEST)
+const OfpType_OFPT_GET_ASYNC_REPLY = OfpType(openflow_13.OfpType_OFPT_GET_ASYNC_REPLY)
+const OfpType_OFPT_SET_ASYNC = OfpType(openflow_13.OfpType_OFPT_SET_ASYNC)
+const OfpType_OFPT_METER_MOD = OfpType(openflow_13.OfpType_OFPT_METER_MOD)
+
+// ofp_hello_elem_type from public import openflow_13.proto
+type OfpHelloElemType openflow_13.OfpHelloElemType
+
+var OfpHelloElemType_name = openflow_13.OfpHelloElemType_name
+var OfpHelloElemType_value = openflow_13.OfpHelloElemType_value
+
+func (x OfpHelloElemType) String() string { return (openflow_13.OfpHelloElemType)(x).String() }
+
+const OfpHelloElemType_OFPHET_INVALID = OfpHelloElemType(openflow_13.OfpHelloElemType_OFPHET_INVALID)
+const OfpHelloElemType_OFPHET_VERSIONBITMAP = OfpHelloElemType(openflow_13.OfpHelloElemType_OFPHET_VERSIONBITMAP)
+
+// ofp_config_flags from public import openflow_13.proto
+type OfpConfigFlags openflow_13.OfpConfigFlags
+
+var OfpConfigFlags_name = openflow_13.OfpConfigFlags_name
+var OfpConfigFlags_value = openflow_13.OfpConfigFlags_value
+
+func (x OfpConfigFlags) String() string { return (openflow_13.OfpConfigFlags)(x).String() }
+
+const OfpConfigFlags_OFPC_FRAG_NORMAL = OfpConfigFlags(openflow_13.OfpConfigFlags_OFPC_FRAG_NORMAL)
+const OfpConfigFlags_OFPC_FRAG_DROP = OfpConfigFlags(openflow_13.OfpConfigFlags_OFPC_FRAG_DROP)
+const OfpConfigFlags_OFPC_FRAG_REASM = OfpConfigFlags(openflow_13.OfpConfigFlags_OFPC_FRAG_REASM)
+const OfpConfigFlags_OFPC_FRAG_MASK = OfpConfigFlags(openflow_13.OfpConfigFlags_OFPC_FRAG_MASK)
+
+// ofp_table_config from public import openflow_13.proto
+type OfpTableConfig openflow_13.OfpTableConfig
+
+var OfpTableConfig_name = openflow_13.OfpTableConfig_name
+var OfpTableConfig_value = openflow_13.OfpTableConfig_value
+
+func (x OfpTableConfig) String() string { return (openflow_13.OfpTableConfig)(x).String() }
+
+const OfpTableConfig_OFPTC_INVALID = OfpTableConfig(openflow_13.OfpTableConfig_OFPTC_INVALID)
+const OfpTableConfig_OFPTC_DEPRECATED_MASK = OfpTableConfig(openflow_13.OfpTableConfig_OFPTC_DEPRECATED_MASK)
+
+// ofp_table from public import openflow_13.proto
+type OfpTable openflow_13.OfpTable
+
+var OfpTable_name = openflow_13.OfpTable_name
+var OfpTable_value = openflow_13.OfpTable_value
+
+func (x OfpTable) String() string { return (openflow_13.OfpTable)(x).String() }
+
+const OfpTable_OFPTT_INVALID = OfpTable(openflow_13.OfpTable_OFPTT_INVALID)
+const OfpTable_OFPTT_MAX = OfpTable(openflow_13.OfpTable_OFPTT_MAX)
+const OfpTable_OFPTT_ALL = OfpTable(openflow_13.OfpTable_OFPTT_ALL)
+
+// ofp_capabilities from public import openflow_13.proto
+type OfpCapabilities openflow_13.OfpCapabilities
+
+var OfpCapabilities_name = openflow_13.OfpCapabilities_name
+var OfpCapabilities_value = openflow_13.OfpCapabilities_value
+
+func (x OfpCapabilities) String() string { return (openflow_13.OfpCapabilities)(x).String() }
+
+const OfpCapabilities_OFPC_INVALID = OfpCapabilities(openflow_13.OfpCapabilities_OFPC_INVALID)
+const OfpCapabilities_OFPC_FLOW_STATS = OfpCapabilities(openflow_13.OfpCapabilities_OFPC_FLOW_STATS)
+const OfpCapabilities_OFPC_TABLE_STATS = OfpCapabilities(openflow_13.OfpCapabilities_OFPC_TABLE_STATS)
+const OfpCapabilities_OFPC_PORT_STATS = OfpCapabilities(openflow_13.OfpCapabilities_OFPC_PORT_STATS)
+const OfpCapabilities_OFPC_GROUP_STATS = OfpCapabilities(openflow_13.OfpCapabilities_OFPC_GROUP_STATS)
+const OfpCapabilities_OFPC_IP_REASM = OfpCapabilities(openflow_13.OfpCapabilities_OFPC_IP_REASM)
+const OfpCapabilities_OFPC_QUEUE_STATS = OfpCapabilities(openflow_13.OfpCapabilities_OFPC_QUEUE_STATS)
+const OfpCapabilities_OFPC_PORT_BLOCKED = OfpCapabilities(openflow_13.OfpCapabilities_OFPC_PORT_BLOCKED)
+
+// ofp_port_config from public import openflow_13.proto
+type OfpPortConfig openflow_13.OfpPortConfig
+
+var OfpPortConfig_name = openflow_13.OfpPortConfig_name
+var OfpPortConfig_value = openflow_13.OfpPortConfig_value
+
+func (x OfpPortConfig) String() string { return (openflow_13.OfpPortConfig)(x).String() }
+
+const OfpPortConfig_OFPPC_INVALID = OfpPortConfig(openflow_13.OfpPortConfig_OFPPC_INVALID)
+const OfpPortConfig_OFPPC_PORT_DOWN = OfpPortConfig(openflow_13.OfpPortConfig_OFPPC_PORT_DOWN)
+const OfpPortConfig_OFPPC_NO_RECV = OfpPortConfig(openflow_13.OfpPortConfig_OFPPC_NO_RECV)
+const OfpPortConfig_OFPPC_NO_FWD = OfpPortConfig(openflow_13.OfpPortConfig_OFPPC_NO_FWD)
+const OfpPortConfig_OFPPC_NO_PACKET_IN = OfpPortConfig(openflow_13.OfpPortConfig_OFPPC_NO_PACKET_IN)
+
+// ofp_port_state from public import openflow_13.proto
+type OfpPortState openflow_13.OfpPortState
+
+var OfpPortState_name = openflow_13.OfpPortState_name
+var OfpPortState_value = openflow_13.OfpPortState_value
+
+func (x OfpPortState) String() string { return (openflow_13.OfpPortState)(x).String() }
+
+const OfpPortState_OFPPS_INVALID = OfpPortState(openflow_13.OfpPortState_OFPPS_INVALID)
+const OfpPortState_OFPPS_LINK_DOWN = OfpPortState(openflow_13.OfpPortState_OFPPS_LINK_DOWN)
+const OfpPortState_OFPPS_BLOCKED = OfpPortState(openflow_13.OfpPortState_OFPPS_BLOCKED)
+const OfpPortState_OFPPS_LIVE = OfpPortState(openflow_13.OfpPortState_OFPPS_LIVE)
+
+// ofp_port_features from public import openflow_13.proto
+type OfpPortFeatures openflow_13.OfpPortFeatures
+
+var OfpPortFeatures_name = openflow_13.OfpPortFeatures_name
+var OfpPortFeatures_value = openflow_13.OfpPortFeatures_value
+
+func (x OfpPortFeatures) String() string { return (openflow_13.OfpPortFeatures)(x).String() }
+
+const OfpPortFeatures_OFPPF_INVALID = OfpPortFeatures(openflow_13.OfpPortFeatures_OFPPF_INVALID)
+const OfpPortFeatures_OFPPF_10MB_HD = OfpPortFeatures(openflow_13.OfpPortFeatures_OFPPF_10MB_HD)
+const OfpPortFeatures_OFPPF_10MB_FD = OfpPortFeatures(openflow_13.OfpPortFeatures_OFPPF_10MB_FD)
+const OfpPortFeatures_OFPPF_100MB_HD = OfpPortFeatures(openflow_13.OfpPortFeatures_OFPPF_100MB_HD)
+const OfpPortFeatures_OFPPF_100MB_FD = OfpPortFeatures(openflow_13.OfpPortFeatures_OFPPF_100MB_FD)
+const OfpPortFeatures_OFPPF_1GB_HD = OfpPortFeatures(openflow_13.OfpPortFeatures_OFPPF_1GB_HD)
+const OfpPortFeatures_OFPPF_1GB_FD = OfpPortFeatures(openflow_13.OfpPortFeatures_OFPPF_1GB_FD)
+const OfpPortFeatures_OFPPF_10GB_FD = OfpPortFeatures(openflow_13.OfpPortFeatures_OFPPF_10GB_FD)
+const OfpPortFeatures_OFPPF_40GB_FD = OfpPortFeatures(openflow_13.OfpPortFeatures_OFPPF_40GB_FD)
+const OfpPortFeatures_OFPPF_100GB_FD = OfpPortFeatures(openflow_13.OfpPortFeatures_OFPPF_100GB_FD)
+const OfpPortFeatures_OFPPF_1TB_FD = OfpPortFeatures(openflow_13.OfpPortFeatures_OFPPF_1TB_FD)
+const OfpPortFeatures_OFPPF_OTHER = OfpPortFeatures(openflow_13.OfpPortFeatures_OFPPF_OTHER)
+const OfpPortFeatures_OFPPF_COPPER = OfpPortFeatures(openflow_13.OfpPortFeatures_OFPPF_COPPER)
+const OfpPortFeatures_OFPPF_FIBER = OfpPortFeatures(openflow_13.OfpPortFeatures_OFPPF_FIBER)
+const OfpPortFeatures_OFPPF_AUTONEG = OfpPortFeatures(openflow_13.OfpPortFeatures_OFPPF_AUTONEG)
+const OfpPortFeatures_OFPPF_PAUSE = OfpPortFeatures(openflow_13.OfpPortFeatures_OFPPF_PAUSE)
+const OfpPortFeatures_OFPPF_PAUSE_ASYM = OfpPortFeatures(openflow_13.OfpPortFeatures_OFPPF_PAUSE_ASYM)
+
+// ofp_port_reason from public import openflow_13.proto
+type OfpPortReason openflow_13.OfpPortReason
+
+var OfpPortReason_name = openflow_13.OfpPortReason_name
+var OfpPortReason_value = openflow_13.OfpPortReason_value
+
+func (x OfpPortReason) String() string { return (openflow_13.OfpPortReason)(x).String() }
+
+const OfpPortReason_OFPPR_ADD = OfpPortReason(openflow_13.OfpPortReason_OFPPR_ADD)
+const OfpPortReason_OFPPR_DELETE = OfpPortReason(openflow_13.OfpPortReason_OFPPR_DELETE)
+const OfpPortReason_OFPPR_MODIFY = OfpPortReason(openflow_13.OfpPortReason_OFPPR_MODIFY)
+
+// ofp_match_type from public import openflow_13.proto
+type OfpMatchType openflow_13.OfpMatchType
+
+var OfpMatchType_name = openflow_13.OfpMatchType_name
+var OfpMatchType_value = openflow_13.OfpMatchType_value
+
+func (x OfpMatchType) String() string { return (openflow_13.OfpMatchType)(x).String() }
+
+const OfpMatchType_OFPMT_STANDARD = OfpMatchType(openflow_13.OfpMatchType_OFPMT_STANDARD)
+const OfpMatchType_OFPMT_OXM = OfpMatchType(openflow_13.OfpMatchType_OFPMT_OXM)
+
+// ofp_oxm_class from public import openflow_13.proto
+type OfpOxmClass openflow_13.OfpOxmClass
+
+var OfpOxmClass_name = openflow_13.OfpOxmClass_name
+var OfpOxmClass_value = openflow_13.OfpOxmClass_value
+
+func (x OfpOxmClass) String() string { return (openflow_13.OfpOxmClass)(x).String() }
+
+const OfpOxmClass_OFPXMC_NXM_0 = OfpOxmClass(openflow_13.OfpOxmClass_OFPXMC_NXM_0)
+const OfpOxmClass_OFPXMC_NXM_1 = OfpOxmClass(openflow_13.OfpOxmClass_OFPXMC_NXM_1)
+const OfpOxmClass_OFPXMC_OPENFLOW_BASIC = OfpOxmClass(openflow_13.OfpOxmClass_OFPXMC_OPENFLOW_BASIC)
+const OfpOxmClass_OFPXMC_EXPERIMENTER = OfpOxmClass(openflow_13.OfpOxmClass_OFPXMC_EXPERIMENTER)
+
+// oxm_ofb_field_types from public import openflow_13.proto
+type OxmOfbFieldTypes openflow_13.OxmOfbFieldTypes
+
+var OxmOfbFieldTypes_name = openflow_13.OxmOfbFieldTypes_name
+var OxmOfbFieldTypes_value = openflow_13.OxmOfbFieldTypes_value
+
+func (x OxmOfbFieldTypes) String() string { return (openflow_13.OxmOfbFieldTypes)(x).String() }
+
+const OxmOfbFieldTypes_OFPXMT_OFB_IN_PORT = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_IN_PORT)
+const OxmOfbFieldTypes_OFPXMT_OFB_IN_PHY_PORT = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_IN_PHY_PORT)
+const OxmOfbFieldTypes_OFPXMT_OFB_METADATA = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_METADATA)
+const OxmOfbFieldTypes_OFPXMT_OFB_ETH_DST = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_ETH_DST)
+const OxmOfbFieldTypes_OFPXMT_OFB_ETH_SRC = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_ETH_SRC)
+const OxmOfbFieldTypes_OFPXMT_OFB_ETH_TYPE = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_ETH_TYPE)
+const OxmOfbFieldTypes_OFPXMT_OFB_VLAN_VID = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_VLAN_VID)
+const OxmOfbFieldTypes_OFPXMT_OFB_VLAN_PCP = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_VLAN_PCP)
+const OxmOfbFieldTypes_OFPXMT_OFB_IP_DSCP = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_IP_DSCP)
+const OxmOfbFieldTypes_OFPXMT_OFB_IP_ECN = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_IP_ECN)
+const OxmOfbFieldTypes_OFPXMT_OFB_IP_PROTO = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_IP_PROTO)
+const OxmOfbFieldTypes_OFPXMT_OFB_IPV4_SRC = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_IPV4_SRC)
+const OxmOfbFieldTypes_OFPXMT_OFB_IPV4_DST = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_IPV4_DST)
+const OxmOfbFieldTypes_OFPXMT_OFB_TCP_SRC = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_TCP_SRC)
+const OxmOfbFieldTypes_OFPXMT_OFB_TCP_DST = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_TCP_DST)
+const OxmOfbFieldTypes_OFPXMT_OFB_UDP_SRC = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_UDP_SRC)
+const OxmOfbFieldTypes_OFPXMT_OFB_UDP_DST = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_UDP_DST)
+const OxmOfbFieldTypes_OFPXMT_OFB_SCTP_SRC = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_SCTP_SRC)
+const OxmOfbFieldTypes_OFPXMT_OFB_SCTP_DST = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_SCTP_DST)
+const OxmOfbFieldTypes_OFPXMT_OFB_ICMPV4_TYPE = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_ICMPV4_TYPE)
+const OxmOfbFieldTypes_OFPXMT_OFB_ICMPV4_CODE = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_ICMPV4_CODE)
+const OxmOfbFieldTypes_OFPXMT_OFB_ARP_OP = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_ARP_OP)
+const OxmOfbFieldTypes_OFPXMT_OFB_ARP_SPA = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_ARP_SPA)
+const OxmOfbFieldTypes_OFPXMT_OFB_ARP_TPA = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_ARP_TPA)
+const OxmOfbFieldTypes_OFPXMT_OFB_ARP_SHA = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_ARP_SHA)
+const OxmOfbFieldTypes_OFPXMT_OFB_ARP_THA = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_ARP_THA)
+const OxmOfbFieldTypes_OFPXMT_OFB_IPV6_SRC = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_IPV6_SRC)
+const OxmOfbFieldTypes_OFPXMT_OFB_IPV6_DST = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_IPV6_DST)
+const OxmOfbFieldTypes_OFPXMT_OFB_IPV6_FLABEL = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_IPV6_FLABEL)
+const OxmOfbFieldTypes_OFPXMT_OFB_ICMPV6_TYPE = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_ICMPV6_TYPE)
+const OxmOfbFieldTypes_OFPXMT_OFB_ICMPV6_CODE = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_ICMPV6_CODE)
+const OxmOfbFieldTypes_OFPXMT_OFB_IPV6_ND_TARGET = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_IPV6_ND_TARGET)
+const OxmOfbFieldTypes_OFPXMT_OFB_IPV6_ND_SLL = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_IPV6_ND_SLL)
+const OxmOfbFieldTypes_OFPXMT_OFB_IPV6_ND_TLL = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_IPV6_ND_TLL)
+const OxmOfbFieldTypes_OFPXMT_OFB_MPLS_LABEL = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_MPLS_LABEL)
+const OxmOfbFieldTypes_OFPXMT_OFB_MPLS_TC = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_MPLS_TC)
+const OxmOfbFieldTypes_OFPXMT_OFB_MPLS_BOS = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_MPLS_BOS)
+const OxmOfbFieldTypes_OFPXMT_OFB_PBB_ISID = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_PBB_ISID)
+const OxmOfbFieldTypes_OFPXMT_OFB_TUNNEL_ID = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_TUNNEL_ID)
+const OxmOfbFieldTypes_OFPXMT_OFB_IPV6_EXTHDR = OxmOfbFieldTypes(openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_IPV6_EXTHDR)
+
+// ofp_vlan_id from public import openflow_13.proto
+type OfpVlanId openflow_13.OfpVlanId
+
+var OfpVlanId_name = openflow_13.OfpVlanId_name
+var OfpVlanId_value = openflow_13.OfpVlanId_value
+
+func (x OfpVlanId) String() string { return (openflow_13.OfpVlanId)(x).String() }
+
+const OfpVlanId_OFPVID_NONE = OfpVlanId(openflow_13.OfpVlanId_OFPVID_NONE)
+const OfpVlanId_OFPVID_PRESENT = OfpVlanId(openflow_13.OfpVlanId_OFPVID_PRESENT)
+
+// ofp_ipv6exthdr_flags from public import openflow_13.proto
+type OfpIpv6ExthdrFlags openflow_13.OfpIpv6ExthdrFlags
+
+var OfpIpv6ExthdrFlags_name = openflow_13.OfpIpv6ExthdrFlags_name
+var OfpIpv6ExthdrFlags_value = openflow_13.OfpIpv6ExthdrFlags_value
+
+func (x OfpIpv6ExthdrFlags) String() string { return (openflow_13.OfpIpv6ExthdrFlags)(x).String() }
+
+const OfpIpv6ExthdrFlags_OFPIEH_INVALID = OfpIpv6ExthdrFlags(openflow_13.OfpIpv6ExthdrFlags_OFPIEH_INVALID)
+const OfpIpv6ExthdrFlags_OFPIEH_NONEXT = OfpIpv6ExthdrFlags(openflow_13.OfpIpv6ExthdrFlags_OFPIEH_NONEXT)
+const OfpIpv6ExthdrFlags_OFPIEH_ESP = OfpIpv6ExthdrFlags(openflow_13.OfpIpv6ExthdrFlags_OFPIEH_ESP)
+const OfpIpv6ExthdrFlags_OFPIEH_AUTH = OfpIpv6ExthdrFlags(openflow_13.OfpIpv6ExthdrFlags_OFPIEH_AUTH)
+const OfpIpv6ExthdrFlags_OFPIEH_DEST = OfpIpv6ExthdrFlags(openflow_13.OfpIpv6ExthdrFlags_OFPIEH_DEST)
+const OfpIpv6ExthdrFlags_OFPIEH_FRAG = OfpIpv6ExthdrFlags(openflow_13.OfpIpv6ExthdrFlags_OFPIEH_FRAG)
+const OfpIpv6ExthdrFlags_OFPIEH_ROUTER = OfpIpv6ExthdrFlags(openflow_13.OfpIpv6ExthdrFlags_OFPIEH_ROUTER)
+const OfpIpv6ExthdrFlags_OFPIEH_HOP = OfpIpv6ExthdrFlags(openflow_13.OfpIpv6ExthdrFlags_OFPIEH_HOP)
+const OfpIpv6ExthdrFlags_OFPIEH_UNREP = OfpIpv6ExthdrFlags(openflow_13.OfpIpv6ExthdrFlags_OFPIEH_UNREP)
+const OfpIpv6ExthdrFlags_OFPIEH_UNSEQ = OfpIpv6ExthdrFlags(openflow_13.OfpIpv6ExthdrFlags_OFPIEH_UNSEQ)
+
+// ofp_action_type from public import openflow_13.proto
+type OfpActionType openflow_13.OfpActionType
+
+var OfpActionType_name = openflow_13.OfpActionType_name
+var OfpActionType_value = openflow_13.OfpActionType_value
+
+func (x OfpActionType) String() string { return (openflow_13.OfpActionType)(x).String() }
+
+const OfpActionType_OFPAT_OUTPUT = OfpActionType(openflow_13.OfpActionType_OFPAT_OUTPUT)
+const OfpActionType_OFPAT_COPY_TTL_OUT = OfpActionType(openflow_13.OfpActionType_OFPAT_COPY_TTL_OUT)
+const OfpActionType_OFPAT_COPY_TTL_IN = OfpActionType(openflow_13.OfpActionType_OFPAT_COPY_TTL_IN)
+const OfpActionType_OFPAT_SET_MPLS_TTL = OfpActionType(openflow_13.OfpActionType_OFPAT_SET_MPLS_TTL)
+const OfpActionType_OFPAT_DEC_MPLS_TTL = OfpActionType(openflow_13.OfpActionType_OFPAT_DEC_MPLS_TTL)
+const OfpActionType_OFPAT_PUSH_VLAN = OfpActionType(openflow_13.OfpActionType_OFPAT_PUSH_VLAN)
+const OfpActionType_OFPAT_POP_VLAN = OfpActionType(openflow_13.OfpActionType_OFPAT_POP_VLAN)
+const OfpActionType_OFPAT_PUSH_MPLS = OfpActionType(openflow_13.OfpActionType_OFPAT_PUSH_MPLS)
+const OfpActionType_OFPAT_POP_MPLS = OfpActionType(openflow_13.OfpActionType_OFPAT_POP_MPLS)
+const OfpActionType_OFPAT_SET_QUEUE = OfpActionType(openflow_13.OfpActionType_OFPAT_SET_QUEUE)
+const OfpActionType_OFPAT_GROUP = OfpActionType(openflow_13.OfpActionType_OFPAT_GROUP)
+const OfpActionType_OFPAT_SET_NW_TTL = OfpActionType(openflow_13.OfpActionType_OFPAT_SET_NW_TTL)
+const OfpActionType_OFPAT_DEC_NW_TTL = OfpActionType(openflow_13.OfpActionType_OFPAT_DEC_NW_TTL)
+const OfpActionType_OFPAT_SET_FIELD = OfpActionType(openflow_13.OfpActionType_OFPAT_SET_FIELD)
+const OfpActionType_OFPAT_PUSH_PBB = OfpActionType(openflow_13.OfpActionType_OFPAT_PUSH_PBB)
+const OfpActionType_OFPAT_POP_PBB = OfpActionType(openflow_13.OfpActionType_OFPAT_POP_PBB)
+const OfpActionType_OFPAT_EXPERIMENTER = OfpActionType(openflow_13.OfpActionType_OFPAT_EXPERIMENTER)
+
+// ofp_controller_max_len from public import openflow_13.proto
+type OfpControllerMaxLen openflow_13.OfpControllerMaxLen
+
+var OfpControllerMaxLen_name = openflow_13.OfpControllerMaxLen_name
+var OfpControllerMaxLen_value = openflow_13.OfpControllerMaxLen_value
+
+func (x OfpControllerMaxLen) String() string { return (openflow_13.OfpControllerMaxLen)(x).String() }
+
+const OfpControllerMaxLen_OFPCML_INVALID = OfpControllerMaxLen(openflow_13.OfpControllerMaxLen_OFPCML_INVALID)
+const OfpControllerMaxLen_OFPCML_MAX = OfpControllerMaxLen(openflow_13.OfpControllerMaxLen_OFPCML_MAX)
+const OfpControllerMaxLen_OFPCML_NO_BUFFER = OfpControllerMaxLen(openflow_13.OfpControllerMaxLen_OFPCML_NO_BUFFER)
+
+// ofp_instruction_type from public import openflow_13.proto
+type OfpInstructionType openflow_13.OfpInstructionType
+
+var OfpInstructionType_name = openflow_13.OfpInstructionType_name
+var OfpInstructionType_value = openflow_13.OfpInstructionType_value
+
+func (x OfpInstructionType) String() string { return (openflow_13.OfpInstructionType)(x).String() }
+
+const OfpInstructionType_OFPIT_INVALID = OfpInstructionType(openflow_13.OfpInstructionType_OFPIT_INVALID)
+const OfpInstructionType_OFPIT_GOTO_TABLE = OfpInstructionType(openflow_13.OfpInstructionType_OFPIT_GOTO_TABLE)
+const OfpInstructionType_OFPIT_WRITE_METADATA = OfpInstructionType(openflow_13.OfpInstructionType_OFPIT_WRITE_METADATA)
+const OfpInstructionType_OFPIT_WRITE_ACTIONS = OfpInstructionType(openflow_13.OfpInstructionType_OFPIT_WRITE_ACTIONS)
+const OfpInstructionType_OFPIT_APPLY_ACTIONS = OfpInstructionType(openflow_13.OfpInstructionType_OFPIT_APPLY_ACTIONS)
+const OfpInstructionType_OFPIT_CLEAR_ACTIONS = OfpInstructionType(openflow_13.OfpInstructionType_OFPIT_CLEAR_ACTIONS)
+const OfpInstructionType_OFPIT_METER = OfpInstructionType(openflow_13.OfpInstructionType_OFPIT_METER)
+const OfpInstructionType_OFPIT_EXPERIMENTER = OfpInstructionType(openflow_13.OfpInstructionType_OFPIT_EXPERIMENTER)
+
+// ofp_flow_mod_command from public import openflow_13.proto
+type OfpFlowModCommand openflow_13.OfpFlowModCommand
+
+var OfpFlowModCommand_name = openflow_13.OfpFlowModCommand_name
+var OfpFlowModCommand_value = openflow_13.OfpFlowModCommand_value
+
+func (x OfpFlowModCommand) String() string { return (openflow_13.OfpFlowModCommand)(x).String() }
+
+const OfpFlowModCommand_OFPFC_ADD = OfpFlowModCommand(openflow_13.OfpFlowModCommand_OFPFC_ADD)
+const OfpFlowModCommand_OFPFC_MODIFY = OfpFlowModCommand(openflow_13.OfpFlowModCommand_OFPFC_MODIFY)
+const OfpFlowModCommand_OFPFC_MODIFY_STRICT = OfpFlowModCommand(openflow_13.OfpFlowModCommand_OFPFC_MODIFY_STRICT)
+const OfpFlowModCommand_OFPFC_DELETE = OfpFlowModCommand(openflow_13.OfpFlowModCommand_OFPFC_DELETE)
+const OfpFlowModCommand_OFPFC_DELETE_STRICT = OfpFlowModCommand(openflow_13.OfpFlowModCommand_OFPFC_DELETE_STRICT)
+
+// ofp_flow_mod_flags from public import openflow_13.proto
+type OfpFlowModFlags openflow_13.OfpFlowModFlags
+
+var OfpFlowModFlags_name = openflow_13.OfpFlowModFlags_name
+var OfpFlowModFlags_value = openflow_13.OfpFlowModFlags_value
+
+func (x OfpFlowModFlags) String() string { return (openflow_13.OfpFlowModFlags)(x).String() }
+
+const OfpFlowModFlags_OFPFF_INVALID = OfpFlowModFlags(openflow_13.OfpFlowModFlags_OFPFF_INVALID)
+const OfpFlowModFlags_OFPFF_SEND_FLOW_REM = OfpFlowModFlags(openflow_13.OfpFlowModFlags_OFPFF_SEND_FLOW_REM)
+const OfpFlowModFlags_OFPFF_CHECK_OVERLAP = OfpFlowModFlags(openflow_13.OfpFlowModFlags_OFPFF_CHECK_OVERLAP)
+const OfpFlowModFlags_OFPFF_RESET_COUNTS = OfpFlowModFlags(openflow_13.OfpFlowModFlags_OFPFF_RESET_COUNTS)
+const OfpFlowModFlags_OFPFF_NO_PKT_COUNTS = OfpFlowModFlags(openflow_13.OfpFlowModFlags_OFPFF_NO_PKT_COUNTS)
+const OfpFlowModFlags_OFPFF_NO_BYT_COUNTS = OfpFlowModFlags(openflow_13.OfpFlowModFlags_OFPFF_NO_BYT_COUNTS)
+
+// ofp_group from public import openflow_13.proto
+type OfpGroup openflow_13.OfpGroup
+
+var OfpGroup_name = openflow_13.OfpGroup_name
+var OfpGroup_value = openflow_13.OfpGroup_value
+
+func (x OfpGroup) String() string { return (openflow_13.OfpGroup)(x).String() }
+
+const OfpGroup_OFPG_INVALID = OfpGroup(openflow_13.OfpGroup_OFPG_INVALID)
+const OfpGroup_OFPG_MAX = OfpGroup(openflow_13.OfpGroup_OFPG_MAX)
+const OfpGroup_OFPG_ALL = OfpGroup(openflow_13.OfpGroup_OFPG_ALL)
+const OfpGroup_OFPG_ANY = OfpGroup(openflow_13.OfpGroup_OFPG_ANY)
+
+// ofp_group_mod_command from public import openflow_13.proto
+type OfpGroupModCommand openflow_13.OfpGroupModCommand
+
+var OfpGroupModCommand_name = openflow_13.OfpGroupModCommand_name
+var OfpGroupModCommand_value = openflow_13.OfpGroupModCommand_value
+
+func (x OfpGroupModCommand) String() string { return (openflow_13.OfpGroupModCommand)(x).String() }
+
+const OfpGroupModCommand_OFPGC_ADD = OfpGroupModCommand(openflow_13.OfpGroupModCommand_OFPGC_ADD)
+const OfpGroupModCommand_OFPGC_MODIFY = OfpGroupModCommand(openflow_13.OfpGroupModCommand_OFPGC_MODIFY)
+const OfpGroupModCommand_OFPGC_DELETE = OfpGroupModCommand(openflow_13.OfpGroupModCommand_OFPGC_DELETE)
+
+// ofp_group_type from public import openflow_13.proto
+type OfpGroupType openflow_13.OfpGroupType
+
+var OfpGroupType_name = openflow_13.OfpGroupType_name
+var OfpGroupType_value = openflow_13.OfpGroupType_value
+
+func (x OfpGroupType) String() string { return (openflow_13.OfpGroupType)(x).String() }
+
+const OfpGroupType_OFPGT_ALL = OfpGroupType(openflow_13.OfpGroupType_OFPGT_ALL)
+const OfpGroupType_OFPGT_SELECT = OfpGroupType(openflow_13.OfpGroupType_OFPGT_SELECT)
+const OfpGroupType_OFPGT_INDIRECT = OfpGroupType(openflow_13.OfpGroupType_OFPGT_INDIRECT)
+const OfpGroupType_OFPGT_FF = OfpGroupType(openflow_13.OfpGroupType_OFPGT_FF)
+
+// ofp_packet_in_reason from public import openflow_13.proto
+type OfpPacketInReason openflow_13.OfpPacketInReason
+
+var OfpPacketInReason_name = openflow_13.OfpPacketInReason_name
+var OfpPacketInReason_value = openflow_13.OfpPacketInReason_value
+
+func (x OfpPacketInReason) String() string { return (openflow_13.OfpPacketInReason)(x).String() }
+
+const OfpPacketInReason_OFPR_NO_MATCH = OfpPacketInReason(openflow_13.OfpPacketInReason_OFPR_NO_MATCH)
+const OfpPacketInReason_OFPR_ACTION = OfpPacketInReason(openflow_13.OfpPacketInReason_OFPR_ACTION)
+const OfpPacketInReason_OFPR_INVALID_TTL = OfpPacketInReason(openflow_13.OfpPacketInReason_OFPR_INVALID_TTL)
+
+// ofp_flow_removed_reason from public import openflow_13.proto
+type OfpFlowRemovedReason openflow_13.OfpFlowRemovedReason
+
+var OfpFlowRemovedReason_name = openflow_13.OfpFlowRemovedReason_name
+var OfpFlowRemovedReason_value = openflow_13.OfpFlowRemovedReason_value
+
+func (x OfpFlowRemovedReason) String() string { return (openflow_13.OfpFlowRemovedReason)(x).String() }
+
+const OfpFlowRemovedReason_OFPRR_IDLE_TIMEOUT = OfpFlowRemovedReason(openflow_13.OfpFlowRemovedReason_OFPRR_IDLE_TIMEOUT)
+const OfpFlowRemovedReason_OFPRR_HARD_TIMEOUT = OfpFlowRemovedReason(openflow_13.OfpFlowRemovedReason_OFPRR_HARD_TIMEOUT)
+const OfpFlowRemovedReason_OFPRR_DELETE = OfpFlowRemovedReason(openflow_13.OfpFlowRemovedReason_OFPRR_DELETE)
+const OfpFlowRemovedReason_OFPRR_GROUP_DELETE = OfpFlowRemovedReason(openflow_13.OfpFlowRemovedReason_OFPRR_GROUP_DELETE)
+const OfpFlowRemovedReason_OFPRR_METER_DELETE = OfpFlowRemovedReason(openflow_13.OfpFlowRemovedReason_OFPRR_METER_DELETE)
+
+// ofp_meter from public import openflow_13.proto
+type OfpMeter openflow_13.OfpMeter
+
+var OfpMeter_name = openflow_13.OfpMeter_name
+var OfpMeter_value = openflow_13.OfpMeter_value
+
+func (x OfpMeter) String() string { return (openflow_13.OfpMeter)(x).String() }
+
+const OfpMeter_OFPM_ZERO = OfpMeter(openflow_13.OfpMeter_OFPM_ZERO)
+const OfpMeter_OFPM_MAX = OfpMeter(openflow_13.OfpMeter_OFPM_MAX)
+const OfpMeter_OFPM_SLOWPATH = OfpMeter(openflow_13.OfpMeter_OFPM_SLOWPATH)
+const OfpMeter_OFPM_CONTROLLER = OfpMeter(openflow_13.OfpMeter_OFPM_CONTROLLER)
+const OfpMeter_OFPM_ALL = OfpMeter(openflow_13.OfpMeter_OFPM_ALL)
+
+// ofp_meter_band_type from public import openflow_13.proto
+type OfpMeterBandType openflow_13.OfpMeterBandType
+
+var OfpMeterBandType_name = openflow_13.OfpMeterBandType_name
+var OfpMeterBandType_value = openflow_13.OfpMeterBandType_value
+
+func (x OfpMeterBandType) String() string { return (openflow_13.OfpMeterBandType)(x).String() }
+
+const OfpMeterBandType_OFPMBT_INVALID = OfpMeterBandType(openflow_13.OfpMeterBandType_OFPMBT_INVALID)
+const OfpMeterBandType_OFPMBT_DROP = OfpMeterBandType(openflow_13.OfpMeterBandType_OFPMBT_DROP)
+const OfpMeterBandType_OFPMBT_DSCP_REMARK = OfpMeterBandType(openflow_13.OfpMeterBandType_OFPMBT_DSCP_REMARK)
+const OfpMeterBandType_OFPMBT_EXPERIMENTER = OfpMeterBandType(openflow_13.OfpMeterBandType_OFPMBT_EXPERIMENTER)
+
+// ofp_meter_mod_command from public import openflow_13.proto
+type OfpMeterModCommand openflow_13.OfpMeterModCommand
+
+var OfpMeterModCommand_name = openflow_13.OfpMeterModCommand_name
+var OfpMeterModCommand_value = openflow_13.OfpMeterModCommand_value
+
+func (x OfpMeterModCommand) String() string { return (openflow_13.OfpMeterModCommand)(x).String() }
+
+const OfpMeterModCommand_OFPMC_ADD = OfpMeterModCommand(openflow_13.OfpMeterModCommand_OFPMC_ADD)
+const OfpMeterModCommand_OFPMC_MODIFY = OfpMeterModCommand(openflow_13.OfpMeterModCommand_OFPMC_MODIFY)
+const OfpMeterModCommand_OFPMC_DELETE = OfpMeterModCommand(openflow_13.OfpMeterModCommand_OFPMC_DELETE)
+
+// ofp_meter_flags from public import openflow_13.proto
+type OfpMeterFlags openflow_13.OfpMeterFlags
+
+var OfpMeterFlags_name = openflow_13.OfpMeterFlags_name
+var OfpMeterFlags_value = openflow_13.OfpMeterFlags_value
+
+func (x OfpMeterFlags) String() string { return (openflow_13.OfpMeterFlags)(x).String() }
+
+const OfpMeterFlags_OFPMF_INVALID = OfpMeterFlags(openflow_13.OfpMeterFlags_OFPMF_INVALID)
+const OfpMeterFlags_OFPMF_KBPS = OfpMeterFlags(openflow_13.OfpMeterFlags_OFPMF_KBPS)
+const OfpMeterFlags_OFPMF_PKTPS = OfpMeterFlags(openflow_13.OfpMeterFlags_OFPMF_PKTPS)
+const OfpMeterFlags_OFPMF_BURST = OfpMeterFlags(openflow_13.OfpMeterFlags_OFPMF_BURST)
+const OfpMeterFlags_OFPMF_STATS = OfpMeterFlags(openflow_13.OfpMeterFlags_OFPMF_STATS)
+
+// ofp_error_type from public import openflow_13.proto
+type OfpErrorType openflow_13.OfpErrorType
+
+var OfpErrorType_name = openflow_13.OfpErrorType_name
+var OfpErrorType_value = openflow_13.OfpErrorType_value
+
+func (x OfpErrorType) String() string { return (openflow_13.OfpErrorType)(x).String() }
+
+const OfpErrorType_OFPET_HELLO_FAILED = OfpErrorType(openflow_13.OfpErrorType_OFPET_HELLO_FAILED)
+const OfpErrorType_OFPET_BAD_REQUEST = OfpErrorType(openflow_13.OfpErrorType_OFPET_BAD_REQUEST)
+const OfpErrorType_OFPET_BAD_ACTION = OfpErrorType(openflow_13.OfpErrorType_OFPET_BAD_ACTION)
+const OfpErrorType_OFPET_BAD_INSTRUCTION = OfpErrorType(openflow_13.OfpErrorType_OFPET_BAD_INSTRUCTION)
+const OfpErrorType_OFPET_BAD_MATCH = OfpErrorType(openflow_13.OfpErrorType_OFPET_BAD_MATCH)
+const OfpErrorType_OFPET_FLOW_MOD_FAILED = OfpErrorType(openflow_13.OfpErrorType_OFPET_FLOW_MOD_FAILED)
+const OfpErrorType_OFPET_GROUP_MOD_FAILED = OfpErrorType(openflow_13.OfpErrorType_OFPET_GROUP_MOD_FAILED)
+const OfpErrorType_OFPET_PORT_MOD_FAILED = OfpErrorType(openflow_13.OfpErrorType_OFPET_PORT_MOD_FAILED)
+const OfpErrorType_OFPET_TABLE_MOD_FAILED = OfpErrorType(openflow_13.OfpErrorType_OFPET_TABLE_MOD_FAILED)
+const OfpErrorType_OFPET_QUEUE_OP_FAILED = OfpErrorType(openflow_13.OfpErrorType_OFPET_QUEUE_OP_FAILED)
+const OfpErrorType_OFPET_SWITCH_CONFIG_FAILED = OfpErrorType(openflow_13.OfpErrorType_OFPET_SWITCH_CONFIG_FAILED)
+const OfpErrorType_OFPET_ROLE_REQUEST_FAILED = OfpErrorType(openflow_13.OfpErrorType_OFPET_ROLE_REQUEST_FAILED)
+const OfpErrorType_OFPET_METER_MOD_FAILED = OfpErrorType(openflow_13.OfpErrorType_OFPET_METER_MOD_FAILED)
+const OfpErrorType_OFPET_TABLE_FEATURES_FAILED = OfpErrorType(openflow_13.OfpErrorType_OFPET_TABLE_FEATURES_FAILED)
+const OfpErrorType_OFPET_EXPERIMENTER = OfpErrorType(openflow_13.OfpErrorType_OFPET_EXPERIMENTER)
+
+// ofp_hello_failed_code from public import openflow_13.proto
+type OfpHelloFailedCode openflow_13.OfpHelloFailedCode
+
+var OfpHelloFailedCode_name = openflow_13.OfpHelloFailedCode_name
+var OfpHelloFailedCode_value = openflow_13.OfpHelloFailedCode_value
+
+func (x OfpHelloFailedCode) String() string { return (openflow_13.OfpHelloFailedCode)(x).String() }
+
+const OfpHelloFailedCode_OFPHFC_INCOMPATIBLE = OfpHelloFailedCode(openflow_13.OfpHelloFailedCode_OFPHFC_INCOMPATIBLE)
+const OfpHelloFailedCode_OFPHFC_EPERM = OfpHelloFailedCode(openflow_13.OfpHelloFailedCode_OFPHFC_EPERM)
+
+// ofp_bad_request_code from public import openflow_13.proto
+type OfpBadRequestCode openflow_13.OfpBadRequestCode
+
+var OfpBadRequestCode_name = openflow_13.OfpBadRequestCode_name
+var OfpBadRequestCode_value = openflow_13.OfpBadRequestCode_value
+
+func (x OfpBadRequestCode) String() string { return (openflow_13.OfpBadRequestCode)(x).String() }
+
+const OfpBadRequestCode_OFPBRC_BAD_VERSION = OfpBadRequestCode(openflow_13.OfpBadRequestCode_OFPBRC_BAD_VERSION)
+const OfpBadRequestCode_OFPBRC_BAD_TYPE = OfpBadRequestCode(openflow_13.OfpBadRequestCode_OFPBRC_BAD_TYPE)
+const OfpBadRequestCode_OFPBRC_BAD_MULTIPART = OfpBadRequestCode(openflow_13.OfpBadRequestCode_OFPBRC_BAD_MULTIPART)
+const OfpBadRequestCode_OFPBRC_BAD_EXPERIMENTER = OfpBadRequestCode(openflow_13.OfpBadRequestCode_OFPBRC_BAD_EXPERIMENTER)
+const OfpBadRequestCode_OFPBRC_BAD_EXP_TYPE = OfpBadRequestCode(openflow_13.OfpBadRequestCode_OFPBRC_BAD_EXP_TYPE)
+const OfpBadRequestCode_OFPBRC_EPERM = OfpBadRequestCode(openflow_13.OfpBadRequestCode_OFPBRC_EPERM)
+const OfpBadRequestCode_OFPBRC_BAD_LEN = OfpBadRequestCode(openflow_13.OfpBadRequestCode_OFPBRC_BAD_LEN)
+const OfpBadRequestCode_OFPBRC_BUFFER_EMPTY = OfpBadRequestCode(openflow_13.OfpBadRequestCode_OFPBRC_BUFFER_EMPTY)
+const OfpBadRequestCode_OFPBRC_BUFFER_UNKNOWN = OfpBadRequestCode(openflow_13.OfpBadRequestCode_OFPBRC_BUFFER_UNKNOWN)
+const OfpBadRequestCode_OFPBRC_BAD_TABLE_ID = OfpBadRequestCode(openflow_13.OfpBadRequestCode_OFPBRC_BAD_TABLE_ID)
+const OfpBadRequestCode_OFPBRC_IS_SLAVE = OfpBadRequestCode(openflow_13.OfpBadRequestCode_OFPBRC_IS_SLAVE)
+const OfpBadRequestCode_OFPBRC_BAD_PORT = OfpBadRequestCode(openflow_13.OfpBadRequestCode_OFPBRC_BAD_PORT)
+const OfpBadRequestCode_OFPBRC_BAD_PACKET = OfpBadRequestCode(openflow_13.OfpBadRequestCode_OFPBRC_BAD_PACKET)
+const OfpBadRequestCode_OFPBRC_MULTIPART_BUFFER_OVERFLOW = OfpBadRequestCode(openflow_13.OfpBadRequestCode_OFPBRC_MULTIPART_BUFFER_OVERFLOW)
+
+// ofp_bad_action_code from public import openflow_13.proto
+type OfpBadActionCode openflow_13.OfpBadActionCode
+
+var OfpBadActionCode_name = openflow_13.OfpBadActionCode_name
+var OfpBadActionCode_value = openflow_13.OfpBadActionCode_value
+
+func (x OfpBadActionCode) String() string { return (openflow_13.OfpBadActionCode)(x).String() }
+
+const OfpBadActionCode_OFPBAC_BAD_TYPE = OfpBadActionCode(openflow_13.OfpBadActionCode_OFPBAC_BAD_TYPE)
+const OfpBadActionCode_OFPBAC_BAD_LEN = OfpBadActionCode(openflow_13.OfpBadActionCode_OFPBAC_BAD_LEN)
+const OfpBadActionCode_OFPBAC_BAD_EXPERIMENTER = OfpBadActionCode(openflow_13.OfpBadActionCode_OFPBAC_BAD_EXPERIMENTER)
+const OfpBadActionCode_OFPBAC_BAD_EXP_TYPE = OfpBadActionCode(openflow_13.OfpBadActionCode_OFPBAC_BAD_EXP_TYPE)
+const OfpBadActionCode_OFPBAC_BAD_OUT_PORT = OfpBadActionCode(openflow_13.OfpBadActionCode_OFPBAC_BAD_OUT_PORT)
+const OfpBadActionCode_OFPBAC_BAD_ARGUMENT = OfpBadActionCode(openflow_13.OfpBadActionCode_OFPBAC_BAD_ARGUMENT)
+const OfpBadActionCode_OFPBAC_EPERM = OfpBadActionCode(openflow_13.OfpBadActionCode_OFPBAC_EPERM)
+const OfpBadActionCode_OFPBAC_TOO_MANY = OfpBadActionCode(openflow_13.OfpBadActionCode_OFPBAC_TOO_MANY)
+const OfpBadActionCode_OFPBAC_BAD_QUEUE = OfpBadActionCode(openflow_13.OfpBadActionCode_OFPBAC_BAD_QUEUE)
+const OfpBadActionCode_OFPBAC_BAD_OUT_GROUP = OfpBadActionCode(openflow_13.OfpBadActionCode_OFPBAC_BAD_OUT_GROUP)
+const OfpBadActionCode_OFPBAC_MATCH_INCONSISTENT = OfpBadActionCode(openflow_13.OfpBadActionCode_OFPBAC_MATCH_INCONSISTENT)
+const OfpBadActionCode_OFPBAC_UNSUPPORTED_ORDER = OfpBadActionCode(openflow_13.OfpBadActionCode_OFPBAC_UNSUPPORTED_ORDER)
+const OfpBadActionCode_OFPBAC_BAD_TAG = OfpBadActionCode(openflow_13.OfpBadActionCode_OFPBAC_BAD_TAG)
+const OfpBadActionCode_OFPBAC_BAD_SET_TYPE = OfpBadActionCode(openflow_13.OfpBadActionCode_OFPBAC_BAD_SET_TYPE)
+const OfpBadActionCode_OFPBAC_BAD_SET_LEN = OfpBadActionCode(openflow_13.OfpBadActionCode_OFPBAC_BAD_SET_LEN)
+const OfpBadActionCode_OFPBAC_BAD_SET_ARGUMENT = OfpBadActionCode(openflow_13.OfpBadActionCode_OFPBAC_BAD_SET_ARGUMENT)
+
+// ofp_bad_instruction_code from public import openflow_13.proto
+type OfpBadInstructionCode openflow_13.OfpBadInstructionCode
+
+var OfpBadInstructionCode_name = openflow_13.OfpBadInstructionCode_name
+var OfpBadInstructionCode_value = openflow_13.OfpBadInstructionCode_value
+
+func (x OfpBadInstructionCode) String() string { return (openflow_13.OfpBadInstructionCode)(x).String() }
+
+const OfpBadInstructionCode_OFPBIC_UNKNOWN_INST = OfpBadInstructionCode(openflow_13.OfpBadInstructionCode_OFPBIC_UNKNOWN_INST)
+const OfpBadInstructionCode_OFPBIC_UNSUP_INST = OfpBadInstructionCode(openflow_13.OfpBadInstructionCode_OFPBIC_UNSUP_INST)
+const OfpBadInstructionCode_OFPBIC_BAD_TABLE_ID = OfpBadInstructionCode(openflow_13.OfpBadInstructionCode_OFPBIC_BAD_TABLE_ID)
+const OfpBadInstructionCode_OFPBIC_UNSUP_METADATA = OfpBadInstructionCode(openflow_13.OfpBadInstructionCode_OFPBIC_UNSUP_METADATA)
+const OfpBadInstructionCode_OFPBIC_UNSUP_METADATA_MASK = OfpBadInstructionCode(openflow_13.OfpBadInstructionCode_OFPBIC_UNSUP_METADATA_MASK)
+const OfpBadInstructionCode_OFPBIC_BAD_EXPERIMENTER = OfpBadInstructionCode(openflow_13.OfpBadInstructionCode_OFPBIC_BAD_EXPERIMENTER)
+const OfpBadInstructionCode_OFPBIC_BAD_EXP_TYPE = OfpBadInstructionCode(openflow_13.OfpBadInstructionCode_OFPBIC_BAD_EXP_TYPE)
+const OfpBadInstructionCode_OFPBIC_BAD_LEN = OfpBadInstructionCode(openflow_13.OfpBadInstructionCode_OFPBIC_BAD_LEN)
+const OfpBadInstructionCode_OFPBIC_EPERM = OfpBadInstructionCode(openflow_13.OfpBadInstructionCode_OFPBIC_EPERM)
+
+// ofp_bad_match_code from public import openflow_13.proto
+type OfpBadMatchCode openflow_13.OfpBadMatchCode
+
+var OfpBadMatchCode_name = openflow_13.OfpBadMatchCode_name
+var OfpBadMatchCode_value = openflow_13.OfpBadMatchCode_value
+
+func (x OfpBadMatchCode) String() string { return (openflow_13.OfpBadMatchCode)(x).String() }
+
+const OfpBadMatchCode_OFPBMC_BAD_TYPE = OfpBadMatchCode(openflow_13.OfpBadMatchCode_OFPBMC_BAD_TYPE)
+const OfpBadMatchCode_OFPBMC_BAD_LEN = OfpBadMatchCode(openflow_13.OfpBadMatchCode_OFPBMC_BAD_LEN)
+const OfpBadMatchCode_OFPBMC_BAD_TAG = OfpBadMatchCode(openflow_13.OfpBadMatchCode_OFPBMC_BAD_TAG)
+const OfpBadMatchCode_OFPBMC_BAD_DL_ADDR_MASK = OfpBadMatchCode(openflow_13.OfpBadMatchCode_OFPBMC_BAD_DL_ADDR_MASK)
+const OfpBadMatchCode_OFPBMC_BAD_NW_ADDR_MASK = OfpBadMatchCode(openflow_13.OfpBadMatchCode_OFPBMC_BAD_NW_ADDR_MASK)
+const OfpBadMatchCode_OFPBMC_BAD_WILDCARDS = OfpBadMatchCode(openflow_13.OfpBadMatchCode_OFPBMC_BAD_WILDCARDS)
+const OfpBadMatchCode_OFPBMC_BAD_FIELD = OfpBadMatchCode(openflow_13.OfpBadMatchCode_OFPBMC_BAD_FIELD)
+const OfpBadMatchCode_OFPBMC_BAD_VALUE = OfpBadMatchCode(openflow_13.OfpBadMatchCode_OFPBMC_BAD_VALUE)
+const OfpBadMatchCode_OFPBMC_BAD_MASK = OfpBadMatchCode(openflow_13.OfpBadMatchCode_OFPBMC_BAD_MASK)
+const OfpBadMatchCode_OFPBMC_BAD_PREREQ = OfpBadMatchCode(openflow_13.OfpBadMatchCode_OFPBMC_BAD_PREREQ)
+const OfpBadMatchCode_OFPBMC_DUP_FIELD = OfpBadMatchCode(openflow_13.OfpBadMatchCode_OFPBMC_DUP_FIELD)
+const OfpBadMatchCode_OFPBMC_EPERM = OfpBadMatchCode(openflow_13.OfpBadMatchCode_OFPBMC_EPERM)
+
+// ofp_flow_mod_failed_code from public import openflow_13.proto
+type OfpFlowModFailedCode openflow_13.OfpFlowModFailedCode
+
+var OfpFlowModFailedCode_name = openflow_13.OfpFlowModFailedCode_name
+var OfpFlowModFailedCode_value = openflow_13.OfpFlowModFailedCode_value
+
+func (x OfpFlowModFailedCode) String() string { return (openflow_13.OfpFlowModFailedCode)(x).String() }
+
+const OfpFlowModFailedCode_OFPFMFC_UNKNOWN = OfpFlowModFailedCode(openflow_13.OfpFlowModFailedCode_OFPFMFC_UNKNOWN)
+const OfpFlowModFailedCode_OFPFMFC_TABLE_FULL = OfpFlowModFailedCode(openflow_13.OfpFlowModFailedCode_OFPFMFC_TABLE_FULL)
+const OfpFlowModFailedCode_OFPFMFC_BAD_TABLE_ID = OfpFlowModFailedCode(openflow_13.OfpFlowModFailedCode_OFPFMFC_BAD_TABLE_ID)
+const OfpFlowModFailedCode_OFPFMFC_OVERLAP = OfpFlowModFailedCode(openflow_13.OfpFlowModFailedCode_OFPFMFC_OVERLAP)
+const OfpFlowModFailedCode_OFPFMFC_EPERM = OfpFlowModFailedCode(openflow_13.OfpFlowModFailedCode_OFPFMFC_EPERM)
+const OfpFlowModFailedCode_OFPFMFC_BAD_TIMEOUT = OfpFlowModFailedCode(openflow_13.OfpFlowModFailedCode_OFPFMFC_BAD_TIMEOUT)
+const OfpFlowModFailedCode_OFPFMFC_BAD_COMMAND = OfpFlowModFailedCode(openflow_13.OfpFlowModFailedCode_OFPFMFC_BAD_COMMAND)
+const OfpFlowModFailedCode_OFPFMFC_BAD_FLAGS = OfpFlowModFailedCode(openflow_13.OfpFlowModFailedCode_OFPFMFC_BAD_FLAGS)
+
+// ofp_group_mod_failed_code from public import openflow_13.proto
+type OfpGroupModFailedCode openflow_13.OfpGroupModFailedCode
+
+var OfpGroupModFailedCode_name = openflow_13.OfpGroupModFailedCode_name
+var OfpGroupModFailedCode_value = openflow_13.OfpGroupModFailedCode_value
+
+func (x OfpGroupModFailedCode) String() string { return (openflow_13.OfpGroupModFailedCode)(x).String() }
+
+const OfpGroupModFailedCode_OFPGMFC_GROUP_EXISTS = OfpGroupModFailedCode(openflow_13.OfpGroupModFailedCode_OFPGMFC_GROUP_EXISTS)
+const OfpGroupModFailedCode_OFPGMFC_INVALID_GROUP = OfpGroupModFailedCode(openflow_13.OfpGroupModFailedCode_OFPGMFC_INVALID_GROUP)
+const OfpGroupModFailedCode_OFPGMFC_WEIGHT_UNSUPPORTED = OfpGroupModFailedCode(openflow_13.OfpGroupModFailedCode_OFPGMFC_WEIGHT_UNSUPPORTED)
+const OfpGroupModFailedCode_OFPGMFC_OUT_OF_GROUPS = OfpGroupModFailedCode(openflow_13.OfpGroupModFailedCode_OFPGMFC_OUT_OF_GROUPS)
+const OfpGroupModFailedCode_OFPGMFC_OUT_OF_BUCKETS = OfpGroupModFailedCode(openflow_13.OfpGroupModFailedCode_OFPGMFC_OUT_OF_BUCKETS)
+const OfpGroupModFailedCode_OFPGMFC_CHAINING_UNSUPPORTED = OfpGroupModFailedCode(openflow_13.OfpGroupModFailedCode_OFPGMFC_CHAINING_UNSUPPORTED)
+const OfpGroupModFailedCode_OFPGMFC_WATCH_UNSUPPORTED = OfpGroupModFailedCode(openflow_13.OfpGroupModFailedCode_OFPGMFC_WATCH_UNSUPPORTED)
+const OfpGroupModFailedCode_OFPGMFC_LOOP = OfpGroupModFailedCode(openflow_13.OfpGroupModFailedCode_OFPGMFC_LOOP)
+const OfpGroupModFailedCode_OFPGMFC_UNKNOWN_GROUP = OfpGroupModFailedCode(openflow_13.OfpGroupModFailedCode_OFPGMFC_UNKNOWN_GROUP)
+const OfpGroupModFailedCode_OFPGMFC_CHAINED_GROUP = OfpGroupModFailedCode(openflow_13.OfpGroupModFailedCode_OFPGMFC_CHAINED_GROUP)
+const OfpGroupModFailedCode_OFPGMFC_BAD_TYPE = OfpGroupModFailedCode(openflow_13.OfpGroupModFailedCode_OFPGMFC_BAD_TYPE)
+const OfpGroupModFailedCode_OFPGMFC_BAD_COMMAND = OfpGroupModFailedCode(openflow_13.OfpGroupModFailedCode_OFPGMFC_BAD_COMMAND)
+const OfpGroupModFailedCode_OFPGMFC_BAD_BUCKET = OfpGroupModFailedCode(openflow_13.OfpGroupModFailedCode_OFPGMFC_BAD_BUCKET)
+const OfpGroupModFailedCode_OFPGMFC_BAD_WATCH = OfpGroupModFailedCode(openflow_13.OfpGroupModFailedCode_OFPGMFC_BAD_WATCH)
+const OfpGroupModFailedCode_OFPGMFC_EPERM = OfpGroupModFailedCode(openflow_13.OfpGroupModFailedCode_OFPGMFC_EPERM)
+
+// ofp_port_mod_failed_code from public import openflow_13.proto
+type OfpPortModFailedCode openflow_13.OfpPortModFailedCode
+
+var OfpPortModFailedCode_name = openflow_13.OfpPortModFailedCode_name
+var OfpPortModFailedCode_value = openflow_13.OfpPortModFailedCode_value
+
+func (x OfpPortModFailedCode) String() string { return (openflow_13.OfpPortModFailedCode)(x).String() }
+
+const OfpPortModFailedCode_OFPPMFC_BAD_PORT = OfpPortModFailedCode(openflow_13.OfpPortModFailedCode_OFPPMFC_BAD_PORT)
+const OfpPortModFailedCode_OFPPMFC_BAD_HW_ADDR = OfpPortModFailedCode(openflow_13.OfpPortModFailedCode_OFPPMFC_BAD_HW_ADDR)
+const OfpPortModFailedCode_OFPPMFC_BAD_CONFIG = OfpPortModFailedCode(openflow_13.OfpPortModFailedCode_OFPPMFC_BAD_CONFIG)
+const OfpPortModFailedCode_OFPPMFC_BAD_ADVERTISE = OfpPortModFailedCode(openflow_13.OfpPortModFailedCode_OFPPMFC_BAD_ADVERTISE)
+const OfpPortModFailedCode_OFPPMFC_EPERM = OfpPortModFailedCode(openflow_13.OfpPortModFailedCode_OFPPMFC_EPERM)
+
+// ofp_table_mod_failed_code from public import openflow_13.proto
+type OfpTableModFailedCode openflow_13.OfpTableModFailedCode
+
+var OfpTableModFailedCode_name = openflow_13.OfpTableModFailedCode_name
+var OfpTableModFailedCode_value = openflow_13.OfpTableModFailedCode_value
+
+func (x OfpTableModFailedCode) String() string { return (openflow_13.OfpTableModFailedCode)(x).String() }
+
+const OfpTableModFailedCode_OFPTMFC_BAD_TABLE = OfpTableModFailedCode(openflow_13.OfpTableModFailedCode_OFPTMFC_BAD_TABLE)
+const OfpTableModFailedCode_OFPTMFC_BAD_CONFIG = OfpTableModFailedCode(openflow_13.OfpTableModFailedCode_OFPTMFC_BAD_CONFIG)
+const OfpTableModFailedCode_OFPTMFC_EPERM = OfpTableModFailedCode(openflow_13.OfpTableModFailedCode_OFPTMFC_EPERM)
+
+// ofp_queue_op_failed_code from public import openflow_13.proto
+type OfpQueueOpFailedCode openflow_13.OfpQueueOpFailedCode
+
+var OfpQueueOpFailedCode_name = openflow_13.OfpQueueOpFailedCode_name
+var OfpQueueOpFailedCode_value = openflow_13.OfpQueueOpFailedCode_value
+
+func (x OfpQueueOpFailedCode) String() string { return (openflow_13.OfpQueueOpFailedCode)(x).String() }
+
+const OfpQueueOpFailedCode_OFPQOFC_BAD_PORT = OfpQueueOpFailedCode(openflow_13.OfpQueueOpFailedCode_OFPQOFC_BAD_PORT)
+const OfpQueueOpFailedCode_OFPQOFC_BAD_QUEUE = OfpQueueOpFailedCode(openflow_13.OfpQueueOpFailedCode_OFPQOFC_BAD_QUEUE)
+const OfpQueueOpFailedCode_OFPQOFC_EPERM = OfpQueueOpFailedCode(openflow_13.OfpQueueOpFailedCode_OFPQOFC_EPERM)
+
+// ofp_switch_config_failed_code from public import openflow_13.proto
+type OfpSwitchConfigFailedCode openflow_13.OfpSwitchConfigFailedCode
+
+var OfpSwitchConfigFailedCode_name = openflow_13.OfpSwitchConfigFailedCode_name
+var OfpSwitchConfigFailedCode_value = openflow_13.OfpSwitchConfigFailedCode_value
+
+func (x OfpSwitchConfigFailedCode) String() string {
+	return (openflow_13.OfpSwitchConfigFailedCode)(x).String()
+}
+
+const OfpSwitchConfigFailedCode_OFPSCFC_BAD_FLAGS = OfpSwitchConfigFailedCode(openflow_13.OfpSwitchConfigFailedCode_OFPSCFC_BAD_FLAGS)
+const OfpSwitchConfigFailedCode_OFPSCFC_BAD_LEN = OfpSwitchConfigFailedCode(openflow_13.OfpSwitchConfigFailedCode_OFPSCFC_BAD_LEN)
+const OfpSwitchConfigFailedCode_OFPSCFC_EPERM = OfpSwitchConfigFailedCode(openflow_13.OfpSwitchConfigFailedCode_OFPSCFC_EPERM)
+
+// ofp_role_request_failed_code from public import openflow_13.proto
+type OfpRoleRequestFailedCode openflow_13.OfpRoleRequestFailedCode
+
+var OfpRoleRequestFailedCode_name = openflow_13.OfpRoleRequestFailedCode_name
+var OfpRoleRequestFailedCode_value = openflow_13.OfpRoleRequestFailedCode_value
+
+func (x OfpRoleRequestFailedCode) String() string {
+	return (openflow_13.OfpRoleRequestFailedCode)(x).String()
+}
+
+const OfpRoleRequestFailedCode_OFPRRFC_STALE = OfpRoleRequestFailedCode(openflow_13.OfpRoleRequestFailedCode_OFPRRFC_STALE)
+const OfpRoleRequestFailedCode_OFPRRFC_UNSUP = OfpRoleRequestFailedCode(openflow_13.OfpRoleRequestFailedCode_OFPRRFC_UNSUP)
+const OfpRoleRequestFailedCode_OFPRRFC_BAD_ROLE = OfpRoleRequestFailedCode(openflow_13.OfpRoleRequestFailedCode_OFPRRFC_BAD_ROLE)
+
+// ofp_meter_mod_failed_code from public import openflow_13.proto
+type OfpMeterModFailedCode openflow_13.OfpMeterModFailedCode
+
+var OfpMeterModFailedCode_name = openflow_13.OfpMeterModFailedCode_name
+var OfpMeterModFailedCode_value = openflow_13.OfpMeterModFailedCode_value
+
+func (x OfpMeterModFailedCode) String() string { return (openflow_13.OfpMeterModFailedCode)(x).String() }
+
+const OfpMeterModFailedCode_OFPMMFC_UNKNOWN = OfpMeterModFailedCode(openflow_13.OfpMeterModFailedCode_OFPMMFC_UNKNOWN)
+const OfpMeterModFailedCode_OFPMMFC_METER_EXISTS = OfpMeterModFailedCode(openflow_13.OfpMeterModFailedCode_OFPMMFC_METER_EXISTS)
+const OfpMeterModFailedCode_OFPMMFC_INVALID_METER = OfpMeterModFailedCode(openflow_13.OfpMeterModFailedCode_OFPMMFC_INVALID_METER)
+const OfpMeterModFailedCode_OFPMMFC_UNKNOWN_METER = OfpMeterModFailedCode(openflow_13.OfpMeterModFailedCode_OFPMMFC_UNKNOWN_METER)
+const OfpMeterModFailedCode_OFPMMFC_BAD_COMMAND = OfpMeterModFailedCode(openflow_13.OfpMeterModFailedCode_OFPMMFC_BAD_COMMAND)
+const OfpMeterModFailedCode_OFPMMFC_BAD_FLAGS = OfpMeterModFailedCode(openflow_13.OfpMeterModFailedCode_OFPMMFC_BAD_FLAGS)
+const OfpMeterModFailedCode_OFPMMFC_BAD_RATE = OfpMeterModFailedCode(openflow_13.OfpMeterModFailedCode_OFPMMFC_BAD_RATE)
+const OfpMeterModFailedCode_OFPMMFC_BAD_BURST = OfpMeterModFailedCode(openflow_13.OfpMeterModFailedCode_OFPMMFC_BAD_BURST)
+const OfpMeterModFailedCode_OFPMMFC_BAD_BAND = OfpMeterModFailedCode(openflow_13.OfpMeterModFailedCode_OFPMMFC_BAD_BAND)
+const OfpMeterModFailedCode_OFPMMFC_BAD_BAND_VALUE = OfpMeterModFailedCode(openflow_13.OfpMeterModFailedCode_OFPMMFC_BAD_BAND_VALUE)
+const OfpMeterModFailedCode_OFPMMFC_OUT_OF_METERS = OfpMeterModFailedCode(openflow_13.OfpMeterModFailedCode_OFPMMFC_OUT_OF_METERS)
+const OfpMeterModFailedCode_OFPMMFC_OUT_OF_BANDS = OfpMeterModFailedCode(openflow_13.OfpMeterModFailedCode_OFPMMFC_OUT_OF_BANDS)
+
+// ofp_table_features_failed_code from public import openflow_13.proto
+type OfpTableFeaturesFailedCode openflow_13.OfpTableFeaturesFailedCode
+
+var OfpTableFeaturesFailedCode_name = openflow_13.OfpTableFeaturesFailedCode_name
+var OfpTableFeaturesFailedCode_value = openflow_13.OfpTableFeaturesFailedCode_value
+
+func (x OfpTableFeaturesFailedCode) String() string {
+	return (openflow_13.OfpTableFeaturesFailedCode)(x).String()
+}
+
+const OfpTableFeaturesFailedCode_OFPTFFC_BAD_TABLE = OfpTableFeaturesFailedCode(openflow_13.OfpTableFeaturesFailedCode_OFPTFFC_BAD_TABLE)
+const OfpTableFeaturesFailedCode_OFPTFFC_BAD_METADATA = OfpTableFeaturesFailedCode(openflow_13.OfpTableFeaturesFailedCode_OFPTFFC_BAD_METADATA)
+const OfpTableFeaturesFailedCode_OFPTFFC_BAD_TYPE = OfpTableFeaturesFailedCode(openflow_13.OfpTableFeaturesFailedCode_OFPTFFC_BAD_TYPE)
+const OfpTableFeaturesFailedCode_OFPTFFC_BAD_LEN = OfpTableFeaturesFailedCode(openflow_13.OfpTableFeaturesFailedCode_OFPTFFC_BAD_LEN)
+const OfpTableFeaturesFailedCode_OFPTFFC_BAD_ARGUMENT = OfpTableFeaturesFailedCode(openflow_13.OfpTableFeaturesFailedCode_OFPTFFC_BAD_ARGUMENT)
+const OfpTableFeaturesFailedCode_OFPTFFC_EPERM = OfpTableFeaturesFailedCode(openflow_13.OfpTableFeaturesFailedCode_OFPTFFC_EPERM)
+
+// ofp_multipart_type from public import openflow_13.proto
+type OfpMultipartType openflow_13.OfpMultipartType
+
+var OfpMultipartType_name = openflow_13.OfpMultipartType_name
+var OfpMultipartType_value = openflow_13.OfpMultipartType_value
+
+func (x OfpMultipartType) String() string { return (openflow_13.OfpMultipartType)(x).String() }
+
+const OfpMultipartType_OFPMP_DESC = OfpMultipartType(openflow_13.OfpMultipartType_OFPMP_DESC)
+const OfpMultipartType_OFPMP_FLOW = OfpMultipartType(openflow_13.OfpMultipartType_OFPMP_FLOW)
+const OfpMultipartType_OFPMP_AGGREGATE = OfpMultipartType(openflow_13.OfpMultipartType_OFPMP_AGGREGATE)
+const OfpMultipartType_OFPMP_TABLE = OfpMultipartType(openflow_13.OfpMultipartType_OFPMP_TABLE)
+const OfpMultipartType_OFPMP_PORT_STATS = OfpMultipartType(openflow_13.OfpMultipartType_OFPMP_PORT_STATS)
+const OfpMultipartType_OFPMP_QUEUE = OfpMultipartType(openflow_13.OfpMultipartType_OFPMP_QUEUE)
+const OfpMultipartType_OFPMP_GROUP = OfpMultipartType(openflow_13.OfpMultipartType_OFPMP_GROUP)
+const OfpMultipartType_OFPMP_GROUP_DESC = OfpMultipartType(openflow_13.OfpMultipartType_OFPMP_GROUP_DESC)
+const OfpMultipartType_OFPMP_GROUP_FEATURES = OfpMultipartType(openflow_13.OfpMultipartType_OFPMP_GROUP_FEATURES)
+const OfpMultipartType_OFPMP_METER = OfpMultipartType(openflow_13.OfpMultipartType_OFPMP_METER)
+const OfpMultipartType_OFPMP_METER_CONFIG = OfpMultipartType(openflow_13.OfpMultipartType_OFPMP_METER_CONFIG)
+const OfpMultipartType_OFPMP_METER_FEATURES = OfpMultipartType(openflow_13.OfpMultipartType_OFPMP_METER_FEATURES)
+const OfpMultipartType_OFPMP_TABLE_FEATURES = OfpMultipartType(openflow_13.OfpMultipartType_OFPMP_TABLE_FEATURES)
+const OfpMultipartType_OFPMP_PORT_DESC = OfpMultipartType(openflow_13.OfpMultipartType_OFPMP_PORT_DESC)
+const OfpMultipartType_OFPMP_EXPERIMENTER = OfpMultipartType(openflow_13.OfpMultipartType_OFPMP_EXPERIMENTER)
+
+// ofp_multipart_request_flags from public import openflow_13.proto
+type OfpMultipartRequestFlags openflow_13.OfpMultipartRequestFlags
+
+var OfpMultipartRequestFlags_name = openflow_13.OfpMultipartRequestFlags_name
+var OfpMultipartRequestFlags_value = openflow_13.OfpMultipartRequestFlags_value
+
+func (x OfpMultipartRequestFlags) String() string {
+	return (openflow_13.OfpMultipartRequestFlags)(x).String()
+}
+
+const OfpMultipartRequestFlags_OFPMPF_REQ_INVALID = OfpMultipartRequestFlags(openflow_13.OfpMultipartRequestFlags_OFPMPF_REQ_INVALID)
+const OfpMultipartRequestFlags_OFPMPF_REQ_MORE = OfpMultipartRequestFlags(openflow_13.OfpMultipartRequestFlags_OFPMPF_REQ_MORE)
+
+// ofp_multipart_reply_flags from public import openflow_13.proto
+type OfpMultipartReplyFlags openflow_13.OfpMultipartReplyFlags
+
+var OfpMultipartReplyFlags_name = openflow_13.OfpMultipartReplyFlags_name
+var OfpMultipartReplyFlags_value = openflow_13.OfpMultipartReplyFlags_value
+
+func (x OfpMultipartReplyFlags) String() string {
+	return (openflow_13.OfpMultipartReplyFlags)(x).String()
+}
+
+const OfpMultipartReplyFlags_OFPMPF_REPLY_INVALID = OfpMultipartReplyFlags(openflow_13.OfpMultipartReplyFlags_OFPMPF_REPLY_INVALID)
+const OfpMultipartReplyFlags_OFPMPF_REPLY_MORE = OfpMultipartReplyFlags(openflow_13.OfpMultipartReplyFlags_OFPMPF_REPLY_MORE)
+
+// ofp_table_feature_prop_type from public import openflow_13.proto
+type OfpTableFeaturePropType openflow_13.OfpTableFeaturePropType
+
+var OfpTableFeaturePropType_name = openflow_13.OfpTableFeaturePropType_name
+var OfpTableFeaturePropType_value = openflow_13.OfpTableFeaturePropType_value
+
+func (x OfpTableFeaturePropType) String() string {
+	return (openflow_13.OfpTableFeaturePropType)(x).String()
+}
+
+const OfpTableFeaturePropType_OFPTFPT_INSTRUCTIONS = OfpTableFeaturePropType(openflow_13.OfpTableFeaturePropType_OFPTFPT_INSTRUCTIONS)
+const OfpTableFeaturePropType_OFPTFPT_INSTRUCTIONS_MISS = OfpTableFeaturePropType(openflow_13.OfpTableFeaturePropType_OFPTFPT_INSTRUCTIONS_MISS)
+const OfpTableFeaturePropType_OFPTFPT_NEXT_TABLES = OfpTableFeaturePropType(openflow_13.OfpTableFeaturePropType_OFPTFPT_NEXT_TABLES)
+const OfpTableFeaturePropType_OFPTFPT_NEXT_TABLES_MISS = OfpTableFeaturePropType(openflow_13.OfpTableFeaturePropType_OFPTFPT_NEXT_TABLES_MISS)
+const OfpTableFeaturePropType_OFPTFPT_WRITE_ACTIONS = OfpTableFeaturePropType(openflow_13.OfpTableFeaturePropType_OFPTFPT_WRITE_ACTIONS)
+const OfpTableFeaturePropType_OFPTFPT_WRITE_ACTIONS_MISS = OfpTableFeaturePropType(openflow_13.OfpTableFeaturePropType_OFPTFPT_WRITE_ACTIONS_MISS)
+const OfpTableFeaturePropType_OFPTFPT_APPLY_ACTIONS = OfpTableFeaturePropType(openflow_13.OfpTableFeaturePropType_OFPTFPT_APPLY_ACTIONS)
+const OfpTableFeaturePropType_OFPTFPT_APPLY_ACTIONS_MISS = OfpTableFeaturePropType(openflow_13.OfpTableFeaturePropType_OFPTFPT_APPLY_ACTIONS_MISS)
+const OfpTableFeaturePropType_OFPTFPT_MATCH = OfpTableFeaturePropType(openflow_13.OfpTableFeaturePropType_OFPTFPT_MATCH)
+const OfpTableFeaturePropType_OFPTFPT_WILDCARDS = OfpTableFeaturePropType(openflow_13.OfpTableFeaturePropType_OFPTFPT_WILDCARDS)
+const OfpTableFeaturePropType_OFPTFPT_WRITE_SETFIELD = OfpTableFeaturePropType(openflow_13.OfpTableFeaturePropType_OFPTFPT_WRITE_SETFIELD)
+const OfpTableFeaturePropType_OFPTFPT_WRITE_SETFIELD_MISS = OfpTableFeaturePropType(openflow_13.OfpTableFeaturePropType_OFPTFPT_WRITE_SETFIELD_MISS)
+const OfpTableFeaturePropType_OFPTFPT_APPLY_SETFIELD = OfpTableFeaturePropType(openflow_13.OfpTableFeaturePropType_OFPTFPT_APPLY_SETFIELD)
+const OfpTableFeaturePropType_OFPTFPT_APPLY_SETFIELD_MISS = OfpTableFeaturePropType(openflow_13.OfpTableFeaturePropType_OFPTFPT_APPLY_SETFIELD_MISS)
+const OfpTableFeaturePropType_OFPTFPT_EXPERIMENTER = OfpTableFeaturePropType(openflow_13.OfpTableFeaturePropType_OFPTFPT_EXPERIMENTER)
+const OfpTableFeaturePropType_OFPTFPT_EXPERIMENTER_MISS = OfpTableFeaturePropType(openflow_13.OfpTableFeaturePropType_OFPTFPT_EXPERIMENTER_MISS)
+
+// ofp_group_capabilities from public import openflow_13.proto
+type OfpGroupCapabilities openflow_13.OfpGroupCapabilities
+
+var OfpGroupCapabilities_name = openflow_13.OfpGroupCapabilities_name
+var OfpGroupCapabilities_value = openflow_13.OfpGroupCapabilities_value
+
+func (x OfpGroupCapabilities) String() string { return (openflow_13.OfpGroupCapabilities)(x).String() }
+
+const OfpGroupCapabilities_OFPGFC_INVALID = OfpGroupCapabilities(openflow_13.OfpGroupCapabilities_OFPGFC_INVALID)
+const OfpGroupCapabilities_OFPGFC_SELECT_WEIGHT = OfpGroupCapabilities(openflow_13.OfpGroupCapabilities_OFPGFC_SELECT_WEIGHT)
+const OfpGroupCapabilities_OFPGFC_SELECT_LIVENESS = OfpGroupCapabilities(openflow_13.OfpGroupCapabilities_OFPGFC_SELECT_LIVENESS)
+const OfpGroupCapabilities_OFPGFC_CHAINING = OfpGroupCapabilities(openflow_13.OfpGroupCapabilities_OFPGFC_CHAINING)
+const OfpGroupCapabilities_OFPGFC_CHAINING_CHECKS = OfpGroupCapabilities(openflow_13.OfpGroupCapabilities_OFPGFC_CHAINING_CHECKS)
+
+// ofp_queue_properties from public import openflow_13.proto
+type OfpQueueProperties openflow_13.OfpQueueProperties
+
+var OfpQueueProperties_name = openflow_13.OfpQueueProperties_name
+var OfpQueueProperties_value = openflow_13.OfpQueueProperties_value
+
+func (x OfpQueueProperties) String() string { return (openflow_13.OfpQueueProperties)(x).String() }
+
+const OfpQueueProperties_OFPQT_INVALID = OfpQueueProperties(openflow_13.OfpQueueProperties_OFPQT_INVALID)
+const OfpQueueProperties_OFPQT_MIN_RATE = OfpQueueProperties(openflow_13.OfpQueueProperties_OFPQT_MIN_RATE)
+const OfpQueueProperties_OFPQT_MAX_RATE = OfpQueueProperties(openflow_13.OfpQueueProperties_OFPQT_MAX_RATE)
+const OfpQueueProperties_OFPQT_EXPERIMENTER = OfpQueueProperties(openflow_13.OfpQueueProperties_OFPQT_EXPERIMENTER)
+
+// ofp_controller_role from public import openflow_13.proto
+type OfpControllerRole openflow_13.OfpControllerRole
+
+var OfpControllerRole_name = openflow_13.OfpControllerRole_name
+var OfpControllerRole_value = openflow_13.OfpControllerRole_value
+
+func (x OfpControllerRole) String() string { return (openflow_13.OfpControllerRole)(x).String() }
+
+const OfpControllerRole_OFPCR_ROLE_NOCHANGE = OfpControllerRole(openflow_13.OfpControllerRole_OFPCR_ROLE_NOCHANGE)
+const OfpControllerRole_OFPCR_ROLE_EQUAL = OfpControllerRole(openflow_13.OfpControllerRole_OFPCR_ROLE_EQUAL)
+const OfpControllerRole_OFPCR_ROLE_MASTER = OfpControllerRole(openflow_13.OfpControllerRole_OFPCR_ROLE_MASTER)
+const OfpControllerRole_OFPCR_ROLE_SLAVE = OfpControllerRole(openflow_13.OfpControllerRole_OFPCR_ROLE_SLAVE)
+
+type AlarmFilterRuleKey_AlarmFilterRuleKey int32
+
+const (
+	AlarmFilterRuleKey_id          AlarmFilterRuleKey_AlarmFilterRuleKey = 0
+	AlarmFilterRuleKey_type        AlarmFilterRuleKey_AlarmFilterRuleKey = 1
+	AlarmFilterRuleKey_severity    AlarmFilterRuleKey_AlarmFilterRuleKey = 2
+	AlarmFilterRuleKey_resource_id AlarmFilterRuleKey_AlarmFilterRuleKey = 3
+	AlarmFilterRuleKey_category    AlarmFilterRuleKey_AlarmFilterRuleKey = 4
+	AlarmFilterRuleKey_device_id   AlarmFilterRuleKey_AlarmFilterRuleKey = 5
+)
+
+var AlarmFilterRuleKey_AlarmFilterRuleKey_name = map[int32]string{
+	0: "id",
+	1: "type",
+	2: "severity",
+	3: "resource_id",
+	4: "category",
+	5: "device_id",
+}
+var AlarmFilterRuleKey_AlarmFilterRuleKey_value = map[string]int32{
+	"id":          0,
+	"type":        1,
+	"severity":    2,
+	"resource_id": 3,
+	"category":    4,
+	"device_id":   5,
+}
+
+func (x AlarmFilterRuleKey_AlarmFilterRuleKey) String() string {
+	return proto.EnumName(AlarmFilterRuleKey_AlarmFilterRuleKey_name, int32(x))
+}
+func (AlarmFilterRuleKey_AlarmFilterRuleKey) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor0, []int{2, 0}
+}
+
+type DeviceGroup struct {
+	Id             string                   `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
+	LogicalDevices []*voltha5.LogicalDevice `protobuf:"bytes,2,rep,name=logical_devices,json=logicalDevices" json:"logical_devices,omitempty"`
+	Devices        []*voltha6.Device        `protobuf:"bytes,3,rep,name=devices" json:"devices,omitempty"`
+}
+
+func (m *DeviceGroup) Reset()                    { *m = DeviceGroup{} }
+func (m *DeviceGroup) String() string            { return proto.CompactTextString(m) }
+func (*DeviceGroup) ProtoMessage()               {}
+func (*DeviceGroup) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
+
+func (m *DeviceGroup) GetId() string {
+	if m != nil {
+		return m.Id
+	}
+	return ""
+}
+
+func (m *DeviceGroup) GetLogicalDevices() []*voltha5.LogicalDevice {
+	if m != nil {
+		return m.LogicalDevices
+	}
+	return nil
+}
+
+func (m *DeviceGroup) GetDevices() []*voltha6.Device {
+	if m != nil {
+		return m.Devices
+	}
+	return nil
+}
+
+type DeviceGroups struct {
+	Items []*DeviceGroup `protobuf:"bytes,1,rep,name=items" json:"items,omitempty"`
+}
+
+func (m *DeviceGroups) Reset()                    { *m = DeviceGroups{} }
+func (m *DeviceGroups) String() string            { return proto.CompactTextString(m) }
+func (*DeviceGroups) ProtoMessage()               {}
+func (*DeviceGroups) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
+
+func (m *DeviceGroups) GetItems() []*DeviceGroup {
+	if m != nil {
+		return m.Items
+	}
+	return nil
+}
+
+type AlarmFilterRuleKey struct {
+}
+
+func (m *AlarmFilterRuleKey) Reset()                    { *m = AlarmFilterRuleKey{} }
+func (m *AlarmFilterRuleKey) String() string            { return proto.CompactTextString(m) }
+func (*AlarmFilterRuleKey) ProtoMessage()               {}
+func (*AlarmFilterRuleKey) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }
+
+type AlarmFilterRule struct {
+	Key   AlarmFilterRuleKey_AlarmFilterRuleKey `protobuf:"varint,1,opt,name=key,enum=voltha.AlarmFilterRuleKey_AlarmFilterRuleKey" json:"key,omitempty"`
+	Value string                                `protobuf:"bytes,2,opt,name=value" json:"value,omitempty"`
+}
+
+func (m *AlarmFilterRule) Reset()                    { *m = AlarmFilterRule{} }
+func (m *AlarmFilterRule) String() string            { return proto.CompactTextString(m) }
+func (*AlarmFilterRule) ProtoMessage()               {}
+func (*AlarmFilterRule) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} }
+
+func (m *AlarmFilterRule) GetKey() AlarmFilterRuleKey_AlarmFilterRuleKey {
+	if m != nil {
+		return m.Key
+	}
+	return AlarmFilterRuleKey_id
+}
+
+func (m *AlarmFilterRule) GetValue() string {
+	if m != nil {
+		return m.Value
+	}
+	return ""
+}
+
+type AlarmFilter struct {
+	Id    string             `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
+	Rules []*AlarmFilterRule `protobuf:"bytes,2,rep,name=rules" json:"rules,omitempty"`
+}
+
+func (m *AlarmFilter) Reset()                    { *m = AlarmFilter{} }
+func (m *AlarmFilter) String() string            { return proto.CompactTextString(m) }
+func (*AlarmFilter) ProtoMessage()               {}
+func (*AlarmFilter) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} }
+
+func (m *AlarmFilter) GetId() string {
+	if m != nil {
+		return m.Id
+	}
+	return ""
+}
+
+func (m *AlarmFilter) GetRules() []*AlarmFilterRule {
+	if m != nil {
+		return m.Rules
+	}
+	return nil
+}
+
+type AlarmFilters struct {
+	Filters []*AlarmFilter `protobuf:"bytes,1,rep,name=filters" json:"filters,omitempty"`
+}
+
+func (m *AlarmFilters) Reset()                    { *m = AlarmFilters{} }
+func (m *AlarmFilters) String() string            { return proto.CompactTextString(m) }
+func (*AlarmFilters) ProtoMessage()               {}
+func (*AlarmFilters) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5} }
+
+func (m *AlarmFilters) GetFilters() []*AlarmFilter {
+	if m != nil {
+		return m.Filters
+	}
+	return nil
+}
+
+// Top-level (root) node for a Voltha Instance
+type VolthaInstance struct {
+	InstanceId     string                    `protobuf:"bytes,1,opt,name=instance_id,json=instanceId" json:"instance_id,omitempty"`
+	Version        string                    `protobuf:"bytes,2,opt,name=version" json:"version,omitempty"`
+	LogLevel       voltha3.LogLevel_LogLevel `protobuf:"varint,3,opt,name=log_level,json=logLevel,enum=voltha.LogLevel_LogLevel" json:"log_level,omitempty"`
+	Health         *voltha4.HealthStatus     `protobuf:"bytes,10,opt,name=health" json:"health,omitempty"`
+	Adapters       []*voltha7.Adapter        `protobuf:"bytes,11,rep,name=adapters" json:"adapters,omitempty"`
+	LogicalDevices []*voltha5.LogicalDevice  `protobuf:"bytes,12,rep,name=logical_devices,json=logicalDevices" json:"logical_devices,omitempty"`
+	Devices        []*voltha6.Device         `protobuf:"bytes,13,rep,name=devices" json:"devices,omitempty"`
+	DeviceTypes    []*voltha6.DeviceType     `protobuf:"bytes,14,rep,name=device_types,json=deviceTypes" json:"device_types,omitempty"`
+	DeviceGroups   []*DeviceGroup            `protobuf:"bytes,15,rep,name=device_groups,json=deviceGroups" json:"device_groups,omitempty"`
+	AlarmFilters   []*AlarmFilter            `protobuf:"bytes,16,rep,name=alarm_filters,json=alarmFilters" json:"alarm_filters,omitempty"`
+}
+
+func (m *VolthaInstance) Reset()                    { *m = VolthaInstance{} }
+func (m *VolthaInstance) String() string            { return proto.CompactTextString(m) }
+func (*VolthaInstance) ProtoMessage()               {}
+func (*VolthaInstance) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{6} }
+
+func (m *VolthaInstance) GetInstanceId() string {
+	if m != nil {
+		return m.InstanceId
+	}
+	return ""
+}
+
+func (m *VolthaInstance) GetVersion() string {
+	if m != nil {
+		return m.Version
+	}
+	return ""
+}
+
+func (m *VolthaInstance) GetLogLevel() voltha3.LogLevel_LogLevel {
+	if m != nil {
+		return m.LogLevel
+	}
+	return voltha3.LogLevel_DEBUG
+}
+
+func (m *VolthaInstance) GetHealth() *voltha4.HealthStatus {
+	if m != nil {
+		return m.Health
+	}
+	return nil
+}
+
+func (m *VolthaInstance) GetAdapters() []*voltha7.Adapter {
+	if m != nil {
+		return m.Adapters
+	}
+	return nil
+}
+
+func (m *VolthaInstance) GetLogicalDevices() []*voltha5.LogicalDevice {
+	if m != nil {
+		return m.LogicalDevices
+	}
+	return nil
+}
+
+func (m *VolthaInstance) GetDevices() []*voltha6.Device {
+	if m != nil {
+		return m.Devices
+	}
+	return nil
+}
+
+func (m *VolthaInstance) GetDeviceTypes() []*voltha6.DeviceType {
+	if m != nil {
+		return m.DeviceTypes
+	}
+	return nil
+}
+
+func (m *VolthaInstance) GetDeviceGroups() []*DeviceGroup {
+	if m != nil {
+		return m.DeviceGroups
+	}
+	return nil
+}
+
+func (m *VolthaInstance) GetAlarmFilters() []*AlarmFilter {
+	if m != nil {
+		return m.AlarmFilters
+	}
+	return nil
+}
+
+type VolthaInstances struct {
+	Items []string `protobuf:"bytes,1,rep,name=items" json:"items,omitempty"`
+}
+
+func (m *VolthaInstances) Reset()                    { *m = VolthaInstances{} }
+func (m *VolthaInstances) String() string            { return proto.CompactTextString(m) }
+func (*VolthaInstances) ProtoMessage()               {}
+func (*VolthaInstances) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7} }
+
+func (m *VolthaInstances) GetItems() []string {
+	if m != nil {
+		return m.Items
+	}
+	return nil
+}
+
+// Voltha representing the entire Voltha cluster
+type Voltha struct {
+	Version        string                    `protobuf:"bytes,1,opt,name=version" json:"version,omitempty"`
+	LogLevel       voltha3.LogLevel_LogLevel `protobuf:"varint,2,opt,name=log_level,json=logLevel,enum=voltha.LogLevel_LogLevel" json:"log_level,omitempty"`
+	Instances      []*VolthaInstance         `protobuf:"bytes,3,rep,name=instances" json:"instances,omitempty"`
+	Adapters       []*voltha7.Adapter        `protobuf:"bytes,11,rep,name=adapters" json:"adapters,omitempty"`
+	LogicalDevices []*voltha5.LogicalDevice  `protobuf:"bytes,12,rep,name=logical_devices,json=logicalDevices" json:"logical_devices,omitempty"`
+	Devices        []*voltha6.Device         `protobuf:"bytes,13,rep,name=devices" json:"devices,omitempty"`
+	DeviceGroups   []*DeviceGroup            `protobuf:"bytes,15,rep,name=device_groups,json=deviceGroups" json:"device_groups,omitempty"`
+}
+
+func (m *Voltha) Reset()                    { *m = Voltha{} }
+func (m *Voltha) String() string            { return proto.CompactTextString(m) }
+func (*Voltha) ProtoMessage()               {}
+func (*Voltha) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{8} }
+
+func (m *Voltha) GetVersion() string {
+	if m != nil {
+		return m.Version
+	}
+	return ""
+}
+
+func (m *Voltha) GetLogLevel() voltha3.LogLevel_LogLevel {
+	if m != nil {
+		return m.LogLevel
+	}
+	return voltha3.LogLevel_DEBUG
+}
+
+func (m *Voltha) GetInstances() []*VolthaInstance {
+	if m != nil {
+		return m.Instances
+	}
+	return nil
+}
+
+func (m *Voltha) GetAdapters() []*voltha7.Adapter {
+	if m != nil {
+		return m.Adapters
+	}
+	return nil
+}
+
+func (m *Voltha) GetLogicalDevices() []*voltha5.LogicalDevice {
+	if m != nil {
+		return m.LogicalDevices
+	}
+	return nil
+}
+
+func (m *Voltha) GetDevices() []*voltha6.Device {
+	if m != nil {
+		return m.Devices
+	}
+	return nil
+}
+
+func (m *Voltha) GetDeviceGroups() []*DeviceGroup {
+	if m != nil {
+		return m.DeviceGroups
+	}
+	return nil
+}
+
+func init() {
+	proto.RegisterType((*DeviceGroup)(nil), "voltha.DeviceGroup")
+	proto.RegisterType((*DeviceGroups)(nil), "voltha.DeviceGroups")
+	proto.RegisterType((*AlarmFilterRuleKey)(nil), "voltha.AlarmFilterRuleKey")
+	proto.RegisterType((*AlarmFilterRule)(nil), "voltha.AlarmFilterRule")
+	proto.RegisterType((*AlarmFilter)(nil), "voltha.AlarmFilter")
+	proto.RegisterType((*AlarmFilters)(nil), "voltha.AlarmFilters")
+	proto.RegisterType((*VolthaInstance)(nil), "voltha.VolthaInstance")
+	proto.RegisterType((*VolthaInstances)(nil), "voltha.VolthaInstances")
+	proto.RegisterType((*Voltha)(nil), "voltha.Voltha")
+	proto.RegisterEnum("voltha.AlarmFilterRuleKey_AlarmFilterRuleKey", AlarmFilterRuleKey_AlarmFilterRuleKey_name, AlarmFilterRuleKey_AlarmFilterRuleKey_value)
+}
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ context.Context
+var _ grpc.ClientConn
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+const _ = grpc.SupportPackageIsVersion4
+
+// Client API for VolthaGlobalService service
+
+type VolthaGlobalServiceClient interface {
+	// Get high level information on the Voltha cluster
+	GetVoltha(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*Voltha, error)
+	// List all Voltha cluster instances
+	ListVolthaInstances(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*VolthaInstances, error)
+	// Get details on a Voltha cluster instance
+	GetVolthaInstance(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*VolthaInstance, error)
+	// List all logical devices managed by the Voltha cluster
+	ListLogicalDevices(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*voltha5.LogicalDevices, error)
+	// Get additional information on a given logical device
+	GetLogicalDevice(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*voltha5.LogicalDevice, error)
+	// List ports of a logical device
+	ListLogicalDevicePorts(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*voltha5.LogicalPorts, error)
+	// List all flows of a logical device
+	ListLogicalDeviceFlows(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*openflow_13.Flows, error)
+	// Update flow table for logical device
+	UpdateLogicalDeviceFlowTable(ctx context.Context, in *openflow_13.FlowTableUpdate, opts ...grpc.CallOption) (*google_protobuf.Empty, error)
+	// List all flow groups of a logical device
+	ListLogicalDeviceFlowGroups(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*openflow_13.FlowGroups, error)
+	// Update group table for device
+	UpdateLogicalDeviceFlowGroupTable(ctx context.Context, in *openflow_13.FlowGroupTableUpdate, opts ...grpc.CallOption) (*google_protobuf.Empty, error)
+	// List all physical devices controlled by the Voltha cluster
+	ListDevices(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*voltha6.Devices, error)
+	// Get more information on a given physical device
+	GetDevice(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*voltha6.Device, error)
+	// Pre-provision a new physical device
+	CreateDevice(ctx context.Context, in *voltha6.Device, opts ...grpc.CallOption) (*voltha6.Device, error)
+	// Enable a device.  If the device was in pre-provisioned state then it
+	// will tansition to ENABLED state.  If it was is DISABLED state then it
+	// will tansition to ENABLED state as well.
+	EnableDevice(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*google_protobuf.Empty, error)
+	// Disable a device
+	DisableDevice(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*google_protobuf.Empty, error)
+	// Reboot a device
+	RebootDevice(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*google_protobuf.Empty, error)
+	// Delete a device
+	DeleteDevice(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*google_protobuf.Empty, error)
+	// List ports of a device
+	ListDevicePorts(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*voltha6.Ports, error)
+	// List pm config of a device
+	ListDevicePmConfigs(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*voltha6.PmConfigs, error)
+	// Update the pm config of a device
+	UpdateDevicePmConfigs(ctx context.Context, in *voltha6.PmConfigs, opts ...grpc.CallOption) (*google_protobuf.Empty, error)
+	// List all flows of a device
+	ListDeviceFlows(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*openflow_13.Flows, error)
+	// List all flow groups of a device
+	ListDeviceFlowGroups(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*openflow_13.FlowGroups, error)
+	// List device types known to Voltha
+	ListDeviceTypes(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*voltha6.DeviceTypes, error)
+	// Get additional information on a device type
+	GetDeviceType(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*voltha6.DeviceType, error)
+	// List all device sharding groups
+	ListDeviceGroups(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*DeviceGroups, error)
+	// Get additional information on a device group
+	GetDeviceGroup(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*DeviceGroup, error)
+	CreateAlarmFilter(ctx context.Context, in *AlarmFilter, opts ...grpc.CallOption) (*AlarmFilter, error)
+	GetAlarmFilter(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*AlarmFilter, error)
+	UpdateAlarmFilter(ctx context.Context, in *AlarmFilter, opts ...grpc.CallOption) (*AlarmFilter, error)
+	DeleteAlarmFilter(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*google_protobuf.Empty, error)
+	ListAlarmFilters(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*AlarmFilters, error)
+}
+
+type volthaGlobalServiceClient struct {
+	cc *grpc.ClientConn
+}
+
+func NewVolthaGlobalServiceClient(cc *grpc.ClientConn) VolthaGlobalServiceClient {
+	return &volthaGlobalServiceClient{cc}
+}
+
+func (c *volthaGlobalServiceClient) GetVoltha(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*Voltha, error) {
+	out := new(Voltha)
+	err := grpc.Invoke(ctx, "/voltha.VolthaGlobalService/GetVoltha", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *volthaGlobalServiceClient) ListVolthaInstances(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*VolthaInstances, error) {
+	out := new(VolthaInstances)
+	err := grpc.Invoke(ctx, "/voltha.VolthaGlobalService/ListVolthaInstances", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *volthaGlobalServiceClient) GetVolthaInstance(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*VolthaInstance, error) {
+	out := new(VolthaInstance)
+	err := grpc.Invoke(ctx, "/voltha.VolthaGlobalService/GetVolthaInstance", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *volthaGlobalServiceClient) ListLogicalDevices(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*voltha5.LogicalDevices, error) {
+	out := new(voltha5.LogicalDevices)
+	err := grpc.Invoke(ctx, "/voltha.VolthaGlobalService/ListLogicalDevices", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *volthaGlobalServiceClient) GetLogicalDevice(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*voltha5.LogicalDevice, error) {
+	out := new(voltha5.LogicalDevice)
+	err := grpc.Invoke(ctx, "/voltha.VolthaGlobalService/GetLogicalDevice", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *volthaGlobalServiceClient) ListLogicalDevicePorts(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*voltha5.LogicalPorts, error) {
+	out := new(voltha5.LogicalPorts)
+	err := grpc.Invoke(ctx, "/voltha.VolthaGlobalService/ListLogicalDevicePorts", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *volthaGlobalServiceClient) ListLogicalDeviceFlows(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*openflow_13.Flows, error) {
+	out := new(openflow_13.Flows)
+	err := grpc.Invoke(ctx, "/voltha.VolthaGlobalService/ListLogicalDeviceFlows", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *volthaGlobalServiceClient) UpdateLogicalDeviceFlowTable(ctx context.Context, in *openflow_13.FlowTableUpdate, opts ...grpc.CallOption) (*google_protobuf.Empty, error) {
+	out := new(google_protobuf.Empty)
+	err := grpc.Invoke(ctx, "/voltha.VolthaGlobalService/UpdateLogicalDeviceFlowTable", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *volthaGlobalServiceClient) ListLogicalDeviceFlowGroups(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*openflow_13.FlowGroups, error) {
+	out := new(openflow_13.FlowGroups)
+	err := grpc.Invoke(ctx, "/voltha.VolthaGlobalService/ListLogicalDeviceFlowGroups", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *volthaGlobalServiceClient) UpdateLogicalDeviceFlowGroupTable(ctx context.Context, in *openflow_13.FlowGroupTableUpdate, opts ...grpc.CallOption) (*google_protobuf.Empty, error) {
+	out := new(google_protobuf.Empty)
+	err := grpc.Invoke(ctx, "/voltha.VolthaGlobalService/UpdateLogicalDeviceFlowGroupTable", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *volthaGlobalServiceClient) ListDevices(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*voltha6.Devices, error) {
+	out := new(voltha6.Devices)
+	err := grpc.Invoke(ctx, "/voltha.VolthaGlobalService/ListDevices", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *volthaGlobalServiceClient) GetDevice(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*voltha6.Device, error) {
+	out := new(voltha6.Device)
+	err := grpc.Invoke(ctx, "/voltha.VolthaGlobalService/GetDevice", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *volthaGlobalServiceClient) CreateDevice(ctx context.Context, in *voltha6.Device, opts ...grpc.CallOption) (*voltha6.Device, error) {
+	out := new(voltha6.Device)
+	err := grpc.Invoke(ctx, "/voltha.VolthaGlobalService/CreateDevice", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *volthaGlobalServiceClient) EnableDevice(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*google_protobuf.Empty, error) {
+	out := new(google_protobuf.Empty)
+	err := grpc.Invoke(ctx, "/voltha.VolthaGlobalService/EnableDevice", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *volthaGlobalServiceClient) DisableDevice(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*google_protobuf.Empty, error) {
+	out := new(google_protobuf.Empty)
+	err := grpc.Invoke(ctx, "/voltha.VolthaGlobalService/DisableDevice", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *volthaGlobalServiceClient) RebootDevice(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*google_protobuf.Empty, error) {
+	out := new(google_protobuf.Empty)
+	err := grpc.Invoke(ctx, "/voltha.VolthaGlobalService/RebootDevice", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *volthaGlobalServiceClient) DeleteDevice(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*google_protobuf.Empty, error) {
+	out := new(google_protobuf.Empty)
+	err := grpc.Invoke(ctx, "/voltha.VolthaGlobalService/DeleteDevice", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *volthaGlobalServiceClient) ListDevicePorts(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*voltha6.Ports, error) {
+	out := new(voltha6.Ports)
+	err := grpc.Invoke(ctx, "/voltha.VolthaGlobalService/ListDevicePorts", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *volthaGlobalServiceClient) ListDevicePmConfigs(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*voltha6.PmConfigs, error) {
+	out := new(voltha6.PmConfigs)
+	err := grpc.Invoke(ctx, "/voltha.VolthaGlobalService/ListDevicePmConfigs", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *volthaGlobalServiceClient) UpdateDevicePmConfigs(ctx context.Context, in *voltha6.PmConfigs, opts ...grpc.CallOption) (*google_protobuf.Empty, error) {
+	out := new(google_protobuf.Empty)
+	err := grpc.Invoke(ctx, "/voltha.VolthaGlobalService/UpdateDevicePmConfigs", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *volthaGlobalServiceClient) ListDeviceFlows(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*openflow_13.Flows, error) {
+	out := new(openflow_13.Flows)
+	err := grpc.Invoke(ctx, "/voltha.VolthaGlobalService/ListDeviceFlows", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *volthaGlobalServiceClient) ListDeviceFlowGroups(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*openflow_13.FlowGroups, error) {
+	out := new(openflow_13.FlowGroups)
+	err := grpc.Invoke(ctx, "/voltha.VolthaGlobalService/ListDeviceFlowGroups", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *volthaGlobalServiceClient) ListDeviceTypes(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*voltha6.DeviceTypes, error) {
+	out := new(voltha6.DeviceTypes)
+	err := grpc.Invoke(ctx, "/voltha.VolthaGlobalService/ListDeviceTypes", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *volthaGlobalServiceClient) GetDeviceType(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*voltha6.DeviceType, error) {
+	out := new(voltha6.DeviceType)
+	err := grpc.Invoke(ctx, "/voltha.VolthaGlobalService/GetDeviceType", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *volthaGlobalServiceClient) ListDeviceGroups(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*DeviceGroups, error) {
+	out := new(DeviceGroups)
+	err := grpc.Invoke(ctx, "/voltha.VolthaGlobalService/ListDeviceGroups", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *volthaGlobalServiceClient) GetDeviceGroup(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*DeviceGroup, error) {
+	out := new(DeviceGroup)
+	err := grpc.Invoke(ctx, "/voltha.VolthaGlobalService/GetDeviceGroup", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *volthaGlobalServiceClient) CreateAlarmFilter(ctx context.Context, in *AlarmFilter, opts ...grpc.CallOption) (*AlarmFilter, error) {
+	out := new(AlarmFilter)
+	err := grpc.Invoke(ctx, "/voltha.VolthaGlobalService/CreateAlarmFilter", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *volthaGlobalServiceClient) GetAlarmFilter(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*AlarmFilter, error) {
+	out := new(AlarmFilter)
+	err := grpc.Invoke(ctx, "/voltha.VolthaGlobalService/GetAlarmFilter", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *volthaGlobalServiceClient) UpdateAlarmFilter(ctx context.Context, in *AlarmFilter, opts ...grpc.CallOption) (*AlarmFilter, error) {
+	out := new(AlarmFilter)
+	err := grpc.Invoke(ctx, "/voltha.VolthaGlobalService/UpdateAlarmFilter", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *volthaGlobalServiceClient) DeleteAlarmFilter(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*google_protobuf.Empty, error) {
+	out := new(google_protobuf.Empty)
+	err := grpc.Invoke(ctx, "/voltha.VolthaGlobalService/DeleteAlarmFilter", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *volthaGlobalServiceClient) ListAlarmFilters(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*AlarmFilters, error) {
+	out := new(AlarmFilters)
+	err := grpc.Invoke(ctx, "/voltha.VolthaGlobalService/ListAlarmFilters", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// Server API for VolthaGlobalService service
+
+type VolthaGlobalServiceServer interface {
+	// Get high level information on the Voltha cluster
+	GetVoltha(context.Context, *google_protobuf.Empty) (*Voltha, error)
+	// List all Voltha cluster instances
+	ListVolthaInstances(context.Context, *google_protobuf.Empty) (*VolthaInstances, error)
+	// Get details on a Voltha cluster instance
+	GetVolthaInstance(context.Context, *voltha3.ID) (*VolthaInstance, error)
+	// List all logical devices managed by the Voltha cluster
+	ListLogicalDevices(context.Context, *google_protobuf.Empty) (*voltha5.LogicalDevices, error)
+	// Get additional information on a given logical device
+	GetLogicalDevice(context.Context, *voltha3.ID) (*voltha5.LogicalDevice, error)
+	// List ports of a logical device
+	ListLogicalDevicePorts(context.Context, *voltha3.ID) (*voltha5.LogicalPorts, error)
+	// List all flows of a logical device
+	ListLogicalDeviceFlows(context.Context, *voltha3.ID) (*openflow_13.Flows, error)
+	// Update flow table for logical device
+	UpdateLogicalDeviceFlowTable(context.Context, *openflow_13.FlowTableUpdate) (*google_protobuf.Empty, error)
+	// List all flow groups of a logical device
+	ListLogicalDeviceFlowGroups(context.Context, *voltha3.ID) (*openflow_13.FlowGroups, error)
+	// Update group table for device
+	UpdateLogicalDeviceFlowGroupTable(context.Context, *openflow_13.FlowGroupTableUpdate) (*google_protobuf.Empty, error)
+	// List all physical devices controlled by the Voltha cluster
+	ListDevices(context.Context, *google_protobuf.Empty) (*voltha6.Devices, error)
+	// Get more information on a given physical device
+	GetDevice(context.Context, *voltha3.ID) (*voltha6.Device, error)
+	// Pre-provision a new physical device
+	CreateDevice(context.Context, *voltha6.Device) (*voltha6.Device, error)
+	// Enable a device.  If the device was in pre-provisioned state then it
+	// will tansition to ENABLED state.  If it was is DISABLED state then it
+	// will tansition to ENABLED state as well.
+	EnableDevice(context.Context, *voltha3.ID) (*google_protobuf.Empty, error)
+	// Disable a device
+	DisableDevice(context.Context, *voltha3.ID) (*google_protobuf.Empty, error)
+	// Reboot a device
+	RebootDevice(context.Context, *voltha3.ID) (*google_protobuf.Empty, error)
+	// Delete a device
+	DeleteDevice(context.Context, *voltha3.ID) (*google_protobuf.Empty, error)
+	// List ports of a device
+	ListDevicePorts(context.Context, *voltha3.ID) (*voltha6.Ports, error)
+	// List pm config of a device
+	ListDevicePmConfigs(context.Context, *voltha3.ID) (*voltha6.PmConfigs, error)
+	// Update the pm config of a device
+	UpdateDevicePmConfigs(context.Context, *voltha6.PmConfigs) (*google_protobuf.Empty, error)
+	// List all flows of a device
+	ListDeviceFlows(context.Context, *voltha3.ID) (*openflow_13.Flows, error)
+	// List all flow groups of a device
+	ListDeviceFlowGroups(context.Context, *voltha3.ID) (*openflow_13.FlowGroups, error)
+	// List device types known to Voltha
+	ListDeviceTypes(context.Context, *google_protobuf.Empty) (*voltha6.DeviceTypes, error)
+	// Get additional information on a device type
+	GetDeviceType(context.Context, *voltha3.ID) (*voltha6.DeviceType, error)
+	// List all device sharding groups
+	ListDeviceGroups(context.Context, *google_protobuf.Empty) (*DeviceGroups, error)
+	// Get additional information on a device group
+	GetDeviceGroup(context.Context, *voltha3.ID) (*DeviceGroup, error)
+	CreateAlarmFilter(context.Context, *AlarmFilter) (*AlarmFilter, error)
+	GetAlarmFilter(context.Context, *voltha3.ID) (*AlarmFilter, error)
+	UpdateAlarmFilter(context.Context, *AlarmFilter) (*AlarmFilter, error)
+	DeleteAlarmFilter(context.Context, *voltha3.ID) (*google_protobuf.Empty, error)
+	ListAlarmFilters(context.Context, *google_protobuf.Empty) (*AlarmFilters, error)
+}
+
+func RegisterVolthaGlobalServiceServer(s *grpc.Server, srv VolthaGlobalServiceServer) {
+	s.RegisterService(&_VolthaGlobalService_serviceDesc, srv)
+}
+
+func _VolthaGlobalService_GetVoltha_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(google_protobuf.Empty)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(VolthaGlobalServiceServer).GetVoltha(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/voltha.VolthaGlobalService/GetVoltha",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(VolthaGlobalServiceServer).GetVoltha(ctx, req.(*google_protobuf.Empty))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaGlobalService_ListVolthaInstances_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(google_protobuf.Empty)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(VolthaGlobalServiceServer).ListVolthaInstances(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/voltha.VolthaGlobalService/ListVolthaInstances",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(VolthaGlobalServiceServer).ListVolthaInstances(ctx, req.(*google_protobuf.Empty))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaGlobalService_GetVolthaInstance_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(voltha3.ID)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(VolthaGlobalServiceServer).GetVolthaInstance(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/voltha.VolthaGlobalService/GetVolthaInstance",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(VolthaGlobalServiceServer).GetVolthaInstance(ctx, req.(*voltha3.ID))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaGlobalService_ListLogicalDevices_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(google_protobuf.Empty)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(VolthaGlobalServiceServer).ListLogicalDevices(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/voltha.VolthaGlobalService/ListLogicalDevices",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(VolthaGlobalServiceServer).ListLogicalDevices(ctx, req.(*google_protobuf.Empty))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaGlobalService_GetLogicalDevice_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(voltha3.ID)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(VolthaGlobalServiceServer).GetLogicalDevice(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/voltha.VolthaGlobalService/GetLogicalDevice",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(VolthaGlobalServiceServer).GetLogicalDevice(ctx, req.(*voltha3.ID))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaGlobalService_ListLogicalDevicePorts_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(voltha3.ID)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(VolthaGlobalServiceServer).ListLogicalDevicePorts(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/voltha.VolthaGlobalService/ListLogicalDevicePorts",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(VolthaGlobalServiceServer).ListLogicalDevicePorts(ctx, req.(*voltha3.ID))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaGlobalService_ListLogicalDeviceFlows_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(voltha3.ID)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(VolthaGlobalServiceServer).ListLogicalDeviceFlows(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/voltha.VolthaGlobalService/ListLogicalDeviceFlows",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(VolthaGlobalServiceServer).ListLogicalDeviceFlows(ctx, req.(*voltha3.ID))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaGlobalService_UpdateLogicalDeviceFlowTable_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(openflow_13.FlowTableUpdate)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(VolthaGlobalServiceServer).UpdateLogicalDeviceFlowTable(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/voltha.VolthaGlobalService/UpdateLogicalDeviceFlowTable",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(VolthaGlobalServiceServer).UpdateLogicalDeviceFlowTable(ctx, req.(*openflow_13.FlowTableUpdate))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaGlobalService_ListLogicalDeviceFlowGroups_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(voltha3.ID)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(VolthaGlobalServiceServer).ListLogicalDeviceFlowGroups(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/voltha.VolthaGlobalService/ListLogicalDeviceFlowGroups",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(VolthaGlobalServiceServer).ListLogicalDeviceFlowGroups(ctx, req.(*voltha3.ID))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaGlobalService_UpdateLogicalDeviceFlowGroupTable_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(openflow_13.FlowGroupTableUpdate)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(VolthaGlobalServiceServer).UpdateLogicalDeviceFlowGroupTable(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/voltha.VolthaGlobalService/UpdateLogicalDeviceFlowGroupTable",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(VolthaGlobalServiceServer).UpdateLogicalDeviceFlowGroupTable(ctx, req.(*openflow_13.FlowGroupTableUpdate))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaGlobalService_ListDevices_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(google_protobuf.Empty)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(VolthaGlobalServiceServer).ListDevices(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/voltha.VolthaGlobalService/ListDevices",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(VolthaGlobalServiceServer).ListDevices(ctx, req.(*google_protobuf.Empty))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaGlobalService_GetDevice_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(voltha3.ID)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(VolthaGlobalServiceServer).GetDevice(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/voltha.VolthaGlobalService/GetDevice",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(VolthaGlobalServiceServer).GetDevice(ctx, req.(*voltha3.ID))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaGlobalService_CreateDevice_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(voltha6.Device)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(VolthaGlobalServiceServer).CreateDevice(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/voltha.VolthaGlobalService/CreateDevice",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(VolthaGlobalServiceServer).CreateDevice(ctx, req.(*voltha6.Device))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaGlobalService_EnableDevice_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(voltha3.ID)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(VolthaGlobalServiceServer).EnableDevice(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/voltha.VolthaGlobalService/EnableDevice",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(VolthaGlobalServiceServer).EnableDevice(ctx, req.(*voltha3.ID))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaGlobalService_DisableDevice_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(voltha3.ID)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(VolthaGlobalServiceServer).DisableDevice(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/voltha.VolthaGlobalService/DisableDevice",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(VolthaGlobalServiceServer).DisableDevice(ctx, req.(*voltha3.ID))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaGlobalService_RebootDevice_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(voltha3.ID)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(VolthaGlobalServiceServer).RebootDevice(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/voltha.VolthaGlobalService/RebootDevice",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(VolthaGlobalServiceServer).RebootDevice(ctx, req.(*voltha3.ID))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaGlobalService_DeleteDevice_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(voltha3.ID)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(VolthaGlobalServiceServer).DeleteDevice(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/voltha.VolthaGlobalService/DeleteDevice",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(VolthaGlobalServiceServer).DeleteDevice(ctx, req.(*voltha3.ID))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaGlobalService_ListDevicePorts_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(voltha3.ID)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(VolthaGlobalServiceServer).ListDevicePorts(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/voltha.VolthaGlobalService/ListDevicePorts",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(VolthaGlobalServiceServer).ListDevicePorts(ctx, req.(*voltha3.ID))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaGlobalService_ListDevicePmConfigs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(voltha3.ID)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(VolthaGlobalServiceServer).ListDevicePmConfigs(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/voltha.VolthaGlobalService/ListDevicePmConfigs",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(VolthaGlobalServiceServer).ListDevicePmConfigs(ctx, req.(*voltha3.ID))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaGlobalService_UpdateDevicePmConfigs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(voltha6.PmConfigs)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(VolthaGlobalServiceServer).UpdateDevicePmConfigs(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/voltha.VolthaGlobalService/UpdateDevicePmConfigs",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(VolthaGlobalServiceServer).UpdateDevicePmConfigs(ctx, req.(*voltha6.PmConfigs))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaGlobalService_ListDeviceFlows_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(voltha3.ID)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(VolthaGlobalServiceServer).ListDeviceFlows(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/voltha.VolthaGlobalService/ListDeviceFlows",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(VolthaGlobalServiceServer).ListDeviceFlows(ctx, req.(*voltha3.ID))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaGlobalService_ListDeviceFlowGroups_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(voltha3.ID)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(VolthaGlobalServiceServer).ListDeviceFlowGroups(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/voltha.VolthaGlobalService/ListDeviceFlowGroups",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(VolthaGlobalServiceServer).ListDeviceFlowGroups(ctx, req.(*voltha3.ID))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaGlobalService_ListDeviceTypes_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(google_protobuf.Empty)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(VolthaGlobalServiceServer).ListDeviceTypes(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/voltha.VolthaGlobalService/ListDeviceTypes",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(VolthaGlobalServiceServer).ListDeviceTypes(ctx, req.(*google_protobuf.Empty))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaGlobalService_GetDeviceType_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(voltha3.ID)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(VolthaGlobalServiceServer).GetDeviceType(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/voltha.VolthaGlobalService/GetDeviceType",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(VolthaGlobalServiceServer).GetDeviceType(ctx, req.(*voltha3.ID))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaGlobalService_ListDeviceGroups_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(google_protobuf.Empty)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(VolthaGlobalServiceServer).ListDeviceGroups(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/voltha.VolthaGlobalService/ListDeviceGroups",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(VolthaGlobalServiceServer).ListDeviceGroups(ctx, req.(*google_protobuf.Empty))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaGlobalService_GetDeviceGroup_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(voltha3.ID)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(VolthaGlobalServiceServer).GetDeviceGroup(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/voltha.VolthaGlobalService/GetDeviceGroup",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(VolthaGlobalServiceServer).GetDeviceGroup(ctx, req.(*voltha3.ID))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaGlobalService_CreateAlarmFilter_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(AlarmFilter)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(VolthaGlobalServiceServer).CreateAlarmFilter(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/voltha.VolthaGlobalService/CreateAlarmFilter",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(VolthaGlobalServiceServer).CreateAlarmFilter(ctx, req.(*AlarmFilter))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaGlobalService_GetAlarmFilter_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(voltha3.ID)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(VolthaGlobalServiceServer).GetAlarmFilter(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/voltha.VolthaGlobalService/GetAlarmFilter",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(VolthaGlobalServiceServer).GetAlarmFilter(ctx, req.(*voltha3.ID))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaGlobalService_UpdateAlarmFilter_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(AlarmFilter)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(VolthaGlobalServiceServer).UpdateAlarmFilter(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/voltha.VolthaGlobalService/UpdateAlarmFilter",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(VolthaGlobalServiceServer).UpdateAlarmFilter(ctx, req.(*AlarmFilter))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaGlobalService_DeleteAlarmFilter_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(voltha3.ID)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(VolthaGlobalServiceServer).DeleteAlarmFilter(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/voltha.VolthaGlobalService/DeleteAlarmFilter",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(VolthaGlobalServiceServer).DeleteAlarmFilter(ctx, req.(*voltha3.ID))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaGlobalService_ListAlarmFilters_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(google_protobuf.Empty)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(VolthaGlobalServiceServer).ListAlarmFilters(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/voltha.VolthaGlobalService/ListAlarmFilters",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(VolthaGlobalServiceServer).ListAlarmFilters(ctx, req.(*google_protobuf.Empty))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+var _VolthaGlobalService_serviceDesc = grpc.ServiceDesc{
+	ServiceName: "voltha.VolthaGlobalService",
+	HandlerType: (*VolthaGlobalServiceServer)(nil),
+	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "GetVoltha",
+			Handler:    _VolthaGlobalService_GetVoltha_Handler,
+		},
+		{
+			MethodName: "ListVolthaInstances",
+			Handler:    _VolthaGlobalService_ListVolthaInstances_Handler,
+		},
+		{
+			MethodName: "GetVolthaInstance",
+			Handler:    _VolthaGlobalService_GetVolthaInstance_Handler,
+		},
+		{
+			MethodName: "ListLogicalDevices",
+			Handler:    _VolthaGlobalService_ListLogicalDevices_Handler,
+		},
+		{
+			MethodName: "GetLogicalDevice",
+			Handler:    _VolthaGlobalService_GetLogicalDevice_Handler,
+		},
+		{
+			MethodName: "ListLogicalDevicePorts",
+			Handler:    _VolthaGlobalService_ListLogicalDevicePorts_Handler,
+		},
+		{
+			MethodName: "ListLogicalDeviceFlows",
+			Handler:    _VolthaGlobalService_ListLogicalDeviceFlows_Handler,
+		},
+		{
+			MethodName: "UpdateLogicalDeviceFlowTable",
+			Handler:    _VolthaGlobalService_UpdateLogicalDeviceFlowTable_Handler,
+		},
+		{
+			MethodName: "ListLogicalDeviceFlowGroups",
+			Handler:    _VolthaGlobalService_ListLogicalDeviceFlowGroups_Handler,
+		},
+		{
+			MethodName: "UpdateLogicalDeviceFlowGroupTable",
+			Handler:    _VolthaGlobalService_UpdateLogicalDeviceFlowGroupTable_Handler,
+		},
+		{
+			MethodName: "ListDevices",
+			Handler:    _VolthaGlobalService_ListDevices_Handler,
+		},
+		{
+			MethodName: "GetDevice",
+			Handler:    _VolthaGlobalService_GetDevice_Handler,
+		},
+		{
+			MethodName: "CreateDevice",
+			Handler:    _VolthaGlobalService_CreateDevice_Handler,
+		},
+		{
+			MethodName: "EnableDevice",
+			Handler:    _VolthaGlobalService_EnableDevice_Handler,
+		},
+		{
+			MethodName: "DisableDevice",
+			Handler:    _VolthaGlobalService_DisableDevice_Handler,
+		},
+		{
+			MethodName: "RebootDevice",
+			Handler:    _VolthaGlobalService_RebootDevice_Handler,
+		},
+		{
+			MethodName: "DeleteDevice",
+			Handler:    _VolthaGlobalService_DeleteDevice_Handler,
+		},
+		{
+			MethodName: "ListDevicePorts",
+			Handler:    _VolthaGlobalService_ListDevicePorts_Handler,
+		},
+		{
+			MethodName: "ListDevicePmConfigs",
+			Handler:    _VolthaGlobalService_ListDevicePmConfigs_Handler,
+		},
+		{
+			MethodName: "UpdateDevicePmConfigs",
+			Handler:    _VolthaGlobalService_UpdateDevicePmConfigs_Handler,
+		},
+		{
+			MethodName: "ListDeviceFlows",
+			Handler:    _VolthaGlobalService_ListDeviceFlows_Handler,
+		},
+		{
+			MethodName: "ListDeviceFlowGroups",
+			Handler:    _VolthaGlobalService_ListDeviceFlowGroups_Handler,
+		},
+		{
+			MethodName: "ListDeviceTypes",
+			Handler:    _VolthaGlobalService_ListDeviceTypes_Handler,
+		},
+		{
+			MethodName: "GetDeviceType",
+			Handler:    _VolthaGlobalService_GetDeviceType_Handler,
+		},
+		{
+			MethodName: "ListDeviceGroups",
+			Handler:    _VolthaGlobalService_ListDeviceGroups_Handler,
+		},
+		{
+			MethodName: "GetDeviceGroup",
+			Handler:    _VolthaGlobalService_GetDeviceGroup_Handler,
+		},
+		{
+			MethodName: "CreateAlarmFilter",
+			Handler:    _VolthaGlobalService_CreateAlarmFilter_Handler,
+		},
+		{
+			MethodName: "GetAlarmFilter",
+			Handler:    _VolthaGlobalService_GetAlarmFilter_Handler,
+		},
+		{
+			MethodName: "UpdateAlarmFilter",
+			Handler:    _VolthaGlobalService_UpdateAlarmFilter_Handler,
+		},
+		{
+			MethodName: "DeleteAlarmFilter",
+			Handler:    _VolthaGlobalService_DeleteAlarmFilter_Handler,
+		},
+		{
+			MethodName: "ListAlarmFilters",
+			Handler:    _VolthaGlobalService_ListAlarmFilters_Handler,
+		},
+	},
+	Streams:  []grpc.StreamDesc{},
+	Metadata: "voltha.proto",
+}
+
+// Client API for VolthaLocalService service
+
+type VolthaLocalServiceClient interface {
+	// Get information on this Voltha instance
+	GetVolthaInstance(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*VolthaInstance, error)
+	// Get the health state of the Voltha instance
+	GetHealth(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*voltha4.HealthStatus, error)
+	// List all active adapters (plugins) in this Voltha instance
+	ListAdapters(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*voltha7.Adapters, error)
+	// List all logical devices managed by this Voltha instance
+	ListLogicalDevices(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*voltha5.LogicalDevices, error)
+	// Get additional information on given logical device
+	GetLogicalDevice(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*voltha5.LogicalDevice, error)
+	// List ports of a logical device
+	ListLogicalDevicePorts(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*voltha5.LogicalPorts, error)
+	// List all flows of a logical device
+	ListLogicalDeviceFlows(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*openflow_13.Flows, error)
+	// Update flow table for logical device
+	UpdateLogicalDeviceFlowTable(ctx context.Context, in *openflow_13.FlowTableUpdate, opts ...grpc.CallOption) (*google_protobuf.Empty, error)
+	// List all flow groups of a logical device
+	ListLogicalDeviceFlowGroups(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*openflow_13.FlowGroups, error)
+	// Update group table for logical device
+	UpdateLogicalDeviceFlowGroupTable(ctx context.Context, in *openflow_13.FlowGroupTableUpdate, opts ...grpc.CallOption) (*google_protobuf.Empty, error)
+	// List all physical devices managed by this Voltha instance
+	ListDevices(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*voltha6.Devices, error)
+	// Get additional information on this device
+	GetDevice(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*voltha6.Device, error)
+	// Pre-provision a new physical device
+	CreateDevice(ctx context.Context, in *voltha6.Device, opts ...grpc.CallOption) (*voltha6.Device, error)
+	// Enable a device.  If the device was in pre-provisioned state then it
+	// will tansition to ENABLED state.  If it was is DISABLED state then it
+	// will tansition to ENABLED state as well.
+	EnableDevice(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*google_protobuf.Empty, error)
+	// Disable a device
+	DisableDevice(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*google_protobuf.Empty, error)
+	// Reboot a device
+	RebootDevice(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*google_protobuf.Empty, error)
+	// Delete a device
+	DeleteDevice(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*google_protobuf.Empty, error)
+	// List ports of a device
+	ListDevicePorts(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*voltha6.Ports, error)
+	// List pm config of a device
+	ListDevicePmConfigs(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*voltha6.PmConfigs, error)
+	// Update the pm config of a device
+	UpdateDevicePmConfigs(ctx context.Context, in *voltha6.PmConfigs, opts ...grpc.CallOption) (*google_protobuf.Empty, error)
+	// List all flows of a device
+	ListDeviceFlows(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*openflow_13.Flows, error)
+	// List all flow groups of a device
+	ListDeviceFlowGroups(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*openflow_13.FlowGroups, error)
+	// List device types know to Voltha instance
+	ListDeviceTypes(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*voltha6.DeviceTypes, error)
+	// Get additional information on given device type
+	GetDeviceType(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*voltha6.DeviceType, error)
+	// List device sharding groups managed by this Voltha instance
+	ListDeviceGroups(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*DeviceGroups, error)
+	// Get more information on given device shard
+	GetDeviceGroup(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*DeviceGroup, error)
+	// Stream control packets to the dataplane
+	StreamPacketsOut(ctx context.Context, opts ...grpc.CallOption) (VolthaLocalService_StreamPacketsOutClient, error)
+	// Receive control packet stream
+	ReceivePacketsIn(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (VolthaLocalService_ReceivePacketsInClient, error)
+	ReceiveChangeEvents(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (VolthaLocalService_ReceiveChangeEventsClient, error)
+	CreateAlarmFilter(ctx context.Context, in *AlarmFilter, opts ...grpc.CallOption) (*AlarmFilter, error)
+	GetAlarmFilter(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*AlarmFilter, error)
+	UpdateAlarmFilter(ctx context.Context, in *AlarmFilter, opts ...grpc.CallOption) (*AlarmFilter, error)
+	DeleteAlarmFilter(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*google_protobuf.Empty, error)
+	ListAlarmFilters(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*AlarmFilters, error)
+}
+
+type volthaLocalServiceClient struct {
+	cc *grpc.ClientConn
+}
+
+func NewVolthaLocalServiceClient(cc *grpc.ClientConn) VolthaLocalServiceClient {
+	return &volthaLocalServiceClient{cc}
+}
+
+func (c *volthaLocalServiceClient) GetVolthaInstance(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*VolthaInstance, error) {
+	out := new(VolthaInstance)
+	err := grpc.Invoke(ctx, "/voltha.VolthaLocalService/GetVolthaInstance", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *volthaLocalServiceClient) GetHealth(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*voltha4.HealthStatus, error) {
+	out := new(voltha4.HealthStatus)
+	err := grpc.Invoke(ctx, "/voltha.VolthaLocalService/GetHealth", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *volthaLocalServiceClient) ListAdapters(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*voltha7.Adapters, error) {
+	out := new(voltha7.Adapters)
+	err := grpc.Invoke(ctx, "/voltha.VolthaLocalService/ListAdapters", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *volthaLocalServiceClient) ListLogicalDevices(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*voltha5.LogicalDevices, error) {
+	out := new(voltha5.LogicalDevices)
+	err := grpc.Invoke(ctx, "/voltha.VolthaLocalService/ListLogicalDevices", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *volthaLocalServiceClient) GetLogicalDevice(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*voltha5.LogicalDevice, error) {
+	out := new(voltha5.LogicalDevice)
+	err := grpc.Invoke(ctx, "/voltha.VolthaLocalService/GetLogicalDevice", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *volthaLocalServiceClient) ListLogicalDevicePorts(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*voltha5.LogicalPorts, error) {
+	out := new(voltha5.LogicalPorts)
+	err := grpc.Invoke(ctx, "/voltha.VolthaLocalService/ListLogicalDevicePorts", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *volthaLocalServiceClient) ListLogicalDeviceFlows(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*openflow_13.Flows, error) {
+	out := new(openflow_13.Flows)
+	err := grpc.Invoke(ctx, "/voltha.VolthaLocalService/ListLogicalDeviceFlows", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *volthaLocalServiceClient) UpdateLogicalDeviceFlowTable(ctx context.Context, in *openflow_13.FlowTableUpdate, opts ...grpc.CallOption) (*google_protobuf.Empty, error) {
+	out := new(google_protobuf.Empty)
+	err := grpc.Invoke(ctx, "/voltha.VolthaLocalService/UpdateLogicalDeviceFlowTable", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *volthaLocalServiceClient) ListLogicalDeviceFlowGroups(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*openflow_13.FlowGroups, error) {
+	out := new(openflow_13.FlowGroups)
+	err := grpc.Invoke(ctx, "/voltha.VolthaLocalService/ListLogicalDeviceFlowGroups", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *volthaLocalServiceClient) UpdateLogicalDeviceFlowGroupTable(ctx context.Context, in *openflow_13.FlowGroupTableUpdate, opts ...grpc.CallOption) (*google_protobuf.Empty, error) {
+	out := new(google_protobuf.Empty)
+	err := grpc.Invoke(ctx, "/voltha.VolthaLocalService/UpdateLogicalDeviceFlowGroupTable", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *volthaLocalServiceClient) ListDevices(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*voltha6.Devices, error) {
+	out := new(voltha6.Devices)
+	err := grpc.Invoke(ctx, "/voltha.VolthaLocalService/ListDevices", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *volthaLocalServiceClient) GetDevice(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*voltha6.Device, error) {
+	out := new(voltha6.Device)
+	err := grpc.Invoke(ctx, "/voltha.VolthaLocalService/GetDevice", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *volthaLocalServiceClient) CreateDevice(ctx context.Context, in *voltha6.Device, opts ...grpc.CallOption) (*voltha6.Device, error) {
+	out := new(voltha6.Device)
+	err := grpc.Invoke(ctx, "/voltha.VolthaLocalService/CreateDevice", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *volthaLocalServiceClient) EnableDevice(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*google_protobuf.Empty, error) {
+	out := new(google_protobuf.Empty)
+	err := grpc.Invoke(ctx, "/voltha.VolthaLocalService/EnableDevice", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *volthaLocalServiceClient) DisableDevice(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*google_protobuf.Empty, error) {
+	out := new(google_protobuf.Empty)
+	err := grpc.Invoke(ctx, "/voltha.VolthaLocalService/DisableDevice", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *volthaLocalServiceClient) RebootDevice(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*google_protobuf.Empty, error) {
+	out := new(google_protobuf.Empty)
+	err := grpc.Invoke(ctx, "/voltha.VolthaLocalService/RebootDevice", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *volthaLocalServiceClient) DeleteDevice(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*google_protobuf.Empty, error) {
+	out := new(google_protobuf.Empty)
+	err := grpc.Invoke(ctx, "/voltha.VolthaLocalService/DeleteDevice", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *volthaLocalServiceClient) ListDevicePorts(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*voltha6.Ports, error) {
+	out := new(voltha6.Ports)
+	err := grpc.Invoke(ctx, "/voltha.VolthaLocalService/ListDevicePorts", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *volthaLocalServiceClient) ListDevicePmConfigs(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*voltha6.PmConfigs, error) {
+	out := new(voltha6.PmConfigs)
+	err := grpc.Invoke(ctx, "/voltha.VolthaLocalService/ListDevicePmConfigs", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *volthaLocalServiceClient) UpdateDevicePmConfigs(ctx context.Context, in *voltha6.PmConfigs, opts ...grpc.CallOption) (*google_protobuf.Empty, error) {
+	out := new(google_protobuf.Empty)
+	err := grpc.Invoke(ctx, "/voltha.VolthaLocalService/UpdateDevicePmConfigs", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *volthaLocalServiceClient) ListDeviceFlows(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*openflow_13.Flows, error) {
+	out := new(openflow_13.Flows)
+	err := grpc.Invoke(ctx, "/voltha.VolthaLocalService/ListDeviceFlows", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *volthaLocalServiceClient) ListDeviceFlowGroups(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*openflow_13.FlowGroups, error) {
+	out := new(openflow_13.FlowGroups)
+	err := grpc.Invoke(ctx, "/voltha.VolthaLocalService/ListDeviceFlowGroups", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *volthaLocalServiceClient) ListDeviceTypes(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*voltha6.DeviceTypes, error) {
+	out := new(voltha6.DeviceTypes)
+	err := grpc.Invoke(ctx, "/voltha.VolthaLocalService/ListDeviceTypes", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *volthaLocalServiceClient) GetDeviceType(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*voltha6.DeviceType, error) {
+	out := new(voltha6.DeviceType)
+	err := grpc.Invoke(ctx, "/voltha.VolthaLocalService/GetDeviceType", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *volthaLocalServiceClient) ListDeviceGroups(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*DeviceGroups, error) {
+	out := new(DeviceGroups)
+	err := grpc.Invoke(ctx, "/voltha.VolthaLocalService/ListDeviceGroups", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *volthaLocalServiceClient) GetDeviceGroup(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*DeviceGroup, error) {
+	out := new(DeviceGroup)
+	err := grpc.Invoke(ctx, "/voltha.VolthaLocalService/GetDeviceGroup", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *volthaLocalServiceClient) StreamPacketsOut(ctx context.Context, opts ...grpc.CallOption) (VolthaLocalService_StreamPacketsOutClient, error) {
+	stream, err := grpc.NewClientStream(ctx, &_VolthaLocalService_serviceDesc.Streams[0], c.cc, "/voltha.VolthaLocalService/StreamPacketsOut", opts...)
+	if err != nil {
+		return nil, err
+	}
+	x := &volthaLocalServiceStreamPacketsOutClient{stream}
+	return x, nil
+}
+
+type VolthaLocalService_StreamPacketsOutClient interface {
+	Send(*openflow_13.PacketOut) error
+	CloseAndRecv() (*google_protobuf.Empty, error)
+	grpc.ClientStream
+}
+
+type volthaLocalServiceStreamPacketsOutClient struct {
+	grpc.ClientStream
+}
+
+func (x *volthaLocalServiceStreamPacketsOutClient) Send(m *openflow_13.PacketOut) error {
+	return x.ClientStream.SendMsg(m)
+}
+
+func (x *volthaLocalServiceStreamPacketsOutClient) CloseAndRecv() (*google_protobuf.Empty, error) {
+	if err := x.ClientStream.CloseSend(); err != nil {
+		return nil, err
+	}
+	m := new(google_protobuf.Empty)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+func (c *volthaLocalServiceClient) ReceivePacketsIn(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (VolthaLocalService_ReceivePacketsInClient, error) {
+	stream, err := grpc.NewClientStream(ctx, &_VolthaLocalService_serviceDesc.Streams[1], c.cc, "/voltha.VolthaLocalService/ReceivePacketsIn", opts...)
+	if err != nil {
+		return nil, err
+	}
+	x := &volthaLocalServiceReceivePacketsInClient{stream}
+	if err := x.ClientStream.SendMsg(in); err != nil {
+		return nil, err
+	}
+	if err := x.ClientStream.CloseSend(); err != nil {
+		return nil, err
+	}
+	return x, nil
+}
+
+type VolthaLocalService_ReceivePacketsInClient interface {
+	Recv() (*openflow_13.PacketIn, error)
+	grpc.ClientStream
+}
+
+type volthaLocalServiceReceivePacketsInClient struct {
+	grpc.ClientStream
+}
+
+func (x *volthaLocalServiceReceivePacketsInClient) Recv() (*openflow_13.PacketIn, error) {
+	m := new(openflow_13.PacketIn)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+func (c *volthaLocalServiceClient) ReceiveChangeEvents(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (VolthaLocalService_ReceiveChangeEventsClient, error) {
+	stream, err := grpc.NewClientStream(ctx, &_VolthaLocalService_serviceDesc.Streams[2], c.cc, "/voltha.VolthaLocalService/ReceiveChangeEvents", opts...)
+	if err != nil {
+		return nil, err
+	}
+	x := &volthaLocalServiceReceiveChangeEventsClient{stream}
+	if err := x.ClientStream.SendMsg(in); err != nil {
+		return nil, err
+	}
+	if err := x.ClientStream.CloseSend(); err != nil {
+		return nil, err
+	}
+	return x, nil
+}
+
+type VolthaLocalService_ReceiveChangeEventsClient interface {
+	Recv() (*openflow_13.ChangeEvent, error)
+	grpc.ClientStream
+}
+
+type volthaLocalServiceReceiveChangeEventsClient struct {
+	grpc.ClientStream
+}
+
+func (x *volthaLocalServiceReceiveChangeEventsClient) Recv() (*openflow_13.ChangeEvent, error) {
+	m := new(openflow_13.ChangeEvent)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+func (c *volthaLocalServiceClient) CreateAlarmFilter(ctx context.Context, in *AlarmFilter, opts ...grpc.CallOption) (*AlarmFilter, error) {
+	out := new(AlarmFilter)
+	err := grpc.Invoke(ctx, "/voltha.VolthaLocalService/CreateAlarmFilter", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *volthaLocalServiceClient) GetAlarmFilter(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*AlarmFilter, error) {
+	out := new(AlarmFilter)
+	err := grpc.Invoke(ctx, "/voltha.VolthaLocalService/GetAlarmFilter", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *volthaLocalServiceClient) UpdateAlarmFilter(ctx context.Context, in *AlarmFilter, opts ...grpc.CallOption) (*AlarmFilter, error) {
+	out := new(AlarmFilter)
+	err := grpc.Invoke(ctx, "/voltha.VolthaLocalService/UpdateAlarmFilter", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *volthaLocalServiceClient) DeleteAlarmFilter(ctx context.Context, in *voltha3.ID, opts ...grpc.CallOption) (*google_protobuf.Empty, error) {
+	out := new(google_protobuf.Empty)
+	err := grpc.Invoke(ctx, "/voltha.VolthaLocalService/DeleteAlarmFilter", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *volthaLocalServiceClient) ListAlarmFilters(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*AlarmFilters, error) {
+	out := new(AlarmFilters)
+	err := grpc.Invoke(ctx, "/voltha.VolthaLocalService/ListAlarmFilters", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// Server API for VolthaLocalService service
+
+type VolthaLocalServiceServer interface {
+	// Get information on this Voltha instance
+	GetVolthaInstance(context.Context, *google_protobuf.Empty) (*VolthaInstance, error)
+	// Get the health state of the Voltha instance
+	GetHealth(context.Context, *google_protobuf.Empty) (*voltha4.HealthStatus, error)
+	// List all active adapters (plugins) in this Voltha instance
+	ListAdapters(context.Context, *google_protobuf.Empty) (*voltha7.Adapters, error)
+	// List all logical devices managed by this Voltha instance
+	ListLogicalDevices(context.Context, *google_protobuf.Empty) (*voltha5.LogicalDevices, error)
+	// Get additional information on given logical device
+	GetLogicalDevice(context.Context, *voltha3.ID) (*voltha5.LogicalDevice, error)
+	// List ports of a logical device
+	ListLogicalDevicePorts(context.Context, *voltha3.ID) (*voltha5.LogicalPorts, error)
+	// List all flows of a logical device
+	ListLogicalDeviceFlows(context.Context, *voltha3.ID) (*openflow_13.Flows, error)
+	// Update flow table for logical device
+	UpdateLogicalDeviceFlowTable(context.Context, *openflow_13.FlowTableUpdate) (*google_protobuf.Empty, error)
+	// List all flow groups of a logical device
+	ListLogicalDeviceFlowGroups(context.Context, *voltha3.ID) (*openflow_13.FlowGroups, error)
+	// Update group table for logical device
+	UpdateLogicalDeviceFlowGroupTable(context.Context, *openflow_13.FlowGroupTableUpdate) (*google_protobuf.Empty, error)
+	// List all physical devices managed by this Voltha instance
+	ListDevices(context.Context, *google_protobuf.Empty) (*voltha6.Devices, error)
+	// Get additional information on this device
+	GetDevice(context.Context, *voltha3.ID) (*voltha6.Device, error)
+	// Pre-provision a new physical device
+	CreateDevice(context.Context, *voltha6.Device) (*voltha6.Device, error)
+	// Enable a device.  If the device was in pre-provisioned state then it
+	// will tansition to ENABLED state.  If it was is DISABLED state then it
+	// will tansition to ENABLED state as well.
+	EnableDevice(context.Context, *voltha3.ID) (*google_protobuf.Empty, error)
+	// Disable a device
+	DisableDevice(context.Context, *voltha3.ID) (*google_protobuf.Empty, error)
+	// Reboot a device
+	RebootDevice(context.Context, *voltha3.ID) (*google_protobuf.Empty, error)
+	// Delete a device
+	DeleteDevice(context.Context, *voltha3.ID) (*google_protobuf.Empty, error)
+	// List ports of a device
+	ListDevicePorts(context.Context, *voltha3.ID) (*voltha6.Ports, error)
+	// List pm config of a device
+	ListDevicePmConfigs(context.Context, *voltha3.ID) (*voltha6.PmConfigs, error)
+	// Update the pm config of a device
+	UpdateDevicePmConfigs(context.Context, *voltha6.PmConfigs) (*google_protobuf.Empty, error)
+	// List all flows of a device
+	ListDeviceFlows(context.Context, *voltha3.ID) (*openflow_13.Flows, error)
+	// List all flow groups of a device
+	ListDeviceFlowGroups(context.Context, *voltha3.ID) (*openflow_13.FlowGroups, error)
+	// List device types know to Voltha instance
+	ListDeviceTypes(context.Context, *google_protobuf.Empty) (*voltha6.DeviceTypes, error)
+	// Get additional information on given device type
+	GetDeviceType(context.Context, *voltha3.ID) (*voltha6.DeviceType, error)
+	// List device sharding groups managed by this Voltha instance
+	ListDeviceGroups(context.Context, *google_protobuf.Empty) (*DeviceGroups, error)
+	// Get more information on given device shard
+	GetDeviceGroup(context.Context, *voltha3.ID) (*DeviceGroup, error)
+	// Stream control packets to the dataplane
+	StreamPacketsOut(VolthaLocalService_StreamPacketsOutServer) error
+	// Receive control packet stream
+	ReceivePacketsIn(*google_protobuf.Empty, VolthaLocalService_ReceivePacketsInServer) error
+	ReceiveChangeEvents(*google_protobuf.Empty, VolthaLocalService_ReceiveChangeEventsServer) error
+	CreateAlarmFilter(context.Context, *AlarmFilter) (*AlarmFilter, error)
+	GetAlarmFilter(context.Context, *voltha3.ID) (*AlarmFilter, error)
+	UpdateAlarmFilter(context.Context, *AlarmFilter) (*AlarmFilter, error)
+	DeleteAlarmFilter(context.Context, *voltha3.ID) (*google_protobuf.Empty, error)
+	ListAlarmFilters(context.Context, *google_protobuf.Empty) (*AlarmFilters, error)
+}
+
+func RegisterVolthaLocalServiceServer(s *grpc.Server, srv VolthaLocalServiceServer) {
+	s.RegisterService(&_VolthaLocalService_serviceDesc, srv)
+}
+
+func _VolthaLocalService_GetVolthaInstance_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(google_protobuf.Empty)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(VolthaLocalServiceServer).GetVolthaInstance(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/voltha.VolthaLocalService/GetVolthaInstance",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(VolthaLocalServiceServer).GetVolthaInstance(ctx, req.(*google_protobuf.Empty))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaLocalService_GetHealth_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(google_protobuf.Empty)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(VolthaLocalServiceServer).GetHealth(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/voltha.VolthaLocalService/GetHealth",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(VolthaLocalServiceServer).GetHealth(ctx, req.(*google_protobuf.Empty))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaLocalService_ListAdapters_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(google_protobuf.Empty)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(VolthaLocalServiceServer).ListAdapters(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/voltha.VolthaLocalService/ListAdapters",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(VolthaLocalServiceServer).ListAdapters(ctx, req.(*google_protobuf.Empty))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaLocalService_ListLogicalDevices_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(google_protobuf.Empty)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(VolthaLocalServiceServer).ListLogicalDevices(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/voltha.VolthaLocalService/ListLogicalDevices",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(VolthaLocalServiceServer).ListLogicalDevices(ctx, req.(*google_protobuf.Empty))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaLocalService_GetLogicalDevice_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(voltha3.ID)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(VolthaLocalServiceServer).GetLogicalDevice(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/voltha.VolthaLocalService/GetLogicalDevice",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(VolthaLocalServiceServer).GetLogicalDevice(ctx, req.(*voltha3.ID))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaLocalService_ListLogicalDevicePorts_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(voltha3.ID)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(VolthaLocalServiceServer).ListLogicalDevicePorts(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/voltha.VolthaLocalService/ListLogicalDevicePorts",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(VolthaLocalServiceServer).ListLogicalDevicePorts(ctx, req.(*voltha3.ID))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaLocalService_ListLogicalDeviceFlows_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(voltha3.ID)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(VolthaLocalServiceServer).ListLogicalDeviceFlows(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/voltha.VolthaLocalService/ListLogicalDeviceFlows",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(VolthaLocalServiceServer).ListLogicalDeviceFlows(ctx, req.(*voltha3.ID))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaLocalService_UpdateLogicalDeviceFlowTable_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(openflow_13.FlowTableUpdate)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(VolthaLocalServiceServer).UpdateLogicalDeviceFlowTable(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/voltha.VolthaLocalService/UpdateLogicalDeviceFlowTable",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(VolthaLocalServiceServer).UpdateLogicalDeviceFlowTable(ctx, req.(*openflow_13.FlowTableUpdate))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaLocalService_ListLogicalDeviceFlowGroups_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(voltha3.ID)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(VolthaLocalServiceServer).ListLogicalDeviceFlowGroups(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/voltha.VolthaLocalService/ListLogicalDeviceFlowGroups",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(VolthaLocalServiceServer).ListLogicalDeviceFlowGroups(ctx, req.(*voltha3.ID))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaLocalService_UpdateLogicalDeviceFlowGroupTable_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(openflow_13.FlowGroupTableUpdate)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(VolthaLocalServiceServer).UpdateLogicalDeviceFlowGroupTable(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/voltha.VolthaLocalService/UpdateLogicalDeviceFlowGroupTable",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(VolthaLocalServiceServer).UpdateLogicalDeviceFlowGroupTable(ctx, req.(*openflow_13.FlowGroupTableUpdate))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaLocalService_ListDevices_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(google_protobuf.Empty)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(VolthaLocalServiceServer).ListDevices(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/voltha.VolthaLocalService/ListDevices",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(VolthaLocalServiceServer).ListDevices(ctx, req.(*google_protobuf.Empty))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaLocalService_GetDevice_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(voltha3.ID)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(VolthaLocalServiceServer).GetDevice(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/voltha.VolthaLocalService/GetDevice",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(VolthaLocalServiceServer).GetDevice(ctx, req.(*voltha3.ID))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaLocalService_CreateDevice_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(voltha6.Device)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(VolthaLocalServiceServer).CreateDevice(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/voltha.VolthaLocalService/CreateDevice",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(VolthaLocalServiceServer).CreateDevice(ctx, req.(*voltha6.Device))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaLocalService_EnableDevice_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(voltha3.ID)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(VolthaLocalServiceServer).EnableDevice(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/voltha.VolthaLocalService/EnableDevice",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(VolthaLocalServiceServer).EnableDevice(ctx, req.(*voltha3.ID))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaLocalService_DisableDevice_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(voltha3.ID)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(VolthaLocalServiceServer).DisableDevice(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/voltha.VolthaLocalService/DisableDevice",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(VolthaLocalServiceServer).DisableDevice(ctx, req.(*voltha3.ID))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaLocalService_RebootDevice_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(voltha3.ID)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(VolthaLocalServiceServer).RebootDevice(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/voltha.VolthaLocalService/RebootDevice",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(VolthaLocalServiceServer).RebootDevice(ctx, req.(*voltha3.ID))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaLocalService_DeleteDevice_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(voltha3.ID)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(VolthaLocalServiceServer).DeleteDevice(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/voltha.VolthaLocalService/DeleteDevice",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(VolthaLocalServiceServer).DeleteDevice(ctx, req.(*voltha3.ID))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaLocalService_ListDevicePorts_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(voltha3.ID)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(VolthaLocalServiceServer).ListDevicePorts(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/voltha.VolthaLocalService/ListDevicePorts",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(VolthaLocalServiceServer).ListDevicePorts(ctx, req.(*voltha3.ID))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaLocalService_ListDevicePmConfigs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(voltha3.ID)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(VolthaLocalServiceServer).ListDevicePmConfigs(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/voltha.VolthaLocalService/ListDevicePmConfigs",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(VolthaLocalServiceServer).ListDevicePmConfigs(ctx, req.(*voltha3.ID))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaLocalService_UpdateDevicePmConfigs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(voltha6.PmConfigs)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(VolthaLocalServiceServer).UpdateDevicePmConfigs(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/voltha.VolthaLocalService/UpdateDevicePmConfigs",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(VolthaLocalServiceServer).UpdateDevicePmConfigs(ctx, req.(*voltha6.PmConfigs))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaLocalService_ListDeviceFlows_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(voltha3.ID)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(VolthaLocalServiceServer).ListDeviceFlows(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/voltha.VolthaLocalService/ListDeviceFlows",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(VolthaLocalServiceServer).ListDeviceFlows(ctx, req.(*voltha3.ID))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaLocalService_ListDeviceFlowGroups_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(voltha3.ID)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(VolthaLocalServiceServer).ListDeviceFlowGroups(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/voltha.VolthaLocalService/ListDeviceFlowGroups",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(VolthaLocalServiceServer).ListDeviceFlowGroups(ctx, req.(*voltha3.ID))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaLocalService_ListDeviceTypes_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(google_protobuf.Empty)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(VolthaLocalServiceServer).ListDeviceTypes(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/voltha.VolthaLocalService/ListDeviceTypes",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(VolthaLocalServiceServer).ListDeviceTypes(ctx, req.(*google_protobuf.Empty))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaLocalService_GetDeviceType_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(voltha3.ID)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(VolthaLocalServiceServer).GetDeviceType(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/voltha.VolthaLocalService/GetDeviceType",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(VolthaLocalServiceServer).GetDeviceType(ctx, req.(*voltha3.ID))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaLocalService_ListDeviceGroups_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(google_protobuf.Empty)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(VolthaLocalServiceServer).ListDeviceGroups(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/voltha.VolthaLocalService/ListDeviceGroups",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(VolthaLocalServiceServer).ListDeviceGroups(ctx, req.(*google_protobuf.Empty))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaLocalService_GetDeviceGroup_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(voltha3.ID)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(VolthaLocalServiceServer).GetDeviceGroup(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/voltha.VolthaLocalService/GetDeviceGroup",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(VolthaLocalServiceServer).GetDeviceGroup(ctx, req.(*voltha3.ID))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaLocalService_StreamPacketsOut_Handler(srv interface{}, stream grpc.ServerStream) error {
+	return srv.(VolthaLocalServiceServer).StreamPacketsOut(&volthaLocalServiceStreamPacketsOutServer{stream})
+}
+
+type VolthaLocalService_StreamPacketsOutServer interface {
+	SendAndClose(*google_protobuf.Empty) error
+	Recv() (*openflow_13.PacketOut, error)
+	grpc.ServerStream
+}
+
+type volthaLocalServiceStreamPacketsOutServer struct {
+	grpc.ServerStream
+}
+
+func (x *volthaLocalServiceStreamPacketsOutServer) SendAndClose(m *google_protobuf.Empty) error {
+	return x.ServerStream.SendMsg(m)
+}
+
+func (x *volthaLocalServiceStreamPacketsOutServer) Recv() (*openflow_13.PacketOut, error) {
+	m := new(openflow_13.PacketOut)
+	if err := x.ServerStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+func _VolthaLocalService_ReceivePacketsIn_Handler(srv interface{}, stream grpc.ServerStream) error {
+	m := new(google_protobuf.Empty)
+	if err := stream.RecvMsg(m); err != nil {
+		return err
+	}
+	return srv.(VolthaLocalServiceServer).ReceivePacketsIn(m, &volthaLocalServiceReceivePacketsInServer{stream})
+}
+
+type VolthaLocalService_ReceivePacketsInServer interface {
+	Send(*openflow_13.PacketIn) error
+	grpc.ServerStream
+}
+
+type volthaLocalServiceReceivePacketsInServer struct {
+	grpc.ServerStream
+}
+
+func (x *volthaLocalServiceReceivePacketsInServer) Send(m *openflow_13.PacketIn) error {
+	return x.ServerStream.SendMsg(m)
+}
+
+func _VolthaLocalService_ReceiveChangeEvents_Handler(srv interface{}, stream grpc.ServerStream) error {
+	m := new(google_protobuf.Empty)
+	if err := stream.RecvMsg(m); err != nil {
+		return err
+	}
+	return srv.(VolthaLocalServiceServer).ReceiveChangeEvents(m, &volthaLocalServiceReceiveChangeEventsServer{stream})
+}
+
+type VolthaLocalService_ReceiveChangeEventsServer interface {
+	Send(*openflow_13.ChangeEvent) error
+	grpc.ServerStream
+}
+
+type volthaLocalServiceReceiveChangeEventsServer struct {
+	grpc.ServerStream
+}
+
+func (x *volthaLocalServiceReceiveChangeEventsServer) Send(m *openflow_13.ChangeEvent) error {
+	return x.ServerStream.SendMsg(m)
+}
+
+func _VolthaLocalService_CreateAlarmFilter_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(AlarmFilter)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(VolthaLocalServiceServer).CreateAlarmFilter(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/voltha.VolthaLocalService/CreateAlarmFilter",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(VolthaLocalServiceServer).CreateAlarmFilter(ctx, req.(*AlarmFilter))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaLocalService_GetAlarmFilter_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(voltha3.ID)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(VolthaLocalServiceServer).GetAlarmFilter(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/voltha.VolthaLocalService/GetAlarmFilter",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(VolthaLocalServiceServer).GetAlarmFilter(ctx, req.(*voltha3.ID))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaLocalService_UpdateAlarmFilter_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(AlarmFilter)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(VolthaLocalServiceServer).UpdateAlarmFilter(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/voltha.VolthaLocalService/UpdateAlarmFilter",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(VolthaLocalServiceServer).UpdateAlarmFilter(ctx, req.(*AlarmFilter))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaLocalService_DeleteAlarmFilter_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(voltha3.ID)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(VolthaLocalServiceServer).DeleteAlarmFilter(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/voltha.VolthaLocalService/DeleteAlarmFilter",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(VolthaLocalServiceServer).DeleteAlarmFilter(ctx, req.(*voltha3.ID))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _VolthaLocalService_ListAlarmFilters_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(google_protobuf.Empty)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(VolthaLocalServiceServer).ListAlarmFilters(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/voltha.VolthaLocalService/ListAlarmFilters",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(VolthaLocalServiceServer).ListAlarmFilters(ctx, req.(*google_protobuf.Empty))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+var _VolthaLocalService_serviceDesc = grpc.ServiceDesc{
+	ServiceName: "voltha.VolthaLocalService",
+	HandlerType: (*VolthaLocalServiceServer)(nil),
+	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "GetVolthaInstance",
+			Handler:    _VolthaLocalService_GetVolthaInstance_Handler,
+		},
+		{
+			MethodName: "GetHealth",
+			Handler:    _VolthaLocalService_GetHealth_Handler,
+		},
+		{
+			MethodName: "ListAdapters",
+			Handler:    _VolthaLocalService_ListAdapters_Handler,
+		},
+		{
+			MethodName: "ListLogicalDevices",
+			Handler:    _VolthaLocalService_ListLogicalDevices_Handler,
+		},
+		{
+			MethodName: "GetLogicalDevice",
+			Handler:    _VolthaLocalService_GetLogicalDevice_Handler,
+		},
+		{
+			MethodName: "ListLogicalDevicePorts",
+			Handler:    _VolthaLocalService_ListLogicalDevicePorts_Handler,
+		},
+		{
+			MethodName: "ListLogicalDeviceFlows",
+			Handler:    _VolthaLocalService_ListLogicalDeviceFlows_Handler,
+		},
+		{
+			MethodName: "UpdateLogicalDeviceFlowTable",
+			Handler:    _VolthaLocalService_UpdateLogicalDeviceFlowTable_Handler,
+		},
+		{
+			MethodName: "ListLogicalDeviceFlowGroups",
+			Handler:    _VolthaLocalService_ListLogicalDeviceFlowGroups_Handler,
+		},
+		{
+			MethodName: "UpdateLogicalDeviceFlowGroupTable",
+			Handler:    _VolthaLocalService_UpdateLogicalDeviceFlowGroupTable_Handler,
+		},
+		{
+			MethodName: "ListDevices",
+			Handler:    _VolthaLocalService_ListDevices_Handler,
+		},
+		{
+			MethodName: "GetDevice",
+			Handler:    _VolthaLocalService_GetDevice_Handler,
+		},
+		{
+			MethodName: "CreateDevice",
+			Handler:    _VolthaLocalService_CreateDevice_Handler,
+		},
+		{
+			MethodName: "EnableDevice",
+			Handler:    _VolthaLocalService_EnableDevice_Handler,
+		},
+		{
+			MethodName: "DisableDevice",
+			Handler:    _VolthaLocalService_DisableDevice_Handler,
+		},
+		{
+			MethodName: "RebootDevice",
+			Handler:    _VolthaLocalService_RebootDevice_Handler,
+		},
+		{
+			MethodName: "DeleteDevice",
+			Handler:    _VolthaLocalService_DeleteDevice_Handler,
+		},
+		{
+			MethodName: "ListDevicePorts",
+			Handler:    _VolthaLocalService_ListDevicePorts_Handler,
+		},
+		{
+			MethodName: "ListDevicePmConfigs",
+			Handler:    _VolthaLocalService_ListDevicePmConfigs_Handler,
+		},
+		{
+			MethodName: "UpdateDevicePmConfigs",
+			Handler:    _VolthaLocalService_UpdateDevicePmConfigs_Handler,
+		},
+		{
+			MethodName: "ListDeviceFlows",
+			Handler:    _VolthaLocalService_ListDeviceFlows_Handler,
+		},
+		{
+			MethodName: "ListDeviceFlowGroups",
+			Handler:    _VolthaLocalService_ListDeviceFlowGroups_Handler,
+		},
+		{
+			MethodName: "ListDeviceTypes",
+			Handler:    _VolthaLocalService_ListDeviceTypes_Handler,
+		},
+		{
+			MethodName: "GetDeviceType",
+			Handler:    _VolthaLocalService_GetDeviceType_Handler,
+		},
+		{
+			MethodName: "ListDeviceGroups",
+			Handler:    _VolthaLocalService_ListDeviceGroups_Handler,
+		},
+		{
+			MethodName: "GetDeviceGroup",
+			Handler:    _VolthaLocalService_GetDeviceGroup_Handler,
+		},
+		{
+			MethodName: "CreateAlarmFilter",
+			Handler:    _VolthaLocalService_CreateAlarmFilter_Handler,
+		},
+		{
+			MethodName: "GetAlarmFilter",
+			Handler:    _VolthaLocalService_GetAlarmFilter_Handler,
+		},
+		{
+			MethodName: "UpdateAlarmFilter",
+			Handler:    _VolthaLocalService_UpdateAlarmFilter_Handler,
+		},
+		{
+			MethodName: "DeleteAlarmFilter",
+			Handler:    _VolthaLocalService_DeleteAlarmFilter_Handler,
+		},
+		{
+			MethodName: "ListAlarmFilters",
+			Handler:    _VolthaLocalService_ListAlarmFilters_Handler,
+		},
+	},
+	Streams: []grpc.StreamDesc{
+		{
+			StreamName:    "StreamPacketsOut",
+			Handler:       _VolthaLocalService_StreamPacketsOut_Handler,
+			ClientStreams: true,
+		},
+		{
+			StreamName:    "ReceivePacketsIn",
+			Handler:       _VolthaLocalService_ReceivePacketsIn_Handler,
+			ServerStreams: true,
+		},
+		{
+			StreamName:    "ReceiveChangeEvents",
+			Handler:       _VolthaLocalService_ReceiveChangeEvents_Handler,
+			ServerStreams: true,
+		},
+	},
+	Metadata: "voltha.proto",
+}
+
+func init() { proto.RegisterFile("voltha.proto", fileDescriptor0) }
+
+var fileDescriptor0 = []byte{
+	// 2029 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x58, 0x4b, 0x73, 0x1b, 0x59,
+	0x15, 0x4e, 0xfb, 0xad, 0x23, 0xc9, 0x92, 0xae, 0x5f, 0xb2, 0x6c, 0x4f, 0xec, 0x9b, 0x49, 0xc6,
+	0xf1, 0x94, 0xa5, 0xc4, 0x66, 0x42, 0x4d, 0x18, 0x8a, 0xc1, 0x8f, 0x24, 0x26, 0x2e, 0xa2, 0x52,
+	0x32, 0x33, 0x40, 0x48, 0xa9, 0xda, 0xd2, 0x8d, 0xdc, 0x4c, 0xab, 0x5b, 0xd5, 0xdd, 0xd2, 0x8c,
+	0x6a, 0x60, 0xc1, 0xb0, 0x82, 0x25, 0xd9, 0xc0, 0x9e, 0x0d, 0x6c, 0xf8, 0x25, 0x59, 0x50, 0xfc,
+	0x03, 0x8a, 0x05, 0xbf, 0x60, 0x60, 0x49, 0xdd, 0x97, 0xd4, 0x8f, 0xdb, 0x7a, 0xd9, 0xb3, 0x98,
+	0x5d, 0xf7, 0x7d, 0x7c, 0xdf, 0x39, 0xa7, 0xcf, 0x39, 0xf7, 0x7e, 0x0d, 0xa9, 0x8e, 0x6d, 0x7a,
+	0x97, 0x7a, 0xb1, 0xe5, 0xd8, 0x9e, 0x8d, 0xe6, 0xf8, 0x5b, 0x61, 0xa3, 0x61, 0xdb, 0x0d, 0x93,
+	0x94, 0xd8, 0xe8, 0x45, 0xfb, 0x75, 0x89, 0x34, 0x5b, 0x5e, 0x97, 0x2f, 0x2a, 0xac, 0x87, 0x27,
+	0x75, 0x4b, 0x4e, 0x6d, 0x8a, 0x29, 0xbd, 0x65, 0x94, 0x74, 0xcb, 0xb2, 0x3d, 0xdd, 0x33, 0x6c,
+	0xcb, 0x15, 0xb3, 0xa8, 0xab, 0x5b, 0x8d, 0xaa, 0xdd, 0xf2, 0x8f, 0x41, 0x93, 0x78, 0x82, 0xbd,
+	0x90, 0xaa, 0xd9, 0xcd, 0xa6, 0x6d, 0xc9, 0xb7, 0x4b, 0xa2, 0x9b, 0xde, 0xa5, 0x78, 0x5b, 0x36,
+	0xed, 0x86, 0x51, 0xd3, 0xcd, 0x6a, 0x9d, 0x74, 0x8c, 0x1a, 0x91, 0x6b, 0x02, 0x6f, 0x69, 0xbd,
+	0xae, 0xb7, 0x3c, 0xe2, 0x88, 0xd7, 0x9c, 0xdd, 0x22, 0xd6, 0x6b, 0xd3, 0xfe, 0xa2, 0x7a, 0xff,
+	0x90, 0x0f, 0xe1, 0xbf, 0x68, 0x90, 0x3c, 0x61, 0x5b, 0x1e, 0x3b, 0x76, 0xbb, 0x85, 0x56, 0x60,
+	0xca, 0xa8, 0xe7, 0xb5, 0x6d, 0x6d, 0x37, 0x71, 0x34, 0xfb, 0x9f, 0x6f, 0xde, 0x6e, 0x69, 0x95,
+	0x29, 0xa3, 0x8e, 0xce, 0x20, 0x13, 0xa4, 0x73, 0xf3, 0x53, 0xdb, 0xd3, 0xbb, 0xc9, 0x83, 0x95,
+	0xa2, 0x08, 0xd7, 0x39, 0x9f, 0xe6, 0x58, 0x47, 0x89, 0x7f, 0x7d, 0xf3, 0x76, 0x6b, 0x86, 0x62,
+	0x55, 0x16, 0x4d, 0xff, 0x8c, 0x8b, 0x0e, 0x61, 0x5e, 0x42, 0x4c, 0x33, 0x88, 0x45, 0x09, 0x11,
+	0xdd, 0x2b, 0x57, 0xe2, 0x0f, 0x21, 0xe5, 0xb3, 0xd2, 0x45, 0x77, 0x61, 0xd6, 0xf0, 0x48, 0xd3,
+	0xcd, 0x6b, 0x0c, 0x62, 0x29, 0x08, 0xc1, 0x16, 0x55, 0xf8, 0x0a, 0xfc, 0x25, 0xa0, 0x1f, 0x9b,
+	0xba, 0xd3, 0x7c, 0x64, 0x98, 0x1e, 0x71, 0x2a, 0x6d, 0x93, 0x3c, 0x25, 0x5d, 0x7c, 0xa1, 0x1a,
+	0x45, 0x73, 0x94, 0x35, 0x7b, 0x03, 0x2d, 0xc0, 0x8c, 0xd7, 0x6d, 0x91, 0xac, 0x86, 0x52, 0xb0,
+	0xe0, 0x92, 0x0e, 0x71, 0x0c, 0xaf, 0x9b, 0x9d, 0x42, 0x19, 0x48, 0x3a, 0xc4, 0xb5, 0xdb, 0x4e,
+	0x8d, 0x54, 0x8d, 0x7a, 0x76, 0x9a, 0x4e, 0xd7, 0x74, 0x8f, 0x34, 0x6c, 0xa7, 0x9b, 0x9d, 0x41,
+	0x69, 0x48, 0x70, 0x83, 0xe9, 0xe4, 0x2c, 0xbe, 0x84, 0x4c, 0x88, 0x03, 0xfd, 0x08, 0xa6, 0x3f,
+	0x27, 0x5d, 0x16, 0xdf, 0xc5, 0x83, 0x7d, 0x69, 0x75, 0xd4, 0x12, 0xc5, 0x50, 0x85, 0xee, 0x44,
+	0xcb, 0x30, 0xdb, 0xd1, 0xcd, 0x36, 0xc9, 0x4f, 0xd1, 0x4f, 0x54, 0xe1, 0x2f, 0xf8, 0x39, 0x24,
+	0x7d, 0x1b, 0xe2, 0x3e, 0xe2, 0x3e, 0xcc, 0x3a, 0x6d, 0xb3, 0xf7, 0xe9, 0xd6, 0x62, 0xe8, 0x2b,
+	0x7c, 0x15, 0xfe, 0x21, 0xa4, 0x7c, 0x33, 0x2e, 0xda, 0x87, 0xf9, 0xd7, 0xfc, 0x31, 0x1c, 0x75,
+	0x3f, 0x80, 0x5c, 0x83, 0xff, 0x31, 0x03, 0x8b, 0x9f, 0xb2, 0xf9, 0x33, 0xcb, 0xf5, 0x74, 0xab,
+	0x46, 0xd0, 0x1d, 0x48, 0x1a, 0xe2, 0xb9, 0x1a, 0x36, 0x10, 0xe4, 0xcc, 0x59, 0x1d, 0xdd, 0x84,
+	0xf9, 0x0e, 0x71, 0x5c, 0xc3, 0xb6, 0xb8, 0x9b, 0x72, 0x8d, 0x1c, 0x45, 0x0f, 0x20, 0x61, 0xda,
+	0x8d, 0xaa, 0x49, 0x3a, 0xc4, 0xcc, 0x4f, 0xb3, 0x60, 0xae, 0xfb, 0x12, 0xf1, 0x9c, 0x8e, 0xf7,
+	0x1e, 0x2a, 0x0b, 0xa6, 0x78, 0x42, 0x87, 0x30, 0xc7, 0x6b, 0x28, 0x0f, 0xdb, 0xda, 0x6e, 0xf2,
+	0x60, 0x59, 0x6e, 0x7a, 0xc2, 0x46, 0x9f, 0x7b, 0xba, 0xd7, 0x76, 0x8f, 0x66, 0x69, 0x02, 0xde,
+	0xa8, 0x88, 0xa5, 0xe8, 0x01, 0x2c, 0x88, 0x32, 0x72, 0xf3, 0x49, 0xe6, 0x78, 0xa6, 0xe7, 0x38,
+	0x1f, 0xf7, 0xa7, 0x6c, 0x6f, 0xad, 0xaa, 0x66, 0x52, 0x57, 0xaf, 0x99, 0xf4, 0xa8, 0x35, 0x83,
+	0x3e, 0x06, 0xd1, 0x0c, 0xaa, 0x34, 0x97, 0xdd, 0xfc, 0x22, 0xdb, 0x89, 0x82, 0x3b, 0x5f, 0x74,
+	0x5b, 0x81, 0xdd, 0xc9, 0x7a, 0x6f, 0xd8, 0x45, 0xc7, 0x90, 0x16, 0x08, 0x0d, 0x56, 0x76, 0xf9,
+	0x4c, 0x6c, 0xb5, 0xf9, 0x31, 0x04, 0xad, 0x28, 0xd5, 0x63, 0x48, 0xeb, 0x34, 0x3f, 0xaa, 0x32,
+	0x79, 0xb2, 0xb1, 0xc9, 0x13, 0x00, 0xd1, 0x7d, 0xb9, 0xf7, 0x70, 0xf6, 0x7f, 0x34, 0x01, 0x70,
+	0x11, 0x32, 0xc1, 0x94, 0x72, 0x69, 0x41, 0xf4, 0x3b, 0x41, 0x42, 0x14, 0xbd, 0x5c, 0xff, 0xf7,
+	0x69, 0x98, 0xe3, 0x1b, 0xfc, 0x39, 0xa5, 0x0d, 0xcf, 0xa9, 0xa9, 0xd1, 0x73, 0xea, 0x09, 0x24,
+	0x64, 0xea, 0xca, 0x8e, 0xb6, 0x2a, 0xf7, 0x05, 0x8d, 0x3d, 0x42, 0xd4, 0xbd, 0x74, 0xa0, 0x08,
+	0x2a, 0xfd, 0xcd, 0xdf, 0xd9, 0x44, 0xbb, 0x8e, 0x34, 0x11, 0x5f, 0xec, 0xe0, 0xcd, 0x3a, 0x2c,
+	0xf1, 0xa8, 0x3d, 0x36, 0xed, 0x0b, 0xdd, 0x7c, 0x4e, 0x1c, 0xba, 0x08, 0x9d, 0x40, 0xe2, 0x31,
+	0xf1, 0xc4, 0xb7, 0x5c, 0x2d, 0xf2, 0x53, 0xb5, 0x28, 0x0f, 0xdc, 0xe2, 0x29, 0x3d, 0x8d, 0x0b,
+	0x8b, 0xc1, 0xb8, 0xe3, 0xcc, 0xd7, 0xff, 0xfc, 0xf7, 0x9b, 0xa9, 0x04, 0x9a, 0x67, 0xc7, 0x6f,
+	0xe7, 0x3e, 0xea, 0xc2, 0xd2, 0xb9, 0xe1, 0x7a, 0xe1, 0x1c, 0x8a, 0xc3, 0x5b, 0x53, 0x7f, 0x47,
+	0x17, 0xdf, 0xff, 0xc3, 0x7f, 0xdf, 0x6e, 0xcd, 0x8b, 0xcc, 0x63, 0xcf, 0x88, 0x3f, 0x33, 0xc2,
+	0x25, 0x94, 0x13, 0x84, 0xa5, 0xfe, 0xc7, 0xfd, 0x0c, 0x72, 0x3d, 0x07, 0x7a, 0x0d, 0x11, 0x24,
+	0xc1, 0xd9, 0x49, 0x21, 0x26, 0x69, 0xf0, 0x3b, 0x0c, 0x33, 0x8f, 0x56, 0x23, 0x98, 0xa5, 0xaf,
+	0x8c, 0xfa, 0x6f, 0xd0, 0x57, 0x80, 0xa8, 0x4f, 0xe7, 0xc1, 0x0f, 0x19, 0xe7, 0xd2, 0xaa, 0x32,
+	0x25, 0x5c, 0xfc, 0x01, 0xf5, 0x22, 0x17, 0x49, 0x24, 0xc6, 0xbd, 0x8e, 0xd6, 0x24, 0x77, 0x68,
+	0x1a, 0xbd, 0x84, 0xec, 0x63, 0x12, 0xe4, 0x0e, 0x38, 0xa5, 0xce, 0x40, 0xfc, 0x2e, 0xc3, 0x7d,
+	0x07, 0x6d, 0xc6, 0xe0, 0x72, 0xcf, 0x1c, 0x58, 0x8d, 0x78, 0x56, 0xb6, 0x1d, 0xcf, 0x0d, 0x50,
+	0x2c, 0x87, 0x28, 0xd8, 0x0a, 0xfc, 0x40, 0x7c, 0xa1, 0x16, 0x7d, 0x63, 0x6c, 0xef, 0x22, 0x3c,
+	0x88, 0xad, 0xc4, 0x56, 0xa2, 0x5f, 0x2b, 0x38, 0x1f, 0x99, 0xf6, 0x17, 0x41, 0x4e, 0x54, 0xf4,
+	0xdf, 0xa4, 0xd8, 0x3c, 0x3e, 0x12, 0x8c, 0x74, 0x34, 0x9a, 0x13, 0xc3, 0xd8, 0xd9, 0x2e, 0xf4,
+	0x3b, 0x0d, 0x36, 0x3f, 0x69, 0xd5, 0x75, 0x8f, 0x44, 0x0c, 0x78, 0xa1, 0x5f, 0x98, 0x04, 0x6d,
+	0x46, 0x88, 0xd9, 0x38, 0xdf, 0x53, 0x88, 0xf9, 0xe8, 0x78, 0x9f, 0x99, 0xf0, 0x1e, 0x1e, 0xc1,
+	0x84, 0x87, 0xda, 0x1e, 0xfa, 0xa3, 0x06, 0x1b, 0xca, 0x20, 0x88, 0x8e, 0xee, 0x8f, 0xc4, 0x5a,
+	0xc4, 0x20, 0xbe, 0x08, 0xff, 0x94, 0x86, 0x20, 0x0d, 0x49, 0x36, 0xc5, 0xfb, 0x42, 0x24, 0x28,
+	0x7b, 0x68, 0x77, 0xa8, 0x45, 0x62, 0x2f, 0x7a, 0xa3, 0xc1, 0x4e, 0x4c, 0x68, 0x18, 0x23, 0x8f,
+	0xcf, 0x8e, 0xda, 0x9c, 0x51, 0x82, 0x74, 0xc8, 0x4c, 0xda, 0xc7, 0x23, 0x9b, 0x44, 0x43, 0xf5,
+	0x0a, 0x92, 0x34, 0x52, 0xc3, 0xaa, 0x2e, 0x13, 0x6c, 0x85, 0x2e, 0xbe, 0x4d, 0x63, 0x91, 0xe8,
+	0x35, 0x5b, 0x46, 0x9d, 0x43, 0x19, 0x49, 0x2d, 0xcb, 0xeb, 0x94, 0x75, 0x3d, 0x45, 0x5d, 0x85,
+	0xda, 0x32, 0xde, 0x64, 0x08, 0xab, 0x68, 0x39, 0x84, 0xc0, 0x0b, 0xe9, 0x27, 0x90, 0x3a, 0x76,
+	0x88, 0xee, 0x11, 0x81, 0x14, 0xda, 0x1d, 0x41, 0x2b, 0x30, 0xb4, 0x65, 0x1c, 0xb6, 0x87, 0x7a,
+	0xfc, 0x19, 0xa4, 0x4e, 0x2d, 0x1a, 0x4e, 0x85, 0x55, 0x71, 0xa1, 0xbd, 0xc5, 0xf0, 0xb6, 0xf0,
+	0x86, 0xca, 0xba, 0x12, 0x61, 0x70, 0xe8, 0xe7, 0x90, 0x3e, 0x31, 0xdc, 0x31, 0x91, 0x45, 0x23,
+	0xc1, 0x9b, 0x4a, 0xe4, 0x3a, 0xc7, 0xa3, 0x36, 0x57, 0xc8, 0x85, 0x6d, 0x7b, 0xd7, 0x66, 0xb3,
+	0xc3, 0xe0, 0x28, 0xf0, 0x09, 0x31, 0x89, 0x37, 0x41, 0x30, 0xf6, 0xd4, 0xc0, 0x75, 0x06, 0x87,
+	0x7e, 0x09, 0x99, 0x7e, 0x5e, 0x45, 0x7b, 0x5e, 0x5a, 0x3e, 0xf3, 0x66, 0x57, 0x8c, 0x34, 0xbb,
+	0x4d, 0x54, 0x50, 0xc2, 0xf3, 0x26, 0xf7, 0x8a, 0x1f, 0x83, 0x02, 0xbd, 0x79, 0x6c, 0x5b, 0xaf,
+	0x8d, 0x46, 0x90, 0x21, 0xd7, 0x63, 0x90, 0xd3, 0xf8, 0x3d, 0x86, 0xbc, 0x83, 0x6e, 0xaa, 0x91,
+	0x9b, 0xd5, 0x9a, 0xc0, 0xb1, 0x60, 0x85, 0xd7, 0x5a, 0x98, 0x20, 0x0a, 0x1a, 0x1b, 0xa5, 0x3d,
+	0xde, 0x35, 0xf1, 0x30, 0x32, 0x9a, 0x92, 0x4d, 0x7f, 0xb0, 0x46, 0x6b, 0xd6, 0x0f, 0x07, 0x36,
+	0xeb, 0xb8, 0xe8, 0xf5, 0x9a, 0xf4, 0x72, 0x90, 0x6f, 0x9c, 0xbe, 0xf8, 0x68, 0x84, 0xbe, 0x88,
+	0xd1, 0x76, 0x2c, 0xbf, 0xec, 0x87, 0xb6, 0xdf, 0x69, 0x7e, 0x5d, 0x8f, 0xeb, 0x3e, 0x4b, 0xd1,
+	0x2b, 0xbf, 0x8b, 0x4b, 0x94, 0x75, 0x31, 0x28, 0x11, 0xd4, 0x4d, 0x84, 0xcf, 0xa1, 0x0a, 0xa4,
+	0x7b, 0xbd, 0x88, 0x42, 0x84, 0x62, 0x1c, 0xa1, 0xc0, 0x3b, 0x0c, 0x6e, 0x03, 0xad, 0xab, 0xe0,
+	0x78, 0x63, 0x72, 0x21, 0xdb, 0x77, 0x42, 0x44, 0x31, 0xce, 0x8b, 0x65, 0xc5, 0x75, 0x52, 0xdc,
+	0xc4, 0x32, 0xa1, 0x0b, 0x28, 0x23, 0x5e, 0x43, 0x2b, 0x21, 0x62, 0x11, 0xb9, 0x4f, 0x60, 0xb1,
+	0xe7, 0x08, 0xff, 0xe9, 0xe1, 0xf7, 0x44, 0x75, 0x6b, 0xc5, 0x58, 0x9d, 0x16, 0x02, 0x91, 0xfb,
+	0x52, 0x85, 0x1c, 0x6f, 0xb2, 0x7e, 0x25, 0xae, 0x52, 0x39, 0x05, 0xd5, 0x20, 0xde, 0x66, 0x14,
+	0x05, 0xdc, 0x33, 0x3a, 0x20, 0x9a, 0x68, 0x9a, 0x73, 0xbb, 0xfd, 0xe8, 0x4a, 0xbb, 0xfd, 0xa0,
+	0x11, 0xbb, 0x03, 0xa0, 0xdc, 0xee, 0x3a, 0xe4, 0x78, 0xb5, 0x4e, 0x66, 0xf7, 0x6d, 0x46, 0x71,
+	0xb3, 0x30, 0x80, 0x82, 0x1a, 0xff, 0x12, 0x72, 0xbc, 0x53, 0xc6, 0xd9, 0x1f, 0xd7, 0x08, 0x84,
+	0x0b, 0x7b, 0x83, 0x5c, 0xa8, 0xf2, 0x34, 0x0a, 0xfc, 0xad, 0x18, 0x9a, 0x46, 0xfe, 0xd5, 0x78,
+	0x2b, 0x9c, 0x32, 0x01, 0x96, 0x83, 0xbf, 0x6e, 0x02, 0xe2, 0xd7, 0xf2, 0x73, 0xbb, 0xd6, 0x17,
+	0x25, 0xbf, 0x50, 0xdd, 0xe9, 0x87, 0xde, 0xbc, 0x43, 0xf7, 0xfb, 0x15, 0x46, 0x9d, 0x41, 0xe9,
+	0xfe, 0xbd, 0xa3, 0xa6, 0x9b, 0xa8, 0xce, 0x8e, 0x7e, 0xfe, 0x5f, 0x62, 0xb8, 0x33, 0xfe, 0xff,
+	0x17, 0xf8, 0x2e, 0xad, 0x89, 0x05, 0xf9, 0xab, 0x23, 0x5c, 0xd4, 0x0c, 0xbe, 0x24, 0xfe, 0x6d,
+	0x34, 0x20, 0xc5, 0x22, 0x27, 0xa5, 0x64, 0x1c, 0x51, 0x36, 0x24, 0x44, 0x5d, 0xbc, 0x4f, 0x49,
+	0xa0, 0xaf, 0x58, 0xc3, 0x2a, 0x85, 0xd3, 0xf4, 0x34, 0xea, 0x6f, 0xb5, 0x6b, 0x91, 0x29, 0x3f,
+	0x18, 0x20, 0x53, 0x6e, 0xa2, 0xad, 0x20, 0x79, 0x58, 0xac, 0xe8, 0x93, 0x89, 0x95, 0xbd, 0xe8,
+	0x05, 0x5e, 0x81, 0xce, 0x33, 0xf1, 0xcb, 0x2b, 0x48, 0x96, 0x8f, 0x22, 0xa7, 0x78, 0xe0, 0x7e,
+	0x1c, 0xc7, 0x29, 0xce, 0xf4, 0xaf, 0xb5, 0x89, 0x95, 0xcb, 0x93, 0x81, 0x87, 0xe1, 0x68, 0x46,
+	0xf0, 0xa3, 0xf1, 0xf7, 0xdf, 0x8e, 0x7e, 0x51, 0x5c, 0xcd, 0x07, 0x1b, 0x42, 0x3b, 0xce, 0x9f,
+	0xae, 0x43, 0xc5, 0xbc, 0x18, 0xe1, 0xb4, 0xbe, 0x87, 0x8a, 0x23, 0xda, 0x25, 0x4f, 0xa0, 0x3f,
+	0x7f, 0xdb, 0x5a, 0xe6, 0x43, 0x66, 0xd8, 0x21, 0x1e, 0xd3, 0x30, 0x1a, 0xb6, 0xda, 0x84, 0x8a,
+	0xe6, 0x7d, 0x85, 0xa2, 0xf1, 0xf5, 0x53, 0x6e, 0x80, 0xac, 0xc4, 0xa7, 0xa3, 0xea, 0x9a, 0xc8,
+	0x01, 0x16, 0xc0, 0xe1, 0x35, 0x57, 0x1e, 0x53, 0xdd, 0x44, 0x4e, 0xda, 0x00, 0x26, 0x57, 0x75,
+	0xe3, 0x6b, 0x9c, 0xbb, 0x0c, 0xf5, 0x16, 0xde, 0x89, 0xb7, 0x54, 0x2a, 0x9d, 0xea, 0x24, 0x4a,
+	0x47, 0x5e, 0x88, 0xf1, 0x00, 0x7c, 0xa9, 0x77, 0x5e, 0x4d, 0xa0, 0x77, 0x46, 0xb1, 0x5f, 0xa8,
+	0x9e, 0x57, 0x13, 0xa8, 0x1e, 0x01, 0xbf, 0x37, 0x08, 0x5e, 0x68, 0x9f, 0x8b, 0xb1, 0xb4, 0xcf,
+	0xf7, 0x22, 0x5d, 0xd3, 0x77, 0x7b, 0x56, 0x90, 0xf0, 0x6e, 0x59, 0x9b, 0x48, 0x01, 0x89, 0xff,
+	0x28, 0xe8, 0xf6, 0x20, 0xfc, 0xbe, 0x0e, 0xf2, 0xae, 0x41, 0x07, 0xdd, 0xe3, 0x3d, 0x18, 0x8f,
+	0x46, 0x49, 0x93, 0xd7, 0x1d, 0x5f, 0x0d, 0x7d, 0x3c, 0xf0, 0x00, 0x18, 0x1c, 0xcf, 0x5e, 0xe3,
+	0xbf, 0x82, 0x26, 0x3a, 0x1f, 0xa1, 0xcb, 0xee, 0xa2, 0x3b, 0x43, 0xac, 0x90, 0xdd, 0xb5, 0x7d,
+	0x45, 0x65, 0xf4, 0x41, 0x9c, 0x32, 0x8a, 0x69, 0x43, 0x42, 0x1f, 0xfd, 0x6c, 0x5c, 0x7d, 0x14,
+	0xd1, 0xd3, 0x51, 0x50, 0xde, 0xe0, 0xba, 0x57, 0x56, 0x49, 0xdf, 0x8f, 0x55, 0x49, 0x5b, 0x68,
+	0x43, 0x49, 0x2f, 0x62, 0xf9, 0x72, 0x7c, 0xad, 0xb4, 0x3b, 0x28, 0x69, 0x02, 0x8a, 0xe9, 0x11,
+	0x64, 0x9f, 0x7b, 0x0e, 0xd1, 0x9b, 0x65, 0xbd, 0xf6, 0x39, 0xf1, 0xdc, 0x67, 0x6d, 0x0f, 0xad,
+	0x06, 0x72, 0x84, 0x4f, 0x3c, 0x6b, 0x7b, 0xb1, 0xf5, 0x71, 0x63, 0x57, 0x43, 0xa7, 0x90, 0xad,
+	0x90, 0x1a, 0x31, 0x3a, 0x44, 0x00, 0x9d, 0x59, 0xb1, 0xf1, 0x59, 0x51, 0xe0, 0x9f, 0x59, 0xf8,
+	0xc6, 0x3d, 0x0d, 0x3d, 0x85, 0x25, 0x01, 0x73, 0x7c, 0xa9, 0x5b, 0x0d, 0x72, 0xda, 0x21, 0x96,
+	0x17, 0x1f, 0xe9, 0x7c, 0x00, 0xc9, 0xb7, 0x85, 0x81, 0x91, 0xab, 0xa9, 0xc1, 0x3b, 0x2c, 0x88,
+	0xdb, 0x38, 0xf4, 0x71, 0x22, 0x9a, 0xf0, 0xe5, 0xf8, 0x9a, 0x30, 0xe6, 0xfb, 0x28, 0x64, 0xd5,
+	0xaf, 0xae, 0xa6, 0x0c, 0xdf, 0x67, 0x44, 0xb7, 0x0b, 0x43, 0x89, 0xa8, 0x23, 0xfa, 0xa4, 0xfa,
+	0x50, 0xb8, 0xb3, 0x37, 0xdc, 0x1d, 0x72, 0x65, 0x95, 0x78, 0x4b, 0x5d, 0x32, 0x01, 0xae, 0xa3,
+	0x8f, 0x60, 0xc9, 0x76, 0x1a, 0x2c, 0x39, 0x6a, 0xb6, 0x53, 0x17, 0x40, 0x47, 0x29, 0x2e, 0xfb,
+	0xca, 0x94, 0xc7, 0xfd, 0xdb, 0xd4, 0xea, 0x33, 0x39, 0xff, 0xa9, 0x5f, 0x15, 0x96, 0x67, 0xca,
+	0xb3, 0xe5, 0xb9, 0xf2, 0x7c, 0x79, 0xa1, 0x9c, 0x28, 0xc3, 0xc5, 0x1c, 0x33, 0xeb, 0xf0, 0xff,
+	0x01, 0x00, 0x00, 0xff, 0xff, 0xfa, 0x33, 0xad, 0xd7, 0x94, 0x22, 0x00, 0x00,
+}
diff --git a/netopeer/voltha-grpc-client/voltha/yang_options/yang_options.pb.go b/netopeer/voltha-grpc-client/voltha/yang_options/yang_options.pb.go
new file mode 100644
index 0000000..4876a98
--- /dev/null
+++ b/netopeer/voltha-grpc-client/voltha/yang_options/yang_options.pb.go
@@ -0,0 +1,193 @@
+// Code generated by protoc-gen-go.
+// source: yang_options.proto
+// DO NOT EDIT!
+
+/*
+Package voltha is a generated protocol buffer package.
+
+It is generated from these files:
+	yang_options.proto
+
+It has these top-level messages:
+	InlineNode
+	RpcReturnDef
+*/
+package yang_options
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+import google_protobuf "github.com/golang/protobuf/protoc-gen-go/descriptor"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+type MessageParserOption int32
+
+const (
+	// Move any enclosing child enum/message definition to the same level
+	// as the parent (this message) in the yang generated file
+	MessageParserOption_MOVE_TO_PARENT_LEVEL MessageParserOption = 0
+	// Create both a grouping and a container for this message.  The container
+	// name will be the message name.  The grouping name will be the message
+	// name prefixed with "grouping_"
+	MessageParserOption_CREATE_BOTH_GROUPING_AND_CONTAINER MessageParserOption = 1
+)
+
+var MessageParserOption_name = map[int32]string{
+	0: "MOVE_TO_PARENT_LEVEL",
+	1: "CREATE_BOTH_GROUPING_AND_CONTAINER",
+}
+var MessageParserOption_value = map[string]int32{
+	"MOVE_TO_PARENT_LEVEL":               0,
+	"CREATE_BOTH_GROUPING_AND_CONTAINER": 1,
+}
+
+func (x MessageParserOption) String() string {
+	return proto.EnumName(MessageParserOption_name, int32(x))
+}
+func (MessageParserOption) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
+
+type InlineNode struct {
+	Id   string `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
+	Type string `protobuf:"bytes,2,opt,name=type" json:"type,omitempty"`
+}
+
+func (m *InlineNode) Reset()                    { *m = InlineNode{} }
+func (m *InlineNode) String() string            { return proto.CompactTextString(m) }
+func (*InlineNode) ProtoMessage()               {}
+func (*InlineNode) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
+
+func (m *InlineNode) GetId() string {
+	if m != nil {
+		return m.Id
+	}
+	return ""
+}
+
+func (m *InlineNode) GetType() string {
+	if m != nil {
+		return m.Type
+	}
+	return ""
+}
+
+type RpcReturnDef struct {
+	// The gRPC methods return message types.  NETCONF expects an actual
+	// attribute as defined in the YANG schema.  The xnl_tag will be used
+	// as the top most tag when translating a gRPC response into an xml
+	// response
+	XmlTag string `protobuf:"bytes,1,opt,name=xml_tag,json=xmlTag" json:"xml_tag,omitempty"`
+	// When the gRPC response is a list of items, we need to differentiate
+	// between a YANG schema attribute whose name is "items" and when "items"
+	// is used only to indicate a list of items is being returned.  The default
+	// behavior assumes a list is returned when "items" is present in
+	// the response.  This option will therefore be used when the attribute
+	// name in the YANG schema is 'items'
+	ListItemsName string `protobuf:"bytes,2,opt,name=list_items_name,json=listItemsName" json:"list_items_name,omitempty"`
+}
+
+func (m *RpcReturnDef) Reset()                    { *m = RpcReturnDef{} }
+func (m *RpcReturnDef) String() string            { return proto.CompactTextString(m) }
+func (*RpcReturnDef) ProtoMessage()               {}
+func (*RpcReturnDef) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
+
+func (m *RpcReturnDef) GetXmlTag() string {
+	if m != nil {
+		return m.XmlTag
+	}
+	return ""
+}
+
+func (m *RpcReturnDef) GetListItemsName() string {
+	if m != nil {
+		return m.ListItemsName
+	}
+	return ""
+}
+
+var E_YangChildRule = &proto.ExtensionDesc{
+	ExtendedType:  (*google_protobuf.MessageOptions)(nil),
+	ExtensionType: (*MessageParserOption)(nil),
+	Field:         7761774,
+	Name:          "voltha.yang_child_rule",
+	Tag:           "varint,7761774,opt,name=yang_child_rule,json=yangChildRule,enum=voltha.MessageParserOption",
+	Filename:      "yang_options.proto",
+}
+
+var E_YangMessageRule = &proto.ExtensionDesc{
+	ExtendedType:  (*google_protobuf.MessageOptions)(nil),
+	ExtensionType: (*MessageParserOption)(nil),
+	Field:         7761775,
+	Name:          "voltha.yang_message_rule",
+	Tag:           "varint,7761775,opt,name=yang_message_rule,json=yangMessageRule,enum=voltha.MessageParserOption",
+	Filename:      "yang_options.proto",
+}
+
+var E_YangInlineNode = &proto.ExtensionDesc{
+	ExtendedType:  (*google_protobuf.FieldOptions)(nil),
+	ExtensionType: (*InlineNode)(nil),
+	Field:         7761776,
+	Name:          "voltha.yang_inline_node",
+	Tag:           "bytes,7761776,opt,name=yang_inline_node,json=yangInlineNode",
+	Filename:      "yang_options.proto",
+}
+
+var E_YangXmlTag = &proto.ExtensionDesc{
+	ExtendedType:  (*google_protobuf.MethodOptions)(nil),
+	ExtensionType: (*RpcReturnDef)(nil),
+	Field:         7761777,
+	Name:          "voltha.yang_xml_tag",
+	Tag:           "bytes,7761777,opt,name=yang_xml_tag,json=yangXmlTag",
+	Filename:      "yang_options.proto",
+}
+
+func init() {
+	proto.RegisterType((*InlineNode)(nil), "voltha.InlineNode")
+	proto.RegisterType((*RpcReturnDef)(nil), "voltha.RpcReturnDef")
+	proto.RegisterEnum("voltha.MessageParserOption", MessageParserOption_name, MessageParserOption_value)
+	proto.RegisterExtension(E_YangChildRule)
+	proto.RegisterExtension(E_YangMessageRule)
+	proto.RegisterExtension(E_YangInlineNode)
+	proto.RegisterExtension(E_YangXmlTag)
+}
+
+func init() { proto.RegisterFile("yang_options.proto", fileDescriptor0) }
+
+var fileDescriptor0 = []byte{
+	// 416 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x92, 0xcf, 0x8e, 0xd3, 0x30,
+	0x10, 0x87, 0x49, 0x41, 0x45, 0x0c, 0xbb, 0xdd, 0x62, 0x56, 0x22, 0x02, 0x01, 0x55, 0x0f, 0xab,
+	0x15, 0x87, 0x2c, 0x5a, 0x6e, 0xbd, 0x85, 0x6e, 0x28, 0x91, 0xda, 0xa4, 0xb2, 0x42, 0x81, 0x0b,
+	0x96, 0xdb, 0xb8, 0xa9, 0x85, 0x13, 0x47, 0xb1, 0x83, 0xda, 0x47, 0xe5, 0xc2, 0x23, 0xf0, 0xe7,
+	0x0d, 0x50, 0x9c, 0x84, 0x22, 0x6d, 0x0f, 0xbd, 0x25, 0x13, 0xe7, 0xfb, 0x3c, 0xf3, 0x1b, 0x40,
+	0x3b, 0x9a, 0x25, 0x44, 0xe6, 0x9a, 0xcb, 0x4c, 0x39, 0x79, 0x21, 0xb5, 0x44, 0xdd, 0x6f, 0x52,
+	0xe8, 0x0d, 0x7d, 0x3a, 0x48, 0xa4, 0x4c, 0x04, 0xbb, 0x32, 0xd5, 0x65, 0xb9, 0xbe, 0x8a, 0x99,
+	0x5a, 0x15, 0x3c, 0xd7, 0xb2, 0xa8, 0x4f, 0x0e, 0x5f, 0x03, 0xf8, 0x99, 0xe0, 0x19, 0x0b, 0x64,
+	0xcc, 0x50, 0x0f, 0x3a, 0x3c, 0xb6, 0xad, 0x81, 0x75, 0xf9, 0x00, 0x77, 0x78, 0x8c, 0x10, 0xdc,
+	0xd3, 0xbb, 0x9c, 0xd9, 0x1d, 0x53, 0x31, 0xcf, 0xc3, 0x10, 0x4e, 0x70, 0xbe, 0xc2, 0x4c, 0x97,
+	0x45, 0x76, 0xc3, 0xd6, 0xe8, 0x09, 0xdc, 0xdf, 0xa6, 0x82, 0x68, 0x9a, 0x34, 0x3f, 0x76, 0xb7,
+	0xa9, 0x88, 0x68, 0x82, 0x2e, 0xe0, 0x4c, 0x70, 0xa5, 0x09, 0xd7, 0x2c, 0x55, 0x24, 0xa3, 0x69,
+	0xcb, 0x39, 0xad, 0xca, 0x7e, 0x55, 0x0d, 0x68, 0xca, 0x5e, 0x7d, 0x84, 0xc7, 0x33, 0xa6, 0x14,
+	0x4d, 0xd8, 0x9c, 0x16, 0x8a, 0x15, 0xa1, 0x69, 0x05, 0xd9, 0x70, 0x3e, 0x0b, 0x17, 0x1e, 0x89,
+	0x42, 0x32, 0x77, 0xb1, 0x17, 0x44, 0x64, 0xea, 0x2d, 0xbc, 0x69, 0xff, 0x0e, 0xba, 0x80, 0xe1,
+	0x18, 0x7b, 0x6e, 0xe4, 0x91, 0xb7, 0x61, 0xf4, 0x9e, 0x4c, 0x70, 0xf8, 0x61, 0xee, 0x07, 0x13,
+	0xe2, 0x06, 0x37, 0x64, 0x1c, 0x06, 0x91, 0xeb, 0x07, 0x1e, 0xee, 0x5b, 0xa3, 0x04, 0xce, 0xcc,
+	0x6c, 0x56, 0x1b, 0x2e, 0x62, 0x52, 0x94, 0x82, 0xa1, 0x97, 0x4e, 0x3d, 0x11, 0xa7, 0x9d, 0x88,
+	0xd3, 0xa8, 0x6b, 0xa9, 0xb2, 0x7f, 0xfe, 0xf8, 0x7e, 0x77, 0x60, 0x5d, 0xf6, 0xae, 0x9f, 0x39,
+	0xf5, 0x0c, 0x9d, 0x03, 0x77, 0xc3, 0xa7, 0x15, 0x77, 0x5c, 0x61, 0x71, 0x29, 0xd8, 0xe8, 0x2b,
+	0x3c, 0x32, 0xa2, 0xb4, 0x3e, 0x7a, 0xa4, 0xea, 0xd7, 0x51, 0x2a, 0xd3, 0x42, 0xf3, 0xc1, 0xc8,
+	0xbe, 0x40, 0xdf, 0xc8, 0xb8, 0x89, 0x8d, 0x64, 0x55, 0x6e, 0xcf, 0x6f, 0xb9, 0xde, 0x71, 0x26,
+	0xe2, 0xd6, 0xf4, 0xbb, 0x36, 0x3d, 0xbc, 0x46, 0xad, 0x69, 0x9f, 0x39, 0xee, 0x55, 0xb4, 0xfd,
+	0xfb, 0xe8, 0x33, 0x9c, 0x18, 0x7e, 0x13, 0x2a, 0x7a, 0x71, 0xa0, 0x0f, 0xbd, 0x91, 0xff, 0xe0,
+	0x7f, 0x5a, 0xf8, 0x79, 0x0b, 0xff, 0x7f, 0x3d, 0x30, 0x54, 0xb0, 0x4f, 0x66, 0x23, 0x96, 0x5d,
+	0x83, 0x78, 0xf3, 0x37, 0x00, 0x00, 0xff, 0xff, 0x4e, 0x8b, 0xcb, 0x68, 0xb3, 0x02, 0x00, 0x00,
+}