diff --git a/of10/action.go b/of10/action.go
new file mode 100644
index 0000000..a93f39e
--- /dev/null
+++ b/of10/action.go
@@ -0,0 +1,5789 @@
+/*
+ * Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
+ * Copyright (c) 2011, 2012 Open Networking Foundation
+ * Copyright 2013, Big Switch Networks, Inc. This library was generated by the LoxiGen Compiler.
+ * Copyright 2018, Red Hat, Inc.
+ */
+// Automatically generated by LOXI from template module.go
+// Do not modify
+
+package of10
+
+import (
+	"bytes"
+	"encoding/binary"
+	"encoding/json"
+	"fmt"
+	"net"
+
+	"github.com/opencord/goloxi"
+)
+
+type Action struct {
+	Type uint16
+	Len  uint16
+}
+
+type IAction interface {
+	goloxi.Serializable
+	GetType() uint16
+	GetLen() uint16
+	GetActionName() string
+	GetActionFields() map[string]interface{}
+}
+
+func (self *Action) GetType() uint16 {
+	return self.Type
+}
+
+func (self *Action) SetType(v uint16) {
+	self.Type = v
+}
+
+func (self *Action) GetLen() uint16 {
+	return self.Len
+}
+
+func (self *Action) SetLen(v uint16) {
+	self.Len = v
+}
+
+func (self *Action) Serialize(encoder *goloxi.Encoder) error {
+
+	encoder.PutUint16(uint16(self.Type))
+	encoder.PutUint16(uint16(self.Len))
+
+	return nil
+}
+
+func DecodeAction(decoder *goloxi.Decoder) (goloxi.IAction, error) {
+	_action := &Action{}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("Action packet too short: %d < 4", decoder.Length())
+	}
+	_action.Type = uint16(decoder.ReadUint16())
+	_action.Len = uint16(decoder.ReadUint16())
+	oldDecoder := decoder
+	defer func() { decoder = oldDecoder }()
+	decoder = decoder.SliceDecoder(int(_action.Len), 2+2)
+
+	switch _action.Type {
+	case 0:
+		return DecodeActionOutput(_action, decoder)
+	case 1:
+		return DecodeActionSetVlanVid(_action, decoder)
+	case 2:
+		return DecodeActionSetVlanPcp(_action, decoder)
+	case 3:
+		return DecodeActionStripVlan(_action, decoder)
+	case 4:
+		return DecodeActionSetDlSrc(_action, decoder)
+	case 5:
+		return DecodeActionSetDlDst(_action, decoder)
+	case 6:
+		return DecodeActionSetNwSrc(_action, decoder)
+	case 7:
+		return DecodeActionSetNwDst(_action, decoder)
+	case 8:
+		return DecodeActionSetNwTos(_action, decoder)
+	case 9:
+		return DecodeActionSetTpSrc(_action, decoder)
+	case 10:
+		return DecodeActionSetTpDst(_action, decoder)
+	case 11:
+		return DecodeActionEnqueue(_action, decoder)
+	case 65535:
+		return DecodeActionExperimenter(_action, decoder)
+	default:
+		return nil, fmt.Errorf("Invalid type '%d' for 'Action'", _action.Type)
+	}
+}
+
+func NewAction(_type uint16) *Action {
+	obj := &Action{}
+	obj.Type = _type
+	return obj
+}
+
+type ActionExperimenter struct {
+	*Action
+	Experimenter uint32
+}
+
+type IActionExperimenter interface {
+	goloxi.IAction
+	GetExperimenter() uint32
+}
+
+func (self *ActionExperimenter) GetExperimenter() uint32 {
+	return self.Experimenter
+}
+
+func (self *ActionExperimenter) SetExperimenter(v uint32) {
+	self.Experimenter = v
+}
+
+func (self *ActionExperimenter) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Action.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Experimenter))
+
+	return nil
+}
+
+func DecodeActionExperimenter(parent *Action, decoder *goloxi.Decoder) (IActionExperimenter, error) {
+	_actionexperimenter := &ActionExperimenter{Action: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("ActionExperimenter packet too short: %d < 4", decoder.Length())
+	}
+	_actionexperimenter.Experimenter = uint32(decoder.ReadUint32())
+
+	switch _actionexperimenter.Experimenter {
+	case 8992:
+		return DecodeActionNicira(_actionexperimenter, decoder)
+	case 6035143:
+		return DecodeActionBsn(_actionexperimenter, decoder)
+	default:
+		return nil, fmt.Errorf("Invalid type '%d' for 'ActionExperimenter'", _actionexperimenter.Experimenter)
+	}
+}
+
+func NewActionExperimenter(_experimenter uint32) *ActionExperimenter {
+	obj := &ActionExperimenter{
+		Action: NewAction(65535),
+	}
+	obj.Experimenter = _experimenter
+	return obj
+}
+func (self *ActionExperimenter) GetActionName() string {
+	return "experimenter"
+}
+
+func (self *ActionExperimenter) GetActionFields() map[string]interface{} {
+	return map[string]interface{}{
+		"Experimenter": self.Experimenter,
+	}
+}
+
+func (self *ActionExperimenter) MarshalJSON() ([]byte, error) {
+	jsonValue, err := json.Marshal(self.GetActionFields())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionBsn struct {
+	*ActionExperimenter
+	Subtype uint32
+}
+
+type IActionBsn interface {
+	IActionExperimenter
+	GetSubtype() uint32
+}
+
+func (self *ActionBsn) GetSubtype() uint32 {
+	return self.Subtype
+}
+
+func (self *ActionBsn) SetSubtype(v uint32) {
+	self.Subtype = v
+}
+
+func (self *ActionBsn) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.ActionExperimenter.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Subtype))
+
+	return nil
+}
+
+func DecodeActionBsn(parent *ActionExperimenter, decoder *goloxi.Decoder) (IActionBsn, error) {
+	_actionbsn := &ActionBsn{ActionExperimenter: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("ActionBsn packet too short: %d < 4", decoder.Length())
+	}
+	_actionbsn.Subtype = uint32(decoder.ReadUint32())
+
+	switch _actionbsn.Subtype {
+	case 1:
+		return DecodeActionBsnMirror(_actionbsn, decoder)
+	case 2:
+		return DecodeActionBsnSetTunnelDst(_actionbsn, decoder)
+	case 4:
+		return DecodeActionBsnChecksum(_actionbsn, decoder)
+	default:
+		return nil, fmt.Errorf("Invalid type '%d' for 'ActionBsn'", _actionbsn.Subtype)
+	}
+}
+
+func NewActionBsn(_subtype uint32) *ActionBsn {
+	obj := &ActionBsn{
+		ActionExperimenter: NewActionExperimenter(6035143),
+	}
+	obj.Subtype = _subtype
+	return obj
+}
+func (self *ActionBsn) GetActionName() string {
+	return "bsn"
+}
+
+func (self *ActionBsn) GetActionFields() map[string]interface{} {
+	return map[string]interface{}{
+		"Subtype": self.Subtype,
+	}
+}
+
+func (self *ActionBsn) MarshalJSON() ([]byte, error) {
+	jsonValue, err := json.Marshal(self.GetActionFields())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionBsnChecksum struct {
+	*ActionBsn
+	Checksum Checksum128
+}
+
+type IActionBsnChecksum interface {
+	IActionBsn
+	GetChecksum() Checksum128
+}
+
+func (self *ActionBsnChecksum) GetChecksum() Checksum128 {
+	return self.Checksum
+}
+
+func (self *ActionBsnChecksum) SetChecksum(v Checksum128) {
+	self.Checksum = v
+}
+
+func (self *ActionBsnChecksum) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionBsn.Serialize(encoder); err != nil {
+		return err
+	}
+
+	self.Checksum.Serialize(encoder)
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionBsnChecksum(parent *ActionBsn, decoder *goloxi.Decoder) (*ActionBsnChecksum, error) {
+	_actionbsnchecksum := &ActionBsnChecksum{ActionBsn: parent}
+	if decoder.Length() < 16 {
+		return nil, fmt.Errorf("ActionBsnChecksum packet too short: %d < 16", decoder.Length())
+	}
+	_actionbsnchecksum.Checksum.Decode(decoder)
+	return _actionbsnchecksum, nil
+}
+
+func NewActionBsnChecksum() *ActionBsnChecksum {
+	obj := &ActionBsnChecksum{
+		ActionBsn: NewActionBsn(4),
+	}
+	return obj
+}
+func (self *ActionBsnChecksum) GetActionName() string {
+	return "bsn_checksum"
+}
+
+func (self *ActionBsnChecksum) GetActionFields() map[string]interface{} {
+	return map[string]interface{}{
+		"Checksum": self.Checksum,
+	}
+}
+
+func (self *ActionBsnChecksum) MarshalJSON() ([]byte, error) {
+	jsonValue, err := json.Marshal(self.GetActionFields())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionBsnMirror struct {
+	*ActionBsn
+	DestPort  uint32
+	VlanTag   uint32
+	CopyStage uint8
+}
+
+type IActionBsnMirror interface {
+	IActionBsn
+	GetDestPort() uint32
+	GetVlanTag() uint32
+	GetCopyStage() uint8
+}
+
+func (self *ActionBsnMirror) GetDestPort() uint32 {
+	return self.DestPort
+}
+
+func (self *ActionBsnMirror) SetDestPort(v uint32) {
+	self.DestPort = v
+}
+
+func (self *ActionBsnMirror) GetVlanTag() uint32 {
+	return self.VlanTag
+}
+
+func (self *ActionBsnMirror) SetVlanTag(v uint32) {
+	self.VlanTag = v
+}
+
+func (self *ActionBsnMirror) GetCopyStage() uint8 {
+	return self.CopyStage
+}
+
+func (self *ActionBsnMirror) SetCopyStage(v uint8) {
+	self.CopyStage = v
+}
+
+func (self *ActionBsnMirror) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionBsn.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.DestPort))
+	encoder.PutUint32(uint32(self.VlanTag))
+	encoder.PutUint8(uint8(self.CopyStage))
+	encoder.Write(bytes.Repeat([]byte{0}, 3))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionBsnMirror(parent *ActionBsn, decoder *goloxi.Decoder) (*ActionBsnMirror, error) {
+	_actionbsnmirror := &ActionBsnMirror{ActionBsn: parent}
+	if decoder.Length() < 12 {
+		return nil, fmt.Errorf("ActionBsnMirror packet too short: %d < 12", decoder.Length())
+	}
+	_actionbsnmirror.DestPort = uint32(decoder.ReadUint32())
+	_actionbsnmirror.VlanTag = uint32(decoder.ReadUint32())
+	_actionbsnmirror.CopyStage = uint8(decoder.ReadByte())
+	decoder.Skip(3)
+	return _actionbsnmirror, nil
+}
+
+func NewActionBsnMirror() *ActionBsnMirror {
+	obj := &ActionBsnMirror{
+		ActionBsn: NewActionBsn(1),
+	}
+	return obj
+}
+func (self *ActionBsnMirror) GetActionName() string {
+	return "bsn_mirror"
+}
+
+func (self *ActionBsnMirror) GetActionFields() map[string]interface{} {
+	return map[string]interface{}{
+		"DestPort":  self.DestPort,
+		"VlanTag":   self.VlanTag,
+		"CopyStage": self.CopyStage,
+	}
+}
+
+func (self *ActionBsnMirror) MarshalJSON() ([]byte, error) {
+	jsonValue, err := json.Marshal(self.GetActionFields())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionBsnSetTunnelDst struct {
+	*ActionBsn
+	Dst uint32
+}
+
+type IActionBsnSetTunnelDst interface {
+	IActionBsn
+	GetDst() uint32
+}
+
+func (self *ActionBsnSetTunnelDst) GetDst() uint32 {
+	return self.Dst
+}
+
+func (self *ActionBsnSetTunnelDst) SetDst(v uint32) {
+	self.Dst = v
+}
+
+func (self *ActionBsnSetTunnelDst) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionBsn.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Dst))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionBsnSetTunnelDst(parent *ActionBsn, decoder *goloxi.Decoder) (*ActionBsnSetTunnelDst, error) {
+	_actionbsnsettunneldst := &ActionBsnSetTunnelDst{ActionBsn: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("ActionBsnSetTunnelDst packet too short: %d < 4", decoder.Length())
+	}
+	_actionbsnsettunneldst.Dst = uint32(decoder.ReadUint32())
+	return _actionbsnsettunneldst, nil
+}
+
+func NewActionBsnSetTunnelDst() *ActionBsnSetTunnelDst {
+	obj := &ActionBsnSetTunnelDst{
+		ActionBsn: NewActionBsn(2),
+	}
+	return obj
+}
+func (self *ActionBsnSetTunnelDst) GetActionName() string {
+	return "bsn_set_tunnel_dst"
+}
+
+func (self *ActionBsnSetTunnelDst) GetActionFields() map[string]interface{} {
+	return map[string]interface{}{
+		"Dst": self.Dst,
+	}
+}
+
+func (self *ActionBsnSetTunnelDst) MarshalJSON() ([]byte, error) {
+	jsonValue, err := json.Marshal(self.GetActionFields())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionEnqueue struct {
+	*Action
+	Port    Port
+	QueueId uint32
+}
+
+type IActionEnqueue interface {
+	goloxi.IAction
+	GetPort() Port
+	GetQueueId() uint32
+}
+
+func (self *ActionEnqueue) GetPort() Port {
+	return self.Port
+}
+
+func (self *ActionEnqueue) SetPort(v Port) {
+	self.Port = v
+}
+
+func (self *ActionEnqueue) GetQueueId() uint32 {
+	return self.QueueId
+}
+
+func (self *ActionEnqueue) SetQueueId(v uint32) {
+	self.QueueId = v
+}
+
+func (self *ActionEnqueue) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.Action.Serialize(encoder); err != nil {
+		return err
+	}
+
+	self.Port.Serialize(encoder)
+	encoder.Write(bytes.Repeat([]byte{0}, 6))
+	encoder.PutUint32(uint32(self.QueueId))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionEnqueue(parent *Action, decoder *goloxi.Decoder) (*ActionEnqueue, error) {
+	_actionenqueue := &ActionEnqueue{Action: parent}
+	if decoder.Length() < 12 {
+		return nil, fmt.Errorf("ActionEnqueue packet too short: %d < 12", decoder.Length())
+	}
+	_actionenqueue.Port.Decode(decoder)
+	decoder.Skip(6)
+	_actionenqueue.QueueId = uint32(decoder.ReadUint32())
+	return _actionenqueue, nil
+}
+
+func NewActionEnqueue() *ActionEnqueue {
+	obj := &ActionEnqueue{
+		Action: NewAction(11),
+	}
+	return obj
+}
+func (self *ActionEnqueue) GetActionName() string {
+	return "enqueue"
+}
+
+func (self *ActionEnqueue) GetActionFields() map[string]interface{} {
+	return map[string]interface{}{
+		"Port":    self.Port,
+		"QueueId": self.QueueId,
+	}
+}
+
+func (self *ActionEnqueue) MarshalJSON() ([]byte, error) {
+	jsonValue, err := json.Marshal(self.GetActionFields())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNicira struct {
+	*ActionExperimenter
+	Subtype uint16
+}
+
+type IActionNicira interface {
+	IActionExperimenter
+	GetSubtype() uint16
+}
+
+func (self *ActionNicira) GetSubtype() uint16 {
+	return self.Subtype
+}
+
+func (self *ActionNicira) SetSubtype(v uint16) {
+	self.Subtype = v
+}
+
+func (self *ActionNicira) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.ActionExperimenter.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Subtype))
+
+	return nil
+}
+
+func DecodeActionNicira(parent *ActionExperimenter, decoder *goloxi.Decoder) (IActionNicira, error) {
+	_actionnicira := &ActionNicira{ActionExperimenter: parent}
+	if decoder.Length() < 2 {
+		return nil, fmt.Errorf("ActionNicira packet too short: %d < 2", decoder.Length())
+	}
+	_actionnicira.Subtype = uint16(decoder.ReadUint16())
+
+	switch _actionnicira.Subtype {
+	case 1:
+		return DecodeActionNxResubmit(_actionnicira, decoder)
+	case 2:
+		return DecodeActionNxSetTunnel(_actionnicira, decoder)
+	case 4:
+		return DecodeActionNxSetQueue(_actionnicira, decoder)
+	case 5:
+		return DecodeActionNxPopQueue(_actionnicira, decoder)
+	case 6:
+		return DecodeActionNxRegMove(_actionnicira, decoder)
+	case 7:
+		return DecodeActionNxRegLoad(_actionnicira, decoder)
+	case 8:
+		return DecodeActionNxNote(_actionnicira, decoder)
+	case 9:
+		return DecodeActionNxSetTunnel64(_actionnicira, decoder)
+	case 10:
+		return DecodeActionNxMultipath(_actionnicira, decoder)
+	case 12:
+		return DecodeActionNxBundle(_actionnicira, decoder)
+	case 13:
+		return DecodeActionNxBundleLoadInPort(_actionnicira, decoder)
+	case 14:
+		return DecodeActionResubmit(_actionnicira, decoder)
+	case 15:
+		return DecodeActionNxOutputReg(_actionnicira, decoder)
+	case 16:
+		return DecodeActionNxLearn(_actionnicira, decoder)
+	case 17:
+		return DecodeActionNxExit(_actionnicira, decoder)
+	case 18:
+		return DecodeActionNiciraDecTtl(_actionnicira, decoder)
+	case 19:
+		return DecodeActionNxFinTimeout(_actionnicira, decoder)
+	case 20:
+		return DecodeActionNxController(_actionnicira, decoder)
+	case 21:
+		return DecodeActionNxDecTtlCntIds(_actionnicira, decoder)
+	case 22:
+		return DecodeActionNxWriteMetadata(_actionnicira, decoder)
+	case 23:
+		return DecodeActionNxPushMpls(_actionnicira, decoder)
+	case 24:
+		return DecodeActionNxPopMpls(_actionnicira, decoder)
+	case 25:
+		return DecodeActionNxSetMplsTtl(_actionnicira, decoder)
+	case 26:
+		return DecodeActionNxDecMplsTtl(_actionnicira, decoder)
+	case 27:
+		return DecodeActionNxStackPush(_actionnicira, decoder)
+	case 28:
+		return DecodeActionNxStackPop(_actionnicira, decoder)
+	case 29:
+		return DecodeActionNxSample(_actionnicira, decoder)
+	case 30:
+		return DecodeActionNxSetMplsLabel(_actionnicira, decoder)
+	case 31:
+		return DecodeActionNxSetMplsTc(_actionnicira, decoder)
+	case 32:
+		return DecodeActionNxOutputReg2(_actionnicira, decoder)
+	case 33:
+		return DecodeActionNxRegLoad2(_actionnicira, decoder)
+	case 34:
+		return DecodeActionNxConjunction(_actionnicira, decoder)
+	case 35:
+		return DecodeActionNxCt(_actionnicira, decoder)
+	case 36:
+		return DecodeActionNxNat(_actionnicira, decoder)
+	case 37:
+		return DecodeActionNxController2(_actionnicira, decoder)
+	case 38:
+		return DecodeActionNxSample2(_actionnicira, decoder)
+	case 39:
+		return DecodeActionNxOutputTrunc(_actionnicira, decoder)
+	case 40:
+		return DecodeActionNxGroup(_actionnicira, decoder)
+	case 41:
+		return DecodeActionNxSample3(_actionnicira, decoder)
+	case 42:
+		return DecodeActionNxClone(_actionnicira, decoder)
+	case 43:
+		return DecodeActionNxCtClear(_actionnicira, decoder)
+	case 44:
+		return DecodeActionNxResubmitTableCt(_actionnicira, decoder)
+	case 45:
+		return DecodeActionNxLearn2(_actionnicira, decoder)
+	case 46:
+		return DecodeActionNxEncap(_actionnicira, decoder)
+	case 47:
+		return DecodeActionNxDecap(_actionnicira, decoder)
+	case 48:
+		return DecodeActionNxDecNshTtl(_actionnicira, decoder)
+	case 254:
+		return DecodeActionNxDebugSlow(_actionnicira, decoder)
+	case 255:
+		return DecodeActionNxDebugRecirc(_actionnicira, decoder)
+	default:
+		return nil, fmt.Errorf("Invalid type '%d' for 'ActionNicira'", _actionnicira.Subtype)
+	}
+}
+
+func NewActionNicira(_subtype uint16) *ActionNicira {
+	obj := &ActionNicira{
+		ActionExperimenter: NewActionExperimenter(8992),
+	}
+	obj.Subtype = _subtype
+	return obj
+}
+func (self *ActionNicira) GetActionName() string {
+	return "nicira"
+}
+
+func (self *ActionNicira) GetActionFields() map[string]interface{} {
+	return map[string]interface{}{
+		"Subtype": self.Subtype,
+	}
+}
+
+func (self *ActionNicira) MarshalJSON() ([]byte, error) {
+	jsonValue, err := json.Marshal(self.GetActionFields())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNiciraDecTtl struct {
+	*ActionNicira
+}
+
+type IActionNiciraDecTtl interface {
+	IActionNicira
+}
+
+func (self *ActionNiciraDecTtl) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionNicira.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(bytes.Repeat([]byte{0}, 2))
+	encoder.Write(bytes.Repeat([]byte{0}, 4))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionNiciraDecTtl(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNiciraDecTtl, error) {
+	_actionniciradecttl := &ActionNiciraDecTtl{ActionNicira: parent}
+	if decoder.Length() < 6 {
+		return nil, fmt.Errorf("ActionNiciraDecTtl packet too short: %d < 6", decoder.Length())
+	}
+	decoder.Skip(2)
+	decoder.Skip(4)
+	return _actionniciradecttl, nil
+}
+
+func NewActionNiciraDecTtl() *ActionNiciraDecTtl {
+	obj := &ActionNiciraDecTtl{
+		ActionNicira: NewActionNicira(18),
+	}
+	return obj
+}
+func (self *ActionNiciraDecTtl) GetActionName() string {
+	return "nicira_dec_ttl"
+}
+
+func (self *ActionNiciraDecTtl) GetActionFields() map[string]interface{} {
+	return map[string]interface{}{}
+}
+
+func (self *ActionNiciraDecTtl) MarshalJSON() ([]byte, error) {
+	jsonValue, err := json.Marshal(self.GetActionFields())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxBundle struct {
+	*ActionNicira
+	Algorithm uint16
+	Fields    NxHashFields
+	Basis     uint16
+	SlaveType ActionNxBundleSlaveType
+	NSlaves   uint16
+	OfsNbits  uint16
+	Dst       goloxi.IOxmId
+}
+
+type IActionNxBundle interface {
+	IActionNicira
+	GetAlgorithm() uint16
+	GetFields() NxHashFields
+	GetBasis() uint16
+	GetSlaveType() ActionNxBundleSlaveType
+	GetNSlaves() uint16
+	GetOfsNbits() uint16
+	GetDst() goloxi.IOxmId
+}
+
+func (self *ActionNxBundle) GetAlgorithm() uint16 {
+	return self.Algorithm
+}
+
+func (self *ActionNxBundle) SetAlgorithm(v uint16) {
+	self.Algorithm = v
+}
+
+func (self *ActionNxBundle) GetFields() NxHashFields {
+	return self.Fields
+}
+
+func (self *ActionNxBundle) SetFields(v NxHashFields) {
+	self.Fields = v
+}
+
+func (self *ActionNxBundle) GetBasis() uint16 {
+	return self.Basis
+}
+
+func (self *ActionNxBundle) SetBasis(v uint16) {
+	self.Basis = v
+}
+
+func (self *ActionNxBundle) GetSlaveType() ActionNxBundleSlaveType {
+	return self.SlaveType
+}
+
+func (self *ActionNxBundle) SetSlaveType(v ActionNxBundleSlaveType) {
+	self.SlaveType = v
+}
+
+func (self *ActionNxBundle) GetNSlaves() uint16 {
+	return self.NSlaves
+}
+
+func (self *ActionNxBundle) SetNSlaves(v uint16) {
+	self.NSlaves = v
+}
+
+func (self *ActionNxBundle) GetOfsNbits() uint16 {
+	return self.OfsNbits
+}
+
+func (self *ActionNxBundle) SetOfsNbits(v uint16) {
+	self.OfsNbits = v
+}
+
+func (self *ActionNxBundle) GetDst() goloxi.IOxmId {
+	return self.Dst
+}
+
+func (self *ActionNxBundle) SetDst(v goloxi.IOxmId) {
+	self.Dst = v
+}
+
+func (self *ActionNxBundle) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionNicira.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Algorithm))
+	encoder.PutUint16(uint16(self.Fields))
+	encoder.PutUint16(uint16(self.Basis))
+	encoder.PutUint32(uint32(self.SlaveType))
+	encoder.PutUint16(uint16(self.NSlaves))
+	encoder.PutUint16(uint16(self.OfsNbits))
+	self.Dst.Serialize(encoder)
+	encoder.Write(bytes.Repeat([]byte{0}, 4))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionNxBundle(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxBundle, error) {
+	_actionnxbundle := &ActionNxBundle{ActionNicira: parent}
+	if decoder.Length() < 22 {
+		return nil, fmt.Errorf("ActionNxBundle packet too short: %d < 22", decoder.Length())
+	}
+	_actionnxbundle.Algorithm = uint16(decoder.ReadUint16())
+	_actionnxbundle.Fields = NxHashFields(decoder.ReadUint16())
+	_actionnxbundle.Basis = uint16(decoder.ReadUint16())
+	_actionnxbundle.SlaveType = ActionNxBundleSlaveType(decoder.ReadUint32())
+	_actionnxbundle.NSlaves = uint16(decoder.ReadUint16())
+	_actionnxbundle.OfsNbits = uint16(decoder.ReadUint16())
+	if obj, err := DecodeOxmId(decoder); err != nil {
+		return nil, err
+	} else {
+		_actionnxbundle.Dst = obj
+	}
+
+	decoder.Skip(4)
+	return _actionnxbundle, nil
+}
+
+func NewActionNxBundle() *ActionNxBundle {
+	obj := &ActionNxBundle{
+		ActionNicira: NewActionNicira(12),
+	}
+	return obj
+}
+func (self *ActionNxBundle) GetActionName() string {
+	return "nx_bundle"
+}
+
+func (self *ActionNxBundle) GetActionFields() map[string]interface{} {
+	return map[string]interface{}{
+		"Algorithm": self.Algorithm,
+		"Fields":    self.Fields,
+		"Basis":     self.Basis,
+		"SlaveType": self.SlaveType,
+		"NSlaves":   self.NSlaves,
+		"OfsNbits":  self.OfsNbits,
+		"Dst":       self.Dst,
+	}
+}
+
+func (self *ActionNxBundle) MarshalJSON() ([]byte, error) {
+	jsonValue, err := json.Marshal(self.GetActionFields())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxBundleLoad struct {
+	*ActionNicira
+	Algorithm NxBdAlgorithms
+	Fields    NxHashFields
+	Basis     uint16
+	SlaveType ActionNxBundleSlaveType
+	NSlaves   uint16
+	OfsNbits  uint16
+	Dst       goloxi.IOxmId
+}
+
+type IActionNxBundleLoad interface {
+	IActionNicira
+	GetAlgorithm() NxBdAlgorithms
+	GetFields() NxHashFields
+	GetBasis() uint16
+	GetSlaveType() ActionNxBundleSlaveType
+	GetNSlaves() uint16
+	GetOfsNbits() uint16
+	GetDst() goloxi.IOxmId
+}
+
+func (self *ActionNxBundleLoad) GetAlgorithm() NxBdAlgorithms {
+	return self.Algorithm
+}
+
+func (self *ActionNxBundleLoad) SetAlgorithm(v NxBdAlgorithms) {
+	self.Algorithm = v
+}
+
+func (self *ActionNxBundleLoad) GetFields() NxHashFields {
+	return self.Fields
+}
+
+func (self *ActionNxBundleLoad) SetFields(v NxHashFields) {
+	self.Fields = v
+}
+
+func (self *ActionNxBundleLoad) GetBasis() uint16 {
+	return self.Basis
+}
+
+func (self *ActionNxBundleLoad) SetBasis(v uint16) {
+	self.Basis = v
+}
+
+func (self *ActionNxBundleLoad) GetSlaveType() ActionNxBundleSlaveType {
+	return self.SlaveType
+}
+
+func (self *ActionNxBundleLoad) SetSlaveType(v ActionNxBundleSlaveType) {
+	self.SlaveType = v
+}
+
+func (self *ActionNxBundleLoad) GetNSlaves() uint16 {
+	return self.NSlaves
+}
+
+func (self *ActionNxBundleLoad) SetNSlaves(v uint16) {
+	self.NSlaves = v
+}
+
+func (self *ActionNxBundleLoad) GetOfsNbits() uint16 {
+	return self.OfsNbits
+}
+
+func (self *ActionNxBundleLoad) SetOfsNbits(v uint16) {
+	self.OfsNbits = v
+}
+
+func (self *ActionNxBundleLoad) GetDst() goloxi.IOxmId {
+	return self.Dst
+}
+
+func (self *ActionNxBundleLoad) SetDst(v goloxi.IOxmId) {
+	self.Dst = v
+}
+
+func (self *ActionNxBundleLoad) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.ActionNicira.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Algorithm))
+	encoder.PutUint16(uint16(self.Fields))
+	encoder.PutUint16(uint16(self.Basis))
+	encoder.PutUint32(uint32(self.SlaveType))
+	encoder.PutUint16(uint16(self.NSlaves))
+	encoder.PutUint16(uint16(self.OfsNbits))
+	self.Dst.Serialize(encoder)
+
+	return nil
+}
+
+func DecodeActionNxBundleLoad(parent *ActionNicira, decoder *goloxi.Decoder) (IActionNxBundleLoad, error) {
+	_actionnxbundleload := &ActionNxBundleLoad{ActionNicira: parent}
+	if decoder.Length() < 18 {
+		return nil, fmt.Errorf("ActionNxBundleLoad packet too short: %d < 18", decoder.Length())
+	}
+	_actionnxbundleload.Algorithm = NxBdAlgorithms(decoder.ReadUint16())
+	_actionnxbundleload.Fields = NxHashFields(decoder.ReadUint16())
+	_actionnxbundleload.Basis = uint16(decoder.ReadUint16())
+	_actionnxbundleload.SlaveType = ActionNxBundleSlaveType(decoder.ReadUint32())
+	_actionnxbundleload.NSlaves = uint16(decoder.ReadUint16())
+	_actionnxbundleload.OfsNbits = uint16(decoder.ReadUint16())
+	if obj, err := DecodeOxmId(decoder); err != nil {
+		return nil, err
+	} else {
+		_actionnxbundleload.Dst = obj
+	}
+
+	return _actionnxbundleload, nil
+}
+
+func NewActionNxBundleLoad(_slave_type ActionNxBundleSlaveType) *ActionNxBundleLoad {
+	obj := &ActionNxBundleLoad{
+		ActionNicira: NewActionNicira(13),
+	}
+	obj.SlaveType = _slave_type
+	return obj
+}
+func (self *ActionNxBundleLoad) GetActionName() string {
+	return "nx_bundle_load"
+}
+
+func (self *ActionNxBundleLoad) GetActionFields() map[string]interface{} {
+	return map[string]interface{}{
+		"Algorithm": self.Algorithm,
+		"Fields":    self.Fields,
+		"Basis":     self.Basis,
+		"SlaveType": self.SlaveType,
+		"NSlaves":   self.NSlaves,
+		"OfsNbits":  self.OfsNbits,
+		"Dst":       self.Dst,
+	}
+}
+
+func (self *ActionNxBundleLoad) MarshalJSON() ([]byte, error) {
+	jsonValue, err := json.Marshal(self.GetActionFields())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxBundleLoadInPort struct {
+	*ActionNicira
+	Algorithm NxBdAlgorithms
+	Fields    NxHashFields
+	Basis     uint16
+	SlaveType ActionNxBundleSlaveType
+	NSlaves   uint16
+	OfsNbits  uint16
+	Dst       goloxi.IOxmId
+	InPorts   []*ActionNxBundleLoadSlave
+}
+
+type IActionNxBundleLoadInPort interface {
+	IActionNicira
+	GetAlgorithm() NxBdAlgorithms
+	GetFields() NxHashFields
+	GetBasis() uint16
+	GetSlaveType() ActionNxBundleSlaveType
+	GetNSlaves() uint16
+	GetOfsNbits() uint16
+	GetDst() goloxi.IOxmId
+	GetInPorts() []*ActionNxBundleLoadSlave
+}
+
+func (self *ActionNxBundleLoadInPort) GetAlgorithm() NxBdAlgorithms {
+	return self.Algorithm
+}
+
+func (self *ActionNxBundleLoadInPort) SetAlgorithm(v NxBdAlgorithms) {
+	self.Algorithm = v
+}
+
+func (self *ActionNxBundleLoadInPort) GetFields() NxHashFields {
+	return self.Fields
+}
+
+func (self *ActionNxBundleLoadInPort) SetFields(v NxHashFields) {
+	self.Fields = v
+}
+
+func (self *ActionNxBundleLoadInPort) GetBasis() uint16 {
+	return self.Basis
+}
+
+func (self *ActionNxBundleLoadInPort) SetBasis(v uint16) {
+	self.Basis = v
+}
+
+func (self *ActionNxBundleLoadInPort) GetSlaveType() ActionNxBundleSlaveType {
+	return self.SlaveType
+}
+
+func (self *ActionNxBundleLoadInPort) SetSlaveType(v ActionNxBundleSlaveType) {
+	self.SlaveType = v
+}
+
+func (self *ActionNxBundleLoadInPort) GetNSlaves() uint16 {
+	return self.NSlaves
+}
+
+func (self *ActionNxBundleLoadInPort) SetNSlaves(v uint16) {
+	self.NSlaves = v
+}
+
+func (self *ActionNxBundleLoadInPort) GetOfsNbits() uint16 {
+	return self.OfsNbits
+}
+
+func (self *ActionNxBundleLoadInPort) SetOfsNbits(v uint16) {
+	self.OfsNbits = v
+}
+
+func (self *ActionNxBundleLoadInPort) GetDst() goloxi.IOxmId {
+	return self.Dst
+}
+
+func (self *ActionNxBundleLoadInPort) SetDst(v goloxi.IOxmId) {
+	self.Dst = v
+}
+
+func (self *ActionNxBundleLoadInPort) GetInPorts() []*ActionNxBundleLoadSlave {
+	return self.InPorts
+}
+
+func (self *ActionNxBundleLoadInPort) SetInPorts(v []*ActionNxBundleLoadSlave) {
+	self.InPorts = v
+}
+
+func (self *ActionNxBundleLoadInPort) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionNicira.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Algorithm))
+	encoder.PutUint16(uint16(self.Fields))
+	encoder.PutUint16(uint16(self.Basis))
+	encoder.PutUint32(uint32(self.SlaveType))
+	encoder.PutUint16(uint16(self.NSlaves))
+	encoder.PutUint16(uint16(self.OfsNbits))
+	self.Dst.Serialize(encoder)
+	encoder.Write(bytes.Repeat([]byte{0}, 4))
+	for _, obj := range self.InPorts {
+		if err := obj.Serialize(encoder); err != nil {
+			return err
+		}
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionNxBundleLoadInPort(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxBundleLoadInPort, error) {
+	_actionnxbundleloadinport := &ActionNxBundleLoadInPort{ActionNicira: parent}
+	if decoder.Length() < 22 {
+		return nil, fmt.Errorf("ActionNxBundleLoadInPort packet too short: %d < 22", decoder.Length())
+	}
+	_actionnxbundleloadinport.Algorithm = NxBdAlgorithms(decoder.ReadUint16())
+	_actionnxbundleloadinport.Fields = NxHashFields(decoder.ReadUint16())
+	_actionnxbundleloadinport.Basis = uint16(decoder.ReadUint16())
+	_actionnxbundleloadinport.SlaveType = ActionNxBundleSlaveType(decoder.ReadUint32())
+	_actionnxbundleloadinport.NSlaves = uint16(decoder.ReadUint16())
+	_actionnxbundleloadinport.OfsNbits = uint16(decoder.ReadUint16())
+	if obj, err := DecodeOxmId(decoder); err != nil {
+		return nil, err
+	} else {
+		_actionnxbundleloadinport.Dst = obj
+	}
+
+	decoder.Skip(4)
+
+	end := decoder.Offset() + int(_actionnxbundleloadinport.NSlaves)
+	for decoder.Offset() < end {
+		item, err := DecodeActionNxBundleLoadSlave(decoder)
+		if err != nil {
+			return nil, err
+		}
+		if item != nil {
+			_actionnxbundleloadinport.InPorts = append(_actionnxbundleloadinport.InPorts, item)
+		}
+	}
+	return _actionnxbundleloadinport, nil
+}
+
+func NewActionNxBundleLoadInPort() *ActionNxBundleLoadInPort {
+	obj := &ActionNxBundleLoadInPort{
+		ActionNicira: NewActionNicira(13),
+	}
+	return obj
+}
+func (self *ActionNxBundleLoadInPort) GetActionName() string {
+	return "nx_bundle_load_in_port"
+}
+
+func (self *ActionNxBundleLoadInPort) GetActionFields() map[string]interface{} {
+	return map[string]interface{}{
+		"Algorithm": self.Algorithm,
+		"Fields":    self.Fields,
+		"Basis":     self.Basis,
+		"SlaveType": self.SlaveType,
+		"NSlaves":   self.NSlaves,
+		"OfsNbits":  self.OfsNbits,
+		"Dst":       self.Dst,
+		"InPorts":   self.InPorts,
+	}
+}
+
+func (self *ActionNxBundleLoadInPort) MarshalJSON() ([]byte, error) {
+	jsonValue, err := json.Marshal(self.GetActionFields())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxClone struct {
+	*ActionNicira
+	Actions []goloxi.IAction
+}
+
+type IActionNxClone interface {
+	IActionNicira
+	GetActions() []goloxi.IAction
+}
+
+func (self *ActionNxClone) GetActions() []goloxi.IAction {
+	return self.Actions
+}
+
+func (self *ActionNxClone) SetActions(v []goloxi.IAction) {
+	self.Actions = v
+}
+
+func (self *ActionNxClone) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionNicira.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(bytes.Repeat([]byte{0}, 6))
+	for _, obj := range self.Actions {
+		if err := obj.Serialize(encoder); err != nil {
+			return err
+		}
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionNxClone(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxClone, error) {
+	_actionnxclone := &ActionNxClone{ActionNicira: parent}
+	if decoder.Length() < 6 {
+		return nil, fmt.Errorf("ActionNxClone packet too short: %d < 6", decoder.Length())
+	}
+	decoder.Skip(6)
+
+	for decoder.Length() >= 8 {
+		item, err := DecodeAction(decoder)
+		if err != nil {
+			return nil, err
+		}
+		if item != nil {
+			_actionnxclone.Actions = append(_actionnxclone.Actions, item)
+		}
+	}
+	return _actionnxclone, nil
+}
+
+func NewActionNxClone() *ActionNxClone {
+	obj := &ActionNxClone{
+		ActionNicira: NewActionNicira(42),
+	}
+	return obj
+}
+func (self *ActionNxClone) GetActionName() string {
+	return "nx_clone"
+}
+
+func (self *ActionNxClone) GetActionFields() map[string]interface{} {
+	return map[string]interface{}{
+		"Actions": self.Actions,
+	}
+}
+
+func (self *ActionNxClone) MarshalJSON() ([]byte, error) {
+	jsonValue, err := json.Marshal(self.GetActionFields())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxConjunction struct {
+	*ActionNicira
+	Clause   uint8
+	NClauses uint8
+	Id       uint32
+}
+
+type IActionNxConjunction interface {
+	IActionNicira
+	GetClause() uint8
+	GetNClauses() uint8
+	GetId() uint32
+}
+
+func (self *ActionNxConjunction) GetClause() uint8 {
+	return self.Clause
+}
+
+func (self *ActionNxConjunction) SetClause(v uint8) {
+	self.Clause = v
+}
+
+func (self *ActionNxConjunction) GetNClauses() uint8 {
+	return self.NClauses
+}
+
+func (self *ActionNxConjunction) SetNClauses(v uint8) {
+	self.NClauses = v
+}
+
+func (self *ActionNxConjunction) GetId() uint32 {
+	return self.Id
+}
+
+func (self *ActionNxConjunction) SetId(v uint32) {
+	self.Id = v
+}
+
+func (self *ActionNxConjunction) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionNicira.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint8(uint8(self.Clause))
+	encoder.PutUint8(uint8(self.NClauses))
+	encoder.PutUint32(uint32(self.Id))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionNxConjunction(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxConjunction, error) {
+	_actionnxconjunction := &ActionNxConjunction{ActionNicira: parent}
+	if decoder.Length() < 6 {
+		return nil, fmt.Errorf("ActionNxConjunction packet too short: %d < 6", decoder.Length())
+	}
+	_actionnxconjunction.Clause = uint8(decoder.ReadByte())
+	_actionnxconjunction.NClauses = uint8(decoder.ReadByte())
+	_actionnxconjunction.Id = uint32(decoder.ReadUint32())
+	return _actionnxconjunction, nil
+}
+
+func NewActionNxConjunction() *ActionNxConjunction {
+	obj := &ActionNxConjunction{
+		ActionNicira: NewActionNicira(34),
+	}
+	return obj
+}
+func (self *ActionNxConjunction) GetActionName() string {
+	return "nx_conjunction"
+}
+
+func (self *ActionNxConjunction) GetActionFields() map[string]interface{} {
+	return map[string]interface{}{
+		"Clause":   self.Clause,
+		"NClauses": self.NClauses,
+		"Id":       self.Id,
+	}
+}
+
+func (self *ActionNxConjunction) MarshalJSON() ([]byte, error) {
+	jsonValue, err := json.Marshal(self.GetActionFields())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxController struct {
+	*ActionNicira
+	MaxLen       uint16
+	ControllerId uint16
+	Reason       uint8
+}
+
+type IActionNxController interface {
+	IActionNicira
+	GetMaxLen() uint16
+	GetControllerId() uint16
+	GetReason() uint8
+}
+
+func (self *ActionNxController) GetMaxLen() uint16 {
+	return self.MaxLen
+}
+
+func (self *ActionNxController) SetMaxLen(v uint16) {
+	self.MaxLen = v
+}
+
+func (self *ActionNxController) GetControllerId() uint16 {
+	return self.ControllerId
+}
+
+func (self *ActionNxController) SetControllerId(v uint16) {
+	self.ControllerId = v
+}
+
+func (self *ActionNxController) GetReason() uint8 {
+	return self.Reason
+}
+
+func (self *ActionNxController) SetReason(v uint8) {
+	self.Reason = v
+}
+
+func (self *ActionNxController) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionNicira.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.MaxLen))
+	encoder.PutUint16(uint16(self.ControllerId))
+	encoder.PutUint8(uint8(self.Reason))
+	encoder.Write(bytes.Repeat([]byte{0}, 1))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionNxController(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxController, error) {
+	_actionnxcontroller := &ActionNxController{ActionNicira: parent}
+	if decoder.Length() < 6 {
+		return nil, fmt.Errorf("ActionNxController packet too short: %d < 6", decoder.Length())
+	}
+	_actionnxcontroller.MaxLen = uint16(decoder.ReadUint16())
+	_actionnxcontroller.ControllerId = uint16(decoder.ReadUint16())
+	_actionnxcontroller.Reason = uint8(decoder.ReadByte())
+	decoder.Skip(1)
+	return _actionnxcontroller, nil
+}
+
+func NewActionNxController() *ActionNxController {
+	obj := &ActionNxController{
+		ActionNicira: NewActionNicira(20),
+	}
+	return obj
+}
+func (self *ActionNxController) GetActionName() string {
+	return "nx_controller"
+}
+
+func (self *ActionNxController) GetActionFields() map[string]interface{} {
+	return map[string]interface{}{
+		"MaxLen":       self.MaxLen,
+		"ControllerId": self.ControllerId,
+		"Reason":       self.Reason,
+	}
+}
+
+func (self *ActionNxController) MarshalJSON() ([]byte, error) {
+	jsonValue, err := json.Marshal(self.GetActionFields())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxController2 struct {
+	*ActionNicira
+	Properties []IActionNxController2Property
+}
+
+type IActionNxController2 interface {
+	IActionNicira
+	GetProperties() []IActionNxController2Property
+}
+
+func (self *ActionNxController2) GetProperties() []IActionNxController2Property {
+	return self.Properties
+}
+
+func (self *ActionNxController2) SetProperties(v []IActionNxController2Property) {
+	self.Properties = v
+}
+
+func (self *ActionNxController2) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionNicira.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(bytes.Repeat([]byte{0}, 6))
+	for _, obj := range self.Properties {
+		if err := obj.Serialize(encoder); err != nil {
+			return err
+		}
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionNxController2(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxController2, error) {
+	_actionnxcontroller2 := &ActionNxController2{ActionNicira: parent}
+	if decoder.Length() < 6 {
+		return nil, fmt.Errorf("ActionNxController2 packet too short: %d < 6", decoder.Length())
+	}
+	decoder.Skip(6)
+
+	for decoder.Length() >= 2 {
+		item, err := DecodeActionNxController2Property(decoder)
+		if err != nil {
+			return nil, err
+		}
+		if item != nil {
+			_actionnxcontroller2.Properties = append(_actionnxcontroller2.Properties, item)
+		}
+	}
+	return _actionnxcontroller2, nil
+}
+
+func NewActionNxController2() *ActionNxController2 {
+	obj := &ActionNxController2{
+		ActionNicira: NewActionNicira(37),
+	}
+	return obj
+}
+func (self *ActionNxController2) GetActionName() string {
+	return "nx_controller2"
+}
+
+func (self *ActionNxController2) GetActionFields() map[string]interface{} {
+	return map[string]interface{}{
+		"Properties": self.Properties,
+	}
+}
+
+func (self *ActionNxController2) MarshalJSON() ([]byte, error) {
+	jsonValue, err := json.Marshal(self.GetActionFields())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxCt struct {
+	*ActionNicira
+	Flags       NxConntrackFlags
+	ZoneSrc     goloxi.IOxmId
+	Value       uint16
+	RecircTable uint8
+	Alg         uint16
+	Actions     []goloxi.IAction
+}
+
+type IActionNxCt interface {
+	IActionNicira
+	GetFlags() NxConntrackFlags
+	GetZoneSrc() goloxi.IOxmId
+	GetValue() uint16
+	GetRecircTable() uint8
+	GetAlg() uint16
+	GetActions() []goloxi.IAction
+}
+
+func (self *ActionNxCt) GetFlags() NxConntrackFlags {
+	return self.Flags
+}
+
+func (self *ActionNxCt) SetFlags(v NxConntrackFlags) {
+	self.Flags = v
+}
+
+func (self *ActionNxCt) GetZoneSrc() goloxi.IOxmId {
+	return self.ZoneSrc
+}
+
+func (self *ActionNxCt) SetZoneSrc(v goloxi.IOxmId) {
+	self.ZoneSrc = v
+}
+
+func (self *ActionNxCt) GetValue() uint16 {
+	return self.Value
+}
+
+func (self *ActionNxCt) SetValue(v uint16) {
+	self.Value = v
+}
+
+func (self *ActionNxCt) GetRecircTable() uint8 {
+	return self.RecircTable
+}
+
+func (self *ActionNxCt) SetRecircTable(v uint8) {
+	self.RecircTable = v
+}
+
+func (self *ActionNxCt) GetAlg() uint16 {
+	return self.Alg
+}
+
+func (self *ActionNxCt) SetAlg(v uint16) {
+	self.Alg = v
+}
+
+func (self *ActionNxCt) GetActions() []goloxi.IAction {
+	return self.Actions
+}
+
+func (self *ActionNxCt) SetActions(v []goloxi.IAction) {
+	self.Actions = v
+}
+
+func (self *ActionNxCt) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionNicira.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Flags))
+	self.ZoneSrc.Serialize(encoder)
+	encoder.PutUint16(uint16(self.Value))
+	encoder.PutUint8(uint8(self.RecircTable))
+	encoder.Write(bytes.Repeat([]byte{0}, 3))
+	encoder.PutUint16(uint16(self.Alg))
+	for _, obj := range self.Actions {
+		if err := obj.Serialize(encoder); err != nil {
+			return err
+		}
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionNxCt(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxCt, error) {
+	_actionnxct := &ActionNxCt{ActionNicira: parent}
+	if decoder.Length() < 14 {
+		return nil, fmt.Errorf("ActionNxCt packet too short: %d < 14", decoder.Length())
+	}
+	_actionnxct.Flags = NxConntrackFlags(decoder.ReadUint16())
+	if obj, err := DecodeOxmId(decoder); err != nil {
+		return nil, err
+	} else {
+		_actionnxct.ZoneSrc = obj
+	}
+
+	_actionnxct.Value = uint16(decoder.ReadUint16())
+	_actionnxct.RecircTable = uint8(decoder.ReadByte())
+	decoder.Skip(3)
+	_actionnxct.Alg = uint16(decoder.ReadUint16())
+
+	for decoder.Length() >= 8 {
+		item, err := DecodeAction(decoder)
+		if err != nil {
+			return nil, err
+		}
+		if item != nil {
+			_actionnxct.Actions = append(_actionnxct.Actions, item)
+		}
+	}
+	return _actionnxct, nil
+}
+
+func NewActionNxCt() *ActionNxCt {
+	obj := &ActionNxCt{
+		ActionNicira: NewActionNicira(35),
+	}
+	return obj
+}
+func (self *ActionNxCt) GetActionName() string {
+	return "nx_ct"
+}
+
+func (self *ActionNxCt) GetActionFields() map[string]interface{} {
+	return map[string]interface{}{
+		"Flags":       self.Flags,
+		"ZoneSrc":     self.ZoneSrc,
+		"Value":       self.Value,
+		"RecircTable": self.RecircTable,
+		"Alg":         self.Alg,
+		"Actions":     self.Actions,
+	}
+}
+
+func (self *ActionNxCt) MarshalJSON() ([]byte, error) {
+	jsonValue, err := json.Marshal(self.GetActionFields())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxCtClear struct {
+	*ActionNicira
+}
+
+type IActionNxCtClear interface {
+	IActionNicira
+}
+
+func (self *ActionNxCtClear) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionNicira.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionNxCtClear(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxCtClear, error) {
+	_actionnxctclear := &ActionNxCtClear{ActionNicira: parent}
+	return _actionnxctclear, nil
+}
+
+func NewActionNxCtClear() *ActionNxCtClear {
+	obj := &ActionNxCtClear{
+		ActionNicira: NewActionNicira(43),
+	}
+	return obj
+}
+func (self *ActionNxCtClear) GetActionName() string {
+	return "nx_ct_clear"
+}
+
+func (self *ActionNxCtClear) GetActionFields() map[string]interface{} {
+	return map[string]interface{}{}
+}
+
+func (self *ActionNxCtClear) MarshalJSON() ([]byte, error) {
+	jsonValue, err := json.Marshal(self.GetActionFields())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxDebugRecirc struct {
+	*ActionNicira
+}
+
+type IActionNxDebugRecirc interface {
+	IActionNicira
+}
+
+func (self *ActionNxDebugRecirc) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionNicira.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionNxDebugRecirc(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxDebugRecirc, error) {
+	_actionnxdebugrecirc := &ActionNxDebugRecirc{ActionNicira: parent}
+	return _actionnxdebugrecirc, nil
+}
+
+func NewActionNxDebugRecirc() *ActionNxDebugRecirc {
+	obj := &ActionNxDebugRecirc{
+		ActionNicira: NewActionNicira(255),
+	}
+	return obj
+}
+func (self *ActionNxDebugRecirc) GetActionName() string {
+	return "nx_debug_recirc"
+}
+
+func (self *ActionNxDebugRecirc) GetActionFields() map[string]interface{} {
+	return map[string]interface{}{}
+}
+
+func (self *ActionNxDebugRecirc) MarshalJSON() ([]byte, error) {
+	jsonValue, err := json.Marshal(self.GetActionFields())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxDebugSlow struct {
+	*ActionNicira
+}
+
+type IActionNxDebugSlow interface {
+	IActionNicira
+}
+
+func (self *ActionNxDebugSlow) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionNicira.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionNxDebugSlow(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxDebugSlow, error) {
+	_actionnxdebugslow := &ActionNxDebugSlow{ActionNicira: parent}
+	return _actionnxdebugslow, nil
+}
+
+func NewActionNxDebugSlow() *ActionNxDebugSlow {
+	obj := &ActionNxDebugSlow{
+		ActionNicira: NewActionNicira(254),
+	}
+	return obj
+}
+func (self *ActionNxDebugSlow) GetActionName() string {
+	return "nx_debug_slow"
+}
+
+func (self *ActionNxDebugSlow) GetActionFields() map[string]interface{} {
+	return map[string]interface{}{}
+}
+
+func (self *ActionNxDebugSlow) MarshalJSON() ([]byte, error) {
+	jsonValue, err := json.Marshal(self.GetActionFields())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxDecMplsTtl struct {
+	*ActionNicira
+}
+
+type IActionNxDecMplsTtl interface {
+	IActionNicira
+}
+
+func (self *ActionNxDecMplsTtl) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionNicira.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionNxDecMplsTtl(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxDecMplsTtl, error) {
+	_actionnxdecmplsttl := &ActionNxDecMplsTtl{ActionNicira: parent}
+	return _actionnxdecmplsttl, nil
+}
+
+func NewActionNxDecMplsTtl() *ActionNxDecMplsTtl {
+	obj := &ActionNxDecMplsTtl{
+		ActionNicira: NewActionNicira(26),
+	}
+	return obj
+}
+func (self *ActionNxDecMplsTtl) GetActionName() string {
+	return "nx_dec_mpls_ttl"
+}
+
+func (self *ActionNxDecMplsTtl) GetActionFields() map[string]interface{} {
+	return map[string]interface{}{}
+}
+
+func (self *ActionNxDecMplsTtl) MarshalJSON() ([]byte, error) {
+	jsonValue, err := json.Marshal(self.GetActionFields())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxDecNshTtl struct {
+	*ActionNicira
+}
+
+type IActionNxDecNshTtl interface {
+	IActionNicira
+}
+
+func (self *ActionNxDecNshTtl) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionNicira.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionNxDecNshTtl(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxDecNshTtl, error) {
+	_actionnxdecnshttl := &ActionNxDecNshTtl{ActionNicira: parent}
+	return _actionnxdecnshttl, nil
+}
+
+func NewActionNxDecNshTtl() *ActionNxDecNshTtl {
+	obj := &ActionNxDecNshTtl{
+		ActionNicira: NewActionNicira(48),
+	}
+	return obj
+}
+func (self *ActionNxDecNshTtl) GetActionName() string {
+	return "nx_dec_nsh_ttl"
+}
+
+func (self *ActionNxDecNshTtl) GetActionFields() map[string]interface{} {
+	return map[string]interface{}{}
+}
+
+func (self *ActionNxDecNshTtl) MarshalJSON() ([]byte, error) {
+	jsonValue, err := json.Marshal(self.GetActionFields())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxDecTtlCntIds struct {
+	*ActionNicira
+	NControllers uint16
+}
+
+type IActionNxDecTtlCntIds interface {
+	IActionNicira
+	GetNControllers() uint16
+}
+
+func (self *ActionNxDecTtlCntIds) GetNControllers() uint16 {
+	return self.NControllers
+}
+
+func (self *ActionNxDecTtlCntIds) SetNControllers(v uint16) {
+	self.NControllers = v
+}
+
+func (self *ActionNxDecTtlCntIds) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionNicira.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.NControllers))
+	encoder.Write(bytes.Repeat([]byte{0}, 4))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionNxDecTtlCntIds(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxDecTtlCntIds, error) {
+	_actionnxdecttlcntids := &ActionNxDecTtlCntIds{ActionNicira: parent}
+	if decoder.Length() < 6 {
+		return nil, fmt.Errorf("ActionNxDecTtlCntIds packet too short: %d < 6", decoder.Length())
+	}
+	_actionnxdecttlcntids.NControllers = uint16(decoder.ReadUint16())
+	decoder.Skip(4)
+	return _actionnxdecttlcntids, nil
+}
+
+func NewActionNxDecTtlCntIds() *ActionNxDecTtlCntIds {
+	obj := &ActionNxDecTtlCntIds{
+		ActionNicira: NewActionNicira(21),
+	}
+	return obj
+}
+func (self *ActionNxDecTtlCntIds) GetActionName() string {
+	return "nx_dec_ttl_cnt_ids"
+}
+
+func (self *ActionNxDecTtlCntIds) GetActionFields() map[string]interface{} {
+	return map[string]interface{}{
+		"NControllers": self.NControllers,
+	}
+}
+
+func (self *ActionNxDecTtlCntIds) MarshalJSON() ([]byte, error) {
+	jsonValue, err := json.Marshal(self.GetActionFields())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxDecap struct {
+	*ActionNicira
+	NewPktType uint32
+}
+
+type IActionNxDecap interface {
+	IActionNicira
+	GetNewPktType() uint32
+}
+
+func (self *ActionNxDecap) GetNewPktType() uint32 {
+	return self.NewPktType
+}
+
+func (self *ActionNxDecap) SetNewPktType(v uint32) {
+	self.NewPktType = v
+}
+
+func (self *ActionNxDecap) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionNicira.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(bytes.Repeat([]byte{0}, 2))
+	encoder.PutUint32(uint32(self.NewPktType))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionNxDecap(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxDecap, error) {
+	_actionnxdecap := &ActionNxDecap{ActionNicira: parent}
+	if decoder.Length() < 6 {
+		return nil, fmt.Errorf("ActionNxDecap packet too short: %d < 6", decoder.Length())
+	}
+	decoder.Skip(2)
+	_actionnxdecap.NewPktType = uint32(decoder.ReadUint32())
+	return _actionnxdecap, nil
+}
+
+func NewActionNxDecap() *ActionNxDecap {
+	obj := &ActionNxDecap{
+		ActionNicira: NewActionNicira(47),
+	}
+	return obj
+}
+func (self *ActionNxDecap) GetActionName() string {
+	return "nx_decap"
+}
+
+func (self *ActionNxDecap) GetActionFields() map[string]interface{} {
+	return map[string]interface{}{
+		"NewPktType": self.NewPktType,
+	}
+}
+
+func (self *ActionNxDecap) MarshalJSON() ([]byte, error) {
+	jsonValue, err := json.Marshal(self.GetActionFields())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxEncap struct {
+	*ActionNicira
+	HdrSize    uint16
+	PacketType PacketType
+	Props      []IEdPropHeader
+}
+
+type IActionNxEncap interface {
+	IActionNicira
+	GetHdrSize() uint16
+	GetPacketType() PacketType
+	GetProps() []IEdPropHeader
+}
+
+func (self *ActionNxEncap) GetHdrSize() uint16 {
+	return self.HdrSize
+}
+
+func (self *ActionNxEncap) SetHdrSize(v uint16) {
+	self.HdrSize = v
+}
+
+func (self *ActionNxEncap) GetPacketType() PacketType {
+	return self.PacketType
+}
+
+func (self *ActionNxEncap) SetPacketType(v PacketType) {
+	self.PacketType = v
+}
+
+func (self *ActionNxEncap) GetProps() []IEdPropHeader {
+	return self.Props
+}
+
+func (self *ActionNxEncap) SetProps(v []IEdPropHeader) {
+	self.Props = v
+}
+
+func (self *ActionNxEncap) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionNicira.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.HdrSize))
+	encoder.PutUint32(uint32(self.PacketType))
+	for _, obj := range self.Props {
+		if err := obj.Serialize(encoder); err != nil {
+			return err
+		}
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionNxEncap(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxEncap, error) {
+	_actionnxencap := &ActionNxEncap{ActionNicira: parent}
+	if decoder.Length() < 6 {
+		return nil, fmt.Errorf("ActionNxEncap packet too short: %d < 6", decoder.Length())
+	}
+	_actionnxencap.HdrSize = uint16(decoder.ReadUint16())
+	_actionnxencap.PacketType = PacketType(decoder.ReadUint32())
+
+	for decoder.Length() >= 4 {
+		item, err := DecodeEdPropHeader(decoder)
+		if err != nil {
+			return nil, err
+		}
+		if item != nil {
+			_actionnxencap.Props = append(_actionnxencap.Props, item)
+		}
+	}
+	return _actionnxencap, nil
+}
+
+func NewActionNxEncap() *ActionNxEncap {
+	obj := &ActionNxEncap{
+		ActionNicira: NewActionNicira(46),
+	}
+	return obj
+}
+func (self *ActionNxEncap) GetActionName() string {
+	return "nx_encap"
+}
+
+func (self *ActionNxEncap) GetActionFields() map[string]interface{} {
+	return map[string]interface{}{
+		"HdrSize":    self.HdrSize,
+		"PacketType": self.PacketType,
+		"Props":      self.Props,
+	}
+}
+
+func (self *ActionNxEncap) MarshalJSON() ([]byte, error) {
+	jsonValue, err := json.Marshal(self.GetActionFields())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxExit struct {
+	*ActionNicira
+}
+
+type IActionNxExit interface {
+	IActionNicira
+}
+
+func (self *ActionNxExit) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionNicira.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionNxExit(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxExit, error) {
+	_actionnxexit := &ActionNxExit{ActionNicira: parent}
+	return _actionnxexit, nil
+}
+
+func NewActionNxExit() *ActionNxExit {
+	obj := &ActionNxExit{
+		ActionNicira: NewActionNicira(17),
+	}
+	return obj
+}
+func (self *ActionNxExit) GetActionName() string {
+	return "nx_exit"
+}
+
+func (self *ActionNxExit) GetActionFields() map[string]interface{} {
+	return map[string]interface{}{}
+}
+
+func (self *ActionNxExit) MarshalJSON() ([]byte, error) {
+	jsonValue, err := json.Marshal(self.GetActionFields())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxFinTimeout struct {
+	*ActionNicira
+	FinIdleTimeout uint16
+	FinHardTimeout uint16
+}
+
+type IActionNxFinTimeout interface {
+	IActionNicira
+	GetFinIdleTimeout() uint16
+	GetFinHardTimeout() uint16
+}
+
+func (self *ActionNxFinTimeout) GetFinIdleTimeout() uint16 {
+	return self.FinIdleTimeout
+}
+
+func (self *ActionNxFinTimeout) SetFinIdleTimeout(v uint16) {
+	self.FinIdleTimeout = v
+}
+
+func (self *ActionNxFinTimeout) GetFinHardTimeout() uint16 {
+	return self.FinHardTimeout
+}
+
+func (self *ActionNxFinTimeout) SetFinHardTimeout(v uint16) {
+	self.FinHardTimeout = v
+}
+
+func (self *ActionNxFinTimeout) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionNicira.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.FinIdleTimeout))
+	encoder.PutUint16(uint16(self.FinHardTimeout))
+	encoder.Write(bytes.Repeat([]byte{0}, 2))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionNxFinTimeout(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxFinTimeout, error) {
+	_actionnxfintimeout := &ActionNxFinTimeout{ActionNicira: parent}
+	if decoder.Length() < 6 {
+		return nil, fmt.Errorf("ActionNxFinTimeout packet too short: %d < 6", decoder.Length())
+	}
+	_actionnxfintimeout.FinIdleTimeout = uint16(decoder.ReadUint16())
+	_actionnxfintimeout.FinHardTimeout = uint16(decoder.ReadUint16())
+	decoder.Skip(2)
+	return _actionnxfintimeout, nil
+}
+
+func NewActionNxFinTimeout() *ActionNxFinTimeout {
+	obj := &ActionNxFinTimeout{
+		ActionNicira: NewActionNicira(19),
+	}
+	return obj
+}
+func (self *ActionNxFinTimeout) GetActionName() string {
+	return "nx_fin_timeout"
+}
+
+func (self *ActionNxFinTimeout) GetActionFields() map[string]interface{} {
+	return map[string]interface{}{
+		"FinIdleTimeout": self.FinIdleTimeout,
+		"FinHardTimeout": self.FinHardTimeout,
+	}
+}
+
+func (self *ActionNxFinTimeout) MarshalJSON() ([]byte, error) {
+	jsonValue, err := json.Marshal(self.GetActionFields())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxGroup struct {
+	*ActionNicira
+	Value uint32
+}
+
+type IActionNxGroup interface {
+	IActionNicira
+	GetValue() uint32
+}
+
+func (self *ActionNxGroup) GetValue() uint32 {
+	return self.Value
+}
+
+func (self *ActionNxGroup) SetValue(v uint32) {
+	self.Value = v
+}
+
+func (self *ActionNxGroup) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionNicira.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Value))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionNxGroup(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxGroup, error) {
+	_actionnxgroup := &ActionNxGroup{ActionNicira: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("ActionNxGroup packet too short: %d < 4", decoder.Length())
+	}
+	_actionnxgroup.Value = uint32(decoder.ReadUint32())
+	return _actionnxgroup, nil
+}
+
+func NewActionNxGroup() *ActionNxGroup {
+	obj := &ActionNxGroup{
+		ActionNicira: NewActionNicira(40),
+	}
+	return obj
+}
+func (self *ActionNxGroup) GetActionName() string {
+	return "nx_group"
+}
+
+func (self *ActionNxGroup) GetActionFields() map[string]interface{} {
+	return map[string]interface{}{
+		"Value": self.Value,
+	}
+}
+
+func (self *ActionNxGroup) MarshalJSON() ([]byte, error) {
+	jsonValue, err := json.Marshal(self.GetActionFields())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxLearn struct {
+	*ActionNicira
+	IdleTimeout    uint16
+	HardTimeout    uint16
+	Priority       uint16
+	Cookie         uint64
+	Flags          uint16
+	TableId        uint8
+	FinIdleTimeout uint16
+	FinHardTimeout uint16
+	FlowMods       []IFlowModSpec
+}
+
+type IActionNxLearn interface {
+	IActionNicira
+	GetIdleTimeout() uint16
+	GetHardTimeout() uint16
+	GetPriority() uint16
+	GetCookie() uint64
+	GetFlags() uint16
+	GetTableId() uint8
+	GetFinIdleTimeout() uint16
+	GetFinHardTimeout() uint16
+	GetFlowMods() []IFlowModSpec
+}
+
+func (self *ActionNxLearn) GetIdleTimeout() uint16 {
+	return self.IdleTimeout
+}
+
+func (self *ActionNxLearn) SetIdleTimeout(v uint16) {
+	self.IdleTimeout = v
+}
+
+func (self *ActionNxLearn) GetHardTimeout() uint16 {
+	return self.HardTimeout
+}
+
+func (self *ActionNxLearn) SetHardTimeout(v uint16) {
+	self.HardTimeout = v
+}
+
+func (self *ActionNxLearn) GetPriority() uint16 {
+	return self.Priority
+}
+
+func (self *ActionNxLearn) SetPriority(v uint16) {
+	self.Priority = v
+}
+
+func (self *ActionNxLearn) GetCookie() uint64 {
+	return self.Cookie
+}
+
+func (self *ActionNxLearn) SetCookie(v uint64) {
+	self.Cookie = v
+}
+
+func (self *ActionNxLearn) GetFlags() uint16 {
+	return self.Flags
+}
+
+func (self *ActionNxLearn) SetFlags(v uint16) {
+	self.Flags = v
+}
+
+func (self *ActionNxLearn) GetTableId() uint8 {
+	return self.TableId
+}
+
+func (self *ActionNxLearn) SetTableId(v uint8) {
+	self.TableId = v
+}
+
+func (self *ActionNxLearn) GetFinIdleTimeout() uint16 {
+	return self.FinIdleTimeout
+}
+
+func (self *ActionNxLearn) SetFinIdleTimeout(v uint16) {
+	self.FinIdleTimeout = v
+}
+
+func (self *ActionNxLearn) GetFinHardTimeout() uint16 {
+	return self.FinHardTimeout
+}
+
+func (self *ActionNxLearn) SetFinHardTimeout(v uint16) {
+	self.FinHardTimeout = v
+}
+
+func (self *ActionNxLearn) GetFlowMods() []IFlowModSpec {
+	return self.FlowMods
+}
+
+func (self *ActionNxLearn) SetFlowMods(v []IFlowModSpec) {
+	self.FlowMods = v
+}
+
+func (self *ActionNxLearn) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionNicira.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.IdleTimeout))
+	encoder.PutUint16(uint16(self.HardTimeout))
+	encoder.PutUint16(uint16(self.Priority))
+	encoder.PutUint64(uint64(self.Cookie))
+	encoder.PutUint16(uint16(self.Flags))
+	encoder.PutUint8(uint8(self.TableId))
+	encoder.Write(bytes.Repeat([]byte{0}, 1))
+	encoder.PutUint16(uint16(self.FinIdleTimeout))
+	encoder.PutUint16(uint16(self.FinHardTimeout))
+	for _, obj := range self.FlowMods {
+		if err := obj.Serialize(encoder); err != nil {
+			return err
+		}
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionNxLearn(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxLearn, error) {
+	_actionnxlearn := &ActionNxLearn{ActionNicira: parent}
+	if decoder.Length() < 22 {
+		return nil, fmt.Errorf("ActionNxLearn packet too short: %d < 22", decoder.Length())
+	}
+	_actionnxlearn.IdleTimeout = uint16(decoder.ReadUint16())
+	_actionnxlearn.HardTimeout = uint16(decoder.ReadUint16())
+	_actionnxlearn.Priority = uint16(decoder.ReadUint16())
+	_actionnxlearn.Cookie = uint64(decoder.ReadUint64())
+	_actionnxlearn.Flags = uint16(decoder.ReadUint16())
+	_actionnxlearn.TableId = uint8(decoder.ReadByte())
+	decoder.Skip(1)
+	_actionnxlearn.FinIdleTimeout = uint16(decoder.ReadUint16())
+	_actionnxlearn.FinHardTimeout = uint16(decoder.ReadUint16())
+
+	for decoder.Length() >= 2 {
+		item, err := DecodeFlowModSpec(decoder)
+		if err != nil {
+			return nil, err
+		}
+		if item != nil {
+			_actionnxlearn.FlowMods = append(_actionnxlearn.FlowMods, item)
+		}
+	}
+	return _actionnxlearn, nil
+}
+
+func NewActionNxLearn() *ActionNxLearn {
+	obj := &ActionNxLearn{
+		ActionNicira: NewActionNicira(16),
+	}
+	return obj
+}
+func (self *ActionNxLearn) GetActionName() string {
+	return "nx_learn"
+}
+
+func (self *ActionNxLearn) GetActionFields() map[string]interface{} {
+	return map[string]interface{}{
+		"IdleTimeout":    self.IdleTimeout,
+		"HardTimeout":    self.HardTimeout,
+		"Priority":       self.Priority,
+		"Cookie":         self.Cookie,
+		"Flags":          self.Flags,
+		"TableId":        self.TableId,
+		"FinIdleTimeout": self.FinIdleTimeout,
+		"FinHardTimeout": self.FinHardTimeout,
+		"FlowMods":       self.FlowMods,
+	}
+}
+
+func (self *ActionNxLearn) MarshalJSON() ([]byte, error) {
+	jsonValue, err := json.Marshal(self.GetActionFields())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxLearn2 struct {
+	*ActionNicira
+}
+
+type IActionNxLearn2 interface {
+	IActionNicira
+}
+
+func (self *ActionNxLearn2) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionNicira.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionNxLearn2(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxLearn2, error) {
+	_actionnxlearn2 := &ActionNxLearn2{ActionNicira: parent}
+	return _actionnxlearn2, nil
+}
+
+func NewActionNxLearn2() *ActionNxLearn2 {
+	obj := &ActionNxLearn2{
+		ActionNicira: NewActionNicira(45),
+	}
+	return obj
+}
+func (self *ActionNxLearn2) GetActionName() string {
+	return "nx_learn2"
+}
+
+func (self *ActionNxLearn2) GetActionFields() map[string]interface{} {
+	return map[string]interface{}{}
+}
+
+func (self *ActionNxLearn2) MarshalJSON() ([]byte, error) {
+	jsonValue, err := json.Marshal(self.GetActionFields())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxMultipath struct {
+	*ActionNicira
+	Fields    NxHashFields
+	Basis     uint16
+	Algorithm NxMpAlgorithm
+	MaxLink   uint16
+	Arg       uint32
+	OfsNbits  uint16
+	Dst       goloxi.IOxmId
+}
+
+type IActionNxMultipath interface {
+	IActionNicira
+	GetFields() NxHashFields
+	GetBasis() uint16
+	GetAlgorithm() NxMpAlgorithm
+	GetMaxLink() uint16
+	GetArg() uint32
+	GetOfsNbits() uint16
+	GetDst() goloxi.IOxmId
+}
+
+func (self *ActionNxMultipath) GetFields() NxHashFields {
+	return self.Fields
+}
+
+func (self *ActionNxMultipath) SetFields(v NxHashFields) {
+	self.Fields = v
+}
+
+func (self *ActionNxMultipath) GetBasis() uint16 {
+	return self.Basis
+}
+
+func (self *ActionNxMultipath) SetBasis(v uint16) {
+	self.Basis = v
+}
+
+func (self *ActionNxMultipath) GetAlgorithm() NxMpAlgorithm {
+	return self.Algorithm
+}
+
+func (self *ActionNxMultipath) SetAlgorithm(v NxMpAlgorithm) {
+	self.Algorithm = v
+}
+
+func (self *ActionNxMultipath) GetMaxLink() uint16 {
+	return self.MaxLink
+}
+
+func (self *ActionNxMultipath) SetMaxLink(v uint16) {
+	self.MaxLink = v
+}
+
+func (self *ActionNxMultipath) GetArg() uint32 {
+	return self.Arg
+}
+
+func (self *ActionNxMultipath) SetArg(v uint32) {
+	self.Arg = v
+}
+
+func (self *ActionNxMultipath) GetOfsNbits() uint16 {
+	return self.OfsNbits
+}
+
+func (self *ActionNxMultipath) SetOfsNbits(v uint16) {
+	self.OfsNbits = v
+}
+
+func (self *ActionNxMultipath) GetDst() goloxi.IOxmId {
+	return self.Dst
+}
+
+func (self *ActionNxMultipath) SetDst(v goloxi.IOxmId) {
+	self.Dst = v
+}
+
+func (self *ActionNxMultipath) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionNicira.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Fields))
+	encoder.PutUint16(uint16(self.Basis))
+	encoder.Write(bytes.Repeat([]byte{0}, 2))
+	encoder.PutUint16(uint16(self.Algorithm))
+	encoder.PutUint16(uint16(self.MaxLink))
+	encoder.PutUint32(uint32(self.Arg))
+	encoder.Write(bytes.Repeat([]byte{0}, 2))
+	encoder.PutUint16(uint16(self.OfsNbits))
+	self.Dst.Serialize(encoder)
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionNxMultipath(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxMultipath, error) {
+	_actionnxmultipath := &ActionNxMultipath{ActionNicira: parent}
+	if decoder.Length() < 22 {
+		return nil, fmt.Errorf("ActionNxMultipath packet too short: %d < 22", decoder.Length())
+	}
+	_actionnxmultipath.Fields = NxHashFields(decoder.ReadUint16())
+	_actionnxmultipath.Basis = uint16(decoder.ReadUint16())
+	decoder.Skip(2)
+	_actionnxmultipath.Algorithm = NxMpAlgorithm(decoder.ReadUint16())
+	_actionnxmultipath.MaxLink = uint16(decoder.ReadUint16())
+	_actionnxmultipath.Arg = uint32(decoder.ReadUint32())
+	decoder.Skip(2)
+	_actionnxmultipath.OfsNbits = uint16(decoder.ReadUint16())
+	if obj, err := DecodeOxmId(decoder); err != nil {
+		return nil, err
+	} else {
+		_actionnxmultipath.Dst = obj
+	}
+
+	return _actionnxmultipath, nil
+}
+
+func NewActionNxMultipath() *ActionNxMultipath {
+	obj := &ActionNxMultipath{
+		ActionNicira: NewActionNicira(10),
+	}
+	return obj
+}
+func (self *ActionNxMultipath) GetActionName() string {
+	return "nx_multipath"
+}
+
+func (self *ActionNxMultipath) GetActionFields() map[string]interface{} {
+	return map[string]interface{}{
+		"Fields":    self.Fields,
+		"Basis":     self.Basis,
+		"Algorithm": self.Algorithm,
+		"MaxLink":   self.MaxLink,
+		"Arg":       self.Arg,
+		"OfsNbits":  self.OfsNbits,
+		"Dst":       self.Dst,
+	}
+}
+
+func (self *ActionNxMultipath) MarshalJSON() ([]byte, error) {
+	jsonValue, err := json.Marshal(self.GetActionFields())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxNat struct {
+	*ActionNicira
+	Flags        uint16
+	RangePresent NxNatRange
+	Ipv4Min      net.IP
+	Ipv4Max      net.IP
+	Ipv6Min      net.IP
+	Ipv6Max      net.IP
+	ProtoMin     uint32
+	ProtoMax     uint32
+}
+
+type IActionNxNat interface {
+	IActionNicira
+	GetFlags() uint16
+	GetRangePresent() NxNatRange
+	GetIpv4Min() net.IP
+	GetIpv4Max() net.IP
+	GetIpv6Min() net.IP
+	GetIpv6Max() net.IP
+	GetProtoMin() uint32
+	GetProtoMax() uint32
+}
+
+func (self *ActionNxNat) GetFlags() uint16 {
+	return self.Flags
+}
+
+func (self *ActionNxNat) SetFlags(v uint16) {
+	self.Flags = v
+}
+
+func (self *ActionNxNat) GetRangePresent() NxNatRange {
+	return self.RangePresent
+}
+
+func (self *ActionNxNat) SetRangePresent(v NxNatRange) {
+	self.RangePresent = v
+}
+
+func (self *ActionNxNat) GetIpv4Min() net.IP {
+	return self.Ipv4Min
+}
+
+func (self *ActionNxNat) SetIpv4Min(v net.IP) {
+	self.Ipv4Min = v
+}
+
+func (self *ActionNxNat) GetIpv4Max() net.IP {
+	return self.Ipv4Max
+}
+
+func (self *ActionNxNat) SetIpv4Max(v net.IP) {
+	self.Ipv4Max = v
+}
+
+func (self *ActionNxNat) GetIpv6Min() net.IP {
+	return self.Ipv6Min
+}
+
+func (self *ActionNxNat) SetIpv6Min(v net.IP) {
+	self.Ipv6Min = v
+}
+
+func (self *ActionNxNat) GetIpv6Max() net.IP {
+	return self.Ipv6Max
+}
+
+func (self *ActionNxNat) SetIpv6Max(v net.IP) {
+	self.Ipv6Max = v
+}
+
+func (self *ActionNxNat) GetProtoMin() uint32 {
+	return self.ProtoMin
+}
+
+func (self *ActionNxNat) SetProtoMin(v uint32) {
+	self.ProtoMin = v
+}
+
+func (self *ActionNxNat) GetProtoMax() uint32 {
+	return self.ProtoMax
+}
+
+func (self *ActionNxNat) SetProtoMax(v uint32) {
+	self.ProtoMax = v
+}
+
+func (self *ActionNxNat) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionNicira.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(bytes.Repeat([]byte{0}, 2))
+	encoder.PutUint16(uint16(self.Flags))
+	encoder.PutUint16(uint16(self.RangePresent))
+	encoder.Write(self.Ipv4Min.To4())
+	encoder.Write(self.Ipv4Max.To4())
+	encoder.Write(self.Ipv6Min.To16())
+	encoder.Write(self.Ipv6Max.To16())
+	encoder.PutUint32(uint32(self.ProtoMin))
+	encoder.PutUint32(uint32(self.ProtoMax))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionNxNat(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxNat, error) {
+	_actionnxnat := &ActionNxNat{ActionNicira: parent}
+	if decoder.Length() < 6 {
+		return nil, fmt.Errorf("ActionNxNat packet too short: %d < 6", decoder.Length())
+	}
+	decoder.Skip(2)
+	_actionnxnat.Flags = uint16(decoder.ReadUint16())
+	_actionnxnat.RangePresent = NxNatRange(decoder.ReadUint16())
+	if _actionnxnat.RangePresent&1 == 1 {
+		_actionnxnat.Ipv4Min = net.IP(decoder.Read(4))
+	}
+	if _actionnxnat.RangePresent&2 == 2 {
+		_actionnxnat.Ipv4Max = net.IP(decoder.Read(4))
+	}
+	if _actionnxnat.RangePresent&4 == 4 {
+		_actionnxnat.Ipv6Min = net.IP(decoder.Read(16))
+	}
+	if _actionnxnat.RangePresent&8 == 8 {
+		_actionnxnat.Ipv6Max = net.IP(decoder.Read(16))
+	}
+	if _actionnxnat.RangePresent&16 == 16 {
+		_actionnxnat.ProtoMin = uint32(decoder.ReadUint32())
+	}
+	if _actionnxnat.RangePresent&32 == 32 {
+		_actionnxnat.ProtoMax = uint32(decoder.ReadUint32())
+	}
+	return _actionnxnat, nil
+}
+
+func NewActionNxNat() *ActionNxNat {
+	obj := &ActionNxNat{
+		ActionNicira: NewActionNicira(36),
+	}
+	return obj
+}
+func (self *ActionNxNat) GetActionName() string {
+	return "nx_nat"
+}
+
+func (self *ActionNxNat) GetActionFields() map[string]interface{} {
+	return map[string]interface{}{
+		"Flags":        self.Flags,
+		"RangePresent": self.RangePresent,
+		"Ipv4Min":      self.Ipv4Min,
+		"Ipv4Max":      self.Ipv4Max,
+		"Ipv6Min":      self.Ipv6Min,
+		"Ipv6Max":      self.Ipv6Max,
+		"ProtoMin":     self.ProtoMin,
+		"ProtoMax":     self.ProtoMax,
+	}
+}
+
+func (self *ActionNxNat) MarshalJSON() ([]byte, error) {
+	jsonValue, err := json.Marshal(self.GetActionFields())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxNote struct {
+	*ActionNicira
+	Note []byte
+}
+
+type IActionNxNote interface {
+	IActionNicira
+	GetNote() []byte
+}
+
+func (self *ActionNxNote) GetNote() []byte {
+	return self.Note
+}
+
+func (self *ActionNxNote) SetNote(v []byte) {
+	self.Note = v
+}
+
+func (self *ActionNxNote) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionNicira.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Note)
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionNxNote(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxNote, error) {
+	_actionnxnote := &ActionNxNote{ActionNicira: parent}
+	_actionnxnote.Note = decoder.Read(int(decoder.Length()))
+	return _actionnxnote, nil
+}
+
+func NewActionNxNote() *ActionNxNote {
+	obj := &ActionNxNote{
+		ActionNicira: NewActionNicira(8),
+	}
+	return obj
+}
+func (self *ActionNxNote) GetActionName() string {
+	return "nx_note"
+}
+
+func (self *ActionNxNote) GetActionFields() map[string]interface{} {
+	return map[string]interface{}{
+		"Note": self.Note,
+	}
+}
+
+func (self *ActionNxNote) MarshalJSON() ([]byte, error) {
+	jsonValue, err := json.Marshal(self.GetActionFields())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxOutputReg struct {
+	*ActionNicira
+	OfsNbits uint16
+	Src      uint32
+	MaxLen   uint16
+}
+
+type IActionNxOutputReg interface {
+	IActionNicira
+	GetOfsNbits() uint16
+	GetSrc() uint32
+	GetMaxLen() uint16
+}
+
+func (self *ActionNxOutputReg) GetOfsNbits() uint16 {
+	return self.OfsNbits
+}
+
+func (self *ActionNxOutputReg) SetOfsNbits(v uint16) {
+	self.OfsNbits = v
+}
+
+func (self *ActionNxOutputReg) GetSrc() uint32 {
+	return self.Src
+}
+
+func (self *ActionNxOutputReg) SetSrc(v uint32) {
+	self.Src = v
+}
+
+func (self *ActionNxOutputReg) GetMaxLen() uint16 {
+	return self.MaxLen
+}
+
+func (self *ActionNxOutputReg) SetMaxLen(v uint16) {
+	self.MaxLen = v
+}
+
+func (self *ActionNxOutputReg) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionNicira.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.OfsNbits))
+	encoder.PutUint32(uint32(self.Src))
+	encoder.PutUint16(uint16(self.MaxLen))
+	encoder.Write(bytes.Repeat([]byte{0}, 6))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionNxOutputReg(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxOutputReg, error) {
+	_actionnxoutputreg := &ActionNxOutputReg{ActionNicira: parent}
+	if decoder.Length() < 14 {
+		return nil, fmt.Errorf("ActionNxOutputReg packet too short: %d < 14", decoder.Length())
+	}
+	_actionnxoutputreg.OfsNbits = uint16(decoder.ReadUint16())
+	_actionnxoutputreg.Src = uint32(decoder.ReadUint32())
+	_actionnxoutputreg.MaxLen = uint16(decoder.ReadUint16())
+	decoder.Skip(6)
+	return _actionnxoutputreg, nil
+}
+
+func NewActionNxOutputReg() *ActionNxOutputReg {
+	obj := &ActionNxOutputReg{
+		ActionNicira: NewActionNicira(15),
+	}
+	return obj
+}
+func (self *ActionNxOutputReg) GetActionName() string {
+	return "nx_output_reg"
+}
+
+func (self *ActionNxOutputReg) GetActionFields() map[string]interface{} {
+	return map[string]interface{}{
+		"OfsNbits": self.OfsNbits,
+		"Src":      self.Src,
+		"MaxLen":   self.MaxLen,
+	}
+}
+
+func (self *ActionNxOutputReg) MarshalJSON() ([]byte, error) {
+	jsonValue, err := json.Marshal(self.GetActionFields())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxOutputReg2 struct {
+	*ActionNicira
+	OfsNbits uint16
+	MaxLen   uint16
+}
+
+type IActionNxOutputReg2 interface {
+	IActionNicira
+	GetOfsNbits() uint16
+	GetMaxLen() uint16
+}
+
+func (self *ActionNxOutputReg2) GetOfsNbits() uint16 {
+	return self.OfsNbits
+}
+
+func (self *ActionNxOutputReg2) SetOfsNbits(v uint16) {
+	self.OfsNbits = v
+}
+
+func (self *ActionNxOutputReg2) GetMaxLen() uint16 {
+	return self.MaxLen
+}
+
+func (self *ActionNxOutputReg2) SetMaxLen(v uint16) {
+	self.MaxLen = v
+}
+
+func (self *ActionNxOutputReg2) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionNicira.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.OfsNbits))
+	encoder.PutUint16(uint16(self.MaxLen))
+	encoder.Write(bytes.Repeat([]byte{0}, 10))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionNxOutputReg2(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxOutputReg2, error) {
+	_actionnxoutputreg2 := &ActionNxOutputReg2{ActionNicira: parent}
+	if decoder.Length() < 14 {
+		return nil, fmt.Errorf("ActionNxOutputReg2 packet too short: %d < 14", decoder.Length())
+	}
+	_actionnxoutputreg2.OfsNbits = uint16(decoder.ReadUint16())
+	_actionnxoutputreg2.MaxLen = uint16(decoder.ReadUint16())
+	decoder.Skip(10)
+	return _actionnxoutputreg2, nil
+}
+
+func NewActionNxOutputReg2() *ActionNxOutputReg2 {
+	obj := &ActionNxOutputReg2{
+		ActionNicira: NewActionNicira(32),
+	}
+	return obj
+}
+func (self *ActionNxOutputReg2) GetActionName() string {
+	return "nx_output_reg2"
+}
+
+func (self *ActionNxOutputReg2) GetActionFields() map[string]interface{} {
+	return map[string]interface{}{
+		"OfsNbits": self.OfsNbits,
+		"MaxLen":   self.MaxLen,
+	}
+}
+
+func (self *ActionNxOutputReg2) MarshalJSON() ([]byte, error) {
+	jsonValue, err := json.Marshal(self.GetActionFields())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxOutputTrunc struct {
+	*ActionNicira
+	Port   uint16
+	MaxLen uint32
+}
+
+type IActionNxOutputTrunc interface {
+	IActionNicira
+	GetPort() uint16
+	GetMaxLen() uint32
+}
+
+func (self *ActionNxOutputTrunc) GetPort() uint16 {
+	return self.Port
+}
+
+func (self *ActionNxOutputTrunc) SetPort(v uint16) {
+	self.Port = v
+}
+
+func (self *ActionNxOutputTrunc) GetMaxLen() uint32 {
+	return self.MaxLen
+}
+
+func (self *ActionNxOutputTrunc) SetMaxLen(v uint32) {
+	self.MaxLen = v
+}
+
+func (self *ActionNxOutputTrunc) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionNicira.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Port))
+	encoder.PutUint32(uint32(self.MaxLen))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionNxOutputTrunc(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxOutputTrunc, error) {
+	_actionnxoutputtrunc := &ActionNxOutputTrunc{ActionNicira: parent}
+	if decoder.Length() < 6 {
+		return nil, fmt.Errorf("ActionNxOutputTrunc packet too short: %d < 6", decoder.Length())
+	}
+	_actionnxoutputtrunc.Port = uint16(decoder.ReadUint16())
+	_actionnxoutputtrunc.MaxLen = uint32(decoder.ReadUint32())
+	return _actionnxoutputtrunc, nil
+}
+
+func NewActionNxOutputTrunc() *ActionNxOutputTrunc {
+	obj := &ActionNxOutputTrunc{
+		ActionNicira: NewActionNicira(39),
+	}
+	return obj
+}
+func (self *ActionNxOutputTrunc) GetActionName() string {
+	return "nx_output_trunc"
+}
+
+func (self *ActionNxOutputTrunc) GetActionFields() map[string]interface{} {
+	return map[string]interface{}{
+		"Port":   self.Port,
+		"MaxLen": self.MaxLen,
+	}
+}
+
+func (self *ActionNxOutputTrunc) MarshalJSON() ([]byte, error) {
+	jsonValue, err := json.Marshal(self.GetActionFields())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxPopMpls struct {
+	*ActionNicira
+	Value uint16
+}
+
+type IActionNxPopMpls interface {
+	IActionNicira
+	GetValue() uint16
+}
+
+func (self *ActionNxPopMpls) GetValue() uint16 {
+	return self.Value
+}
+
+func (self *ActionNxPopMpls) SetValue(v uint16) {
+	self.Value = v
+}
+
+func (self *ActionNxPopMpls) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionNicira.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Value))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionNxPopMpls(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxPopMpls, error) {
+	_actionnxpopmpls := &ActionNxPopMpls{ActionNicira: parent}
+	if decoder.Length() < 2 {
+		return nil, fmt.Errorf("ActionNxPopMpls packet too short: %d < 2", decoder.Length())
+	}
+	_actionnxpopmpls.Value = uint16(decoder.ReadUint16())
+	return _actionnxpopmpls, nil
+}
+
+func NewActionNxPopMpls() *ActionNxPopMpls {
+	obj := &ActionNxPopMpls{
+		ActionNicira: NewActionNicira(24),
+	}
+	return obj
+}
+func (self *ActionNxPopMpls) GetActionName() string {
+	return "nx_pop_mpls"
+}
+
+func (self *ActionNxPopMpls) GetActionFields() map[string]interface{} {
+	return map[string]interface{}{
+		"Value": self.Value,
+	}
+}
+
+func (self *ActionNxPopMpls) MarshalJSON() ([]byte, error) {
+	jsonValue, err := json.Marshal(self.GetActionFields())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxPopQueue struct {
+	*ActionNicira
+}
+
+type IActionNxPopQueue interface {
+	IActionNicira
+}
+
+func (self *ActionNxPopQueue) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionNicira.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionNxPopQueue(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxPopQueue, error) {
+	_actionnxpopqueue := &ActionNxPopQueue{ActionNicira: parent}
+	return _actionnxpopqueue, nil
+}
+
+func NewActionNxPopQueue() *ActionNxPopQueue {
+	obj := &ActionNxPopQueue{
+		ActionNicira: NewActionNicira(5),
+	}
+	return obj
+}
+func (self *ActionNxPopQueue) GetActionName() string {
+	return "nx_pop_queue"
+}
+
+func (self *ActionNxPopQueue) GetActionFields() map[string]interface{} {
+	return map[string]interface{}{}
+}
+
+func (self *ActionNxPopQueue) MarshalJSON() ([]byte, error) {
+	jsonValue, err := json.Marshal(self.GetActionFields())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxPushMpls struct {
+	*ActionNicira
+	Value uint16
+}
+
+type IActionNxPushMpls interface {
+	IActionNicira
+	GetValue() uint16
+}
+
+func (self *ActionNxPushMpls) GetValue() uint16 {
+	return self.Value
+}
+
+func (self *ActionNxPushMpls) SetValue(v uint16) {
+	self.Value = v
+}
+
+func (self *ActionNxPushMpls) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionNicira.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Value))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionNxPushMpls(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxPushMpls, error) {
+	_actionnxpushmpls := &ActionNxPushMpls{ActionNicira: parent}
+	if decoder.Length() < 2 {
+		return nil, fmt.Errorf("ActionNxPushMpls packet too short: %d < 2", decoder.Length())
+	}
+	_actionnxpushmpls.Value = uint16(decoder.ReadUint16())
+	return _actionnxpushmpls, nil
+}
+
+func NewActionNxPushMpls() *ActionNxPushMpls {
+	obj := &ActionNxPushMpls{
+		ActionNicira: NewActionNicira(23),
+	}
+	return obj
+}
+func (self *ActionNxPushMpls) GetActionName() string {
+	return "nx_push_mpls"
+}
+
+func (self *ActionNxPushMpls) GetActionFields() map[string]interface{} {
+	return map[string]interface{}{
+		"Value": self.Value,
+	}
+}
+
+func (self *ActionNxPushMpls) MarshalJSON() ([]byte, error) {
+	jsonValue, err := json.Marshal(self.GetActionFields())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxRegLoad struct {
+	*ActionNicira
+	OfsNbits uint16
+	SrcField goloxi.IOxmId
+	Value    uint64
+}
+
+type IActionNxRegLoad interface {
+	IActionNicira
+	GetOfsNbits() uint16
+	GetSrcField() goloxi.IOxmId
+	GetValue() uint64
+}
+
+func (self *ActionNxRegLoad) GetOfsNbits() uint16 {
+	return self.OfsNbits
+}
+
+func (self *ActionNxRegLoad) SetOfsNbits(v uint16) {
+	self.OfsNbits = v
+}
+
+func (self *ActionNxRegLoad) GetSrcField() goloxi.IOxmId {
+	return self.SrcField
+}
+
+func (self *ActionNxRegLoad) SetSrcField(v goloxi.IOxmId) {
+	self.SrcField = v
+}
+
+func (self *ActionNxRegLoad) GetValue() uint64 {
+	return self.Value
+}
+
+func (self *ActionNxRegLoad) SetValue(v uint64) {
+	self.Value = v
+}
+
+func (self *ActionNxRegLoad) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionNicira.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.OfsNbits))
+	self.SrcField.Serialize(encoder)
+	encoder.PutUint64(uint64(self.Value))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionNxRegLoad(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxRegLoad, error) {
+	_actionnxregload := &ActionNxRegLoad{ActionNicira: parent}
+	if decoder.Length() < 14 {
+		return nil, fmt.Errorf("ActionNxRegLoad packet too short: %d < 14", decoder.Length())
+	}
+	_actionnxregload.OfsNbits = uint16(decoder.ReadUint16())
+	if obj, err := DecodeOxmId(decoder); err != nil {
+		return nil, err
+	} else {
+		_actionnxregload.SrcField = obj
+	}
+
+	_actionnxregload.Value = uint64(decoder.ReadUint64())
+	return _actionnxregload, nil
+}
+
+func NewActionNxRegLoad() *ActionNxRegLoad {
+	obj := &ActionNxRegLoad{
+		ActionNicira: NewActionNicira(7),
+	}
+	return obj
+}
+func (self *ActionNxRegLoad) GetActionName() string {
+	return "nx_reg_load"
+}
+
+func (self *ActionNxRegLoad) GetActionFields() map[string]interface{} {
+	return map[string]interface{}{
+		"OfsNbits": self.OfsNbits,
+		"SrcField": self.SrcField,
+		"Value":    self.Value,
+	}
+}
+
+func (self *ActionNxRegLoad) MarshalJSON() ([]byte, error) {
+	jsonValue, err := json.Marshal(self.GetActionFields())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxRegLoad2 struct {
+	*ActionNicira
+}
+
+type IActionNxRegLoad2 interface {
+	IActionNicira
+}
+
+func (self *ActionNxRegLoad2) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionNicira.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(bytes.Repeat([]byte{0}, 6))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionNxRegLoad2(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxRegLoad2, error) {
+	_actionnxregload2 := &ActionNxRegLoad2{ActionNicira: parent}
+	if decoder.Length() < 6 {
+		return nil, fmt.Errorf("ActionNxRegLoad2 packet too short: %d < 6", decoder.Length())
+	}
+	decoder.Skip(6)
+	return _actionnxregload2, nil
+}
+
+func NewActionNxRegLoad2() *ActionNxRegLoad2 {
+	obj := &ActionNxRegLoad2{
+		ActionNicira: NewActionNicira(33),
+	}
+	return obj
+}
+func (self *ActionNxRegLoad2) GetActionName() string {
+	return "nx_reg_load2"
+}
+
+func (self *ActionNxRegLoad2) GetActionFields() map[string]interface{} {
+	return map[string]interface{}{}
+}
+
+func (self *ActionNxRegLoad2) MarshalJSON() ([]byte, error) {
+	jsonValue, err := json.Marshal(self.GetActionFields())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxRegMove struct {
+	*ActionNicira
+	NBits  uint16
+	SrcOfs uint16
+	DstOfs uint16
+	Src    goloxi.IOxmId
+	Dst    goloxi.IOxmId
+}
+
+type IActionNxRegMove interface {
+	IActionNicira
+	GetNBits() uint16
+	GetSrcOfs() uint16
+	GetDstOfs() uint16
+	GetSrc() goloxi.IOxmId
+	GetDst() goloxi.IOxmId
+}
+
+func (self *ActionNxRegMove) GetNBits() uint16 {
+	return self.NBits
+}
+
+func (self *ActionNxRegMove) SetNBits(v uint16) {
+	self.NBits = v
+}
+
+func (self *ActionNxRegMove) GetSrcOfs() uint16 {
+	return self.SrcOfs
+}
+
+func (self *ActionNxRegMove) SetSrcOfs(v uint16) {
+	self.SrcOfs = v
+}
+
+func (self *ActionNxRegMove) GetDstOfs() uint16 {
+	return self.DstOfs
+}
+
+func (self *ActionNxRegMove) SetDstOfs(v uint16) {
+	self.DstOfs = v
+}
+
+func (self *ActionNxRegMove) GetSrc() goloxi.IOxmId {
+	return self.Src
+}
+
+func (self *ActionNxRegMove) SetSrc(v goloxi.IOxmId) {
+	self.Src = v
+}
+
+func (self *ActionNxRegMove) GetDst() goloxi.IOxmId {
+	return self.Dst
+}
+
+func (self *ActionNxRegMove) SetDst(v goloxi.IOxmId) {
+	self.Dst = v
+}
+
+func (self *ActionNxRegMove) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionNicira.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.NBits))
+	encoder.PutUint16(uint16(self.SrcOfs))
+	encoder.PutUint16(uint16(self.DstOfs))
+	self.Src.Serialize(encoder)
+	self.Dst.Serialize(encoder)
+	length := len(encoder.Bytes()) - startIndex
+	alignedLength := ((length + 7) / 8 * 8)
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
+
+	return nil
+}
+
+func DecodeActionNxRegMove(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxRegMove, error) {
+	_actionnxregmove := &ActionNxRegMove{ActionNicira: parent}
+	if decoder.Length() < 14 {
+		return nil, fmt.Errorf("ActionNxRegMove packet too short: %d < 14", decoder.Length())
+	}
+	_actionnxregmove.NBits = uint16(decoder.ReadUint16())
+	_actionnxregmove.SrcOfs = uint16(decoder.ReadUint16())
+	_actionnxregmove.DstOfs = uint16(decoder.ReadUint16())
+	if obj, err := DecodeOxmId(decoder); err != nil {
+		return nil, err
+	} else {
+		_actionnxregmove.Src = obj
+	}
+
+	if obj, err := DecodeOxmId(decoder); err != nil {
+		return nil, err
+	} else {
+		_actionnxregmove.Dst = obj
+	}
+
+	return _actionnxregmove, nil
+}
+
+func NewActionNxRegMove() *ActionNxRegMove {
+	obj := &ActionNxRegMove{
+		ActionNicira: NewActionNicira(6),
+	}
+	return obj
+}
+func (self *ActionNxRegMove) GetActionName() string {
+	return "nx_reg_move"
+}
+
+func (self *ActionNxRegMove) GetActionFields() map[string]interface{} {
+	return map[string]interface{}{
+		"NBits":  self.NBits,
+		"SrcOfs": self.SrcOfs,
+		"DstOfs": self.DstOfs,
+		"Src":    self.Src,
+		"Dst":    self.Dst,
+	}
+}
+
+func (self *ActionNxRegMove) MarshalJSON() ([]byte, error) {
+	jsonValue, err := json.Marshal(self.GetActionFields())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxResubmit struct {
+	*ActionNicira
+	Value uint16
+}
+
+type IActionNxResubmit interface {
+	IActionNicira
+	GetValue() uint16
+}
+
+func (self *ActionNxResubmit) GetValue() uint16 {
+	return self.Value
+}
+
+func (self *ActionNxResubmit) SetValue(v uint16) {
+	self.Value = v
+}
+
+func (self *ActionNxResubmit) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionNicira.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Value))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionNxResubmit(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxResubmit, error) {
+	_actionnxresubmit := &ActionNxResubmit{ActionNicira: parent}
+	if decoder.Length() < 2 {
+		return nil, fmt.Errorf("ActionNxResubmit packet too short: %d < 2", decoder.Length())
+	}
+	_actionnxresubmit.Value = uint16(decoder.ReadUint16())
+	return _actionnxresubmit, nil
+}
+
+func NewActionNxResubmit() *ActionNxResubmit {
+	obj := &ActionNxResubmit{
+		ActionNicira: NewActionNicira(1),
+	}
+	return obj
+}
+func (self *ActionNxResubmit) GetActionName() string {
+	return "nx_resubmit"
+}
+
+func (self *ActionNxResubmit) GetActionFields() map[string]interface{} {
+	return map[string]interface{}{
+		"Value": self.Value,
+	}
+}
+
+func (self *ActionNxResubmit) MarshalJSON() ([]byte, error) {
+	jsonValue, err := json.Marshal(self.GetActionFields())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxResubmitTable struct {
+	*ActionNicira
+	InPort uint16
+	Table  uint8
+}
+
+type IActionNxResubmitTable interface {
+	IActionNicira
+	GetInPort() uint16
+	GetTable() uint8
+}
+
+func (self *ActionNxResubmitTable) GetInPort() uint16 {
+	return self.InPort
+}
+
+func (self *ActionNxResubmitTable) SetInPort(v uint16) {
+	self.InPort = v
+}
+
+func (self *ActionNxResubmitTable) GetTable() uint8 {
+	return self.Table
+}
+
+func (self *ActionNxResubmitTable) SetTable(v uint8) {
+	self.Table = v
+}
+
+func (self *ActionNxResubmitTable) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionNicira.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.InPort))
+	encoder.PutUint8(uint8(self.Table))
+	encoder.Write(bytes.Repeat([]byte{0}, 3))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionNxResubmitTable(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxResubmitTable, error) {
+	_actionnxresubmittable := &ActionNxResubmitTable{ActionNicira: parent}
+	if decoder.Length() < 6 {
+		return nil, fmt.Errorf("ActionNxResubmitTable packet too short: %d < 6", decoder.Length())
+	}
+	_actionnxresubmittable.InPort = uint16(decoder.ReadUint16())
+	_actionnxresubmittable.Table = uint8(decoder.ReadByte())
+	decoder.Skip(3)
+	return _actionnxresubmittable, nil
+}
+
+func NewActionNxResubmitTable() *ActionNxResubmitTable {
+	obj := &ActionNxResubmitTable{
+		ActionNicira: NewActionNicira(14),
+	}
+	return obj
+}
+func (self *ActionNxResubmitTable) GetActionName() string {
+	return "nx_resubmit_table"
+}
+
+func (self *ActionNxResubmitTable) GetActionFields() map[string]interface{} {
+	return map[string]interface{}{
+		"InPort": self.InPort,
+		"Table":  self.Table,
+	}
+}
+
+func (self *ActionNxResubmitTable) MarshalJSON() ([]byte, error) {
+	jsonValue, err := json.Marshal(self.GetActionFields())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxResubmitTableCt struct {
+	*ActionNicira
+	InPort uint16
+	Table  uint8
+}
+
+type IActionNxResubmitTableCt interface {
+	IActionNicira
+	GetInPort() uint16
+	GetTable() uint8
+}
+
+func (self *ActionNxResubmitTableCt) GetInPort() uint16 {
+	return self.InPort
+}
+
+func (self *ActionNxResubmitTableCt) SetInPort(v uint16) {
+	self.InPort = v
+}
+
+func (self *ActionNxResubmitTableCt) GetTable() uint8 {
+	return self.Table
+}
+
+func (self *ActionNxResubmitTableCt) SetTable(v uint8) {
+	self.Table = v
+}
+
+func (self *ActionNxResubmitTableCt) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionNicira.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.InPort))
+	encoder.PutUint8(uint8(self.Table))
+	encoder.Write(bytes.Repeat([]byte{0}, 3))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionNxResubmitTableCt(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxResubmitTableCt, error) {
+	_actionnxresubmittablect := &ActionNxResubmitTableCt{ActionNicira: parent}
+	if decoder.Length() < 6 {
+		return nil, fmt.Errorf("ActionNxResubmitTableCt packet too short: %d < 6", decoder.Length())
+	}
+	_actionnxresubmittablect.InPort = uint16(decoder.ReadUint16())
+	_actionnxresubmittablect.Table = uint8(decoder.ReadByte())
+	decoder.Skip(3)
+	return _actionnxresubmittablect, nil
+}
+
+func NewActionNxResubmitTableCt() *ActionNxResubmitTableCt {
+	obj := &ActionNxResubmitTableCt{
+		ActionNicira: NewActionNicira(44),
+	}
+	return obj
+}
+func (self *ActionNxResubmitTableCt) GetActionName() string {
+	return "nx_resubmit_table_ct"
+}
+
+func (self *ActionNxResubmitTableCt) GetActionFields() map[string]interface{} {
+	return map[string]interface{}{
+		"InPort": self.InPort,
+		"Table":  self.Table,
+	}
+}
+
+func (self *ActionNxResubmitTableCt) MarshalJSON() ([]byte, error) {
+	jsonValue, err := json.Marshal(self.GetActionFields())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxSample struct {
+	*ActionNicira
+	Probability    uint16
+	CollectorSetId uint32
+	ObsDomainId    uint32
+	ObsPointId     uint32
+}
+
+type IActionNxSample interface {
+	IActionNicira
+	GetProbability() uint16
+	GetCollectorSetId() uint32
+	GetObsDomainId() uint32
+	GetObsPointId() uint32
+}
+
+func (self *ActionNxSample) GetProbability() uint16 {
+	return self.Probability
+}
+
+func (self *ActionNxSample) SetProbability(v uint16) {
+	self.Probability = v
+}
+
+func (self *ActionNxSample) GetCollectorSetId() uint32 {
+	return self.CollectorSetId
+}
+
+func (self *ActionNxSample) SetCollectorSetId(v uint32) {
+	self.CollectorSetId = v
+}
+
+func (self *ActionNxSample) GetObsDomainId() uint32 {
+	return self.ObsDomainId
+}
+
+func (self *ActionNxSample) SetObsDomainId(v uint32) {
+	self.ObsDomainId = v
+}
+
+func (self *ActionNxSample) GetObsPointId() uint32 {
+	return self.ObsPointId
+}
+
+func (self *ActionNxSample) SetObsPointId(v uint32) {
+	self.ObsPointId = v
+}
+
+func (self *ActionNxSample) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionNicira.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Probability))
+	encoder.PutUint32(uint32(self.CollectorSetId))
+	encoder.PutUint32(uint32(self.ObsDomainId))
+	encoder.PutUint32(uint32(self.ObsPointId))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionNxSample(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxSample, error) {
+	_actionnxsample := &ActionNxSample{ActionNicira: parent}
+	if decoder.Length() < 14 {
+		return nil, fmt.Errorf("ActionNxSample packet too short: %d < 14", decoder.Length())
+	}
+	_actionnxsample.Probability = uint16(decoder.ReadUint16())
+	_actionnxsample.CollectorSetId = uint32(decoder.ReadUint32())
+	_actionnxsample.ObsDomainId = uint32(decoder.ReadUint32())
+	_actionnxsample.ObsPointId = uint32(decoder.ReadUint32())
+	return _actionnxsample, nil
+}
+
+func NewActionNxSample() *ActionNxSample {
+	obj := &ActionNxSample{
+		ActionNicira: NewActionNicira(29),
+	}
+	return obj
+}
+func (self *ActionNxSample) GetActionName() string {
+	return "nx_sample"
+}
+
+func (self *ActionNxSample) GetActionFields() map[string]interface{} {
+	return map[string]interface{}{
+		"Probability":    self.Probability,
+		"CollectorSetId": self.CollectorSetId,
+		"ObsDomainId":    self.ObsDomainId,
+		"ObsPointId":     self.ObsPointId,
+	}
+}
+
+func (self *ActionNxSample) MarshalJSON() ([]byte, error) {
+	jsonValue, err := json.Marshal(self.GetActionFields())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxSample2 struct {
+	*ActionNicira
+	Probability    uint16
+	CollectorSetId uint32
+	ObsDomainId    uint32
+	ObsPointId     uint32
+	SamplingPort   uint16
+	Direction      uint8
+}
+
+type IActionNxSample2 interface {
+	IActionNicira
+	GetProbability() uint16
+	GetCollectorSetId() uint32
+	GetObsDomainId() uint32
+	GetObsPointId() uint32
+	GetSamplingPort() uint16
+	GetDirection() uint8
+}
+
+func (self *ActionNxSample2) GetProbability() uint16 {
+	return self.Probability
+}
+
+func (self *ActionNxSample2) SetProbability(v uint16) {
+	self.Probability = v
+}
+
+func (self *ActionNxSample2) GetCollectorSetId() uint32 {
+	return self.CollectorSetId
+}
+
+func (self *ActionNxSample2) SetCollectorSetId(v uint32) {
+	self.CollectorSetId = v
+}
+
+func (self *ActionNxSample2) GetObsDomainId() uint32 {
+	return self.ObsDomainId
+}
+
+func (self *ActionNxSample2) SetObsDomainId(v uint32) {
+	self.ObsDomainId = v
+}
+
+func (self *ActionNxSample2) GetObsPointId() uint32 {
+	return self.ObsPointId
+}
+
+func (self *ActionNxSample2) SetObsPointId(v uint32) {
+	self.ObsPointId = v
+}
+
+func (self *ActionNxSample2) GetSamplingPort() uint16 {
+	return self.SamplingPort
+}
+
+func (self *ActionNxSample2) SetSamplingPort(v uint16) {
+	self.SamplingPort = v
+}
+
+func (self *ActionNxSample2) GetDirection() uint8 {
+	return self.Direction
+}
+
+func (self *ActionNxSample2) SetDirection(v uint8) {
+	self.Direction = v
+}
+
+func (self *ActionNxSample2) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionNicira.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Probability))
+	encoder.PutUint32(uint32(self.CollectorSetId))
+	encoder.PutUint32(uint32(self.ObsDomainId))
+	encoder.PutUint32(uint32(self.ObsPointId))
+	encoder.PutUint16(uint16(self.SamplingPort))
+	encoder.PutUint8(uint8(self.Direction))
+	encoder.Write(bytes.Repeat([]byte{0}, 5))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionNxSample2(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxSample2, error) {
+	_actionnxsample2 := &ActionNxSample2{ActionNicira: parent}
+	if decoder.Length() < 22 {
+		return nil, fmt.Errorf("ActionNxSample2 packet too short: %d < 22", decoder.Length())
+	}
+	_actionnxsample2.Probability = uint16(decoder.ReadUint16())
+	_actionnxsample2.CollectorSetId = uint32(decoder.ReadUint32())
+	_actionnxsample2.ObsDomainId = uint32(decoder.ReadUint32())
+	_actionnxsample2.ObsPointId = uint32(decoder.ReadUint32())
+	_actionnxsample2.SamplingPort = uint16(decoder.ReadUint16())
+	_actionnxsample2.Direction = uint8(decoder.ReadByte())
+	decoder.Skip(5)
+	return _actionnxsample2, nil
+}
+
+func NewActionNxSample2() *ActionNxSample2 {
+	obj := &ActionNxSample2{
+		ActionNicira: NewActionNicira(38),
+	}
+	return obj
+}
+func (self *ActionNxSample2) GetActionName() string {
+	return "nx_sample2"
+}
+
+func (self *ActionNxSample2) GetActionFields() map[string]interface{} {
+	return map[string]interface{}{
+		"Probability":    self.Probability,
+		"CollectorSetId": self.CollectorSetId,
+		"ObsDomainId":    self.ObsDomainId,
+		"ObsPointId":     self.ObsPointId,
+		"SamplingPort":   self.SamplingPort,
+		"Direction":      self.Direction,
+	}
+}
+
+func (self *ActionNxSample2) MarshalJSON() ([]byte, error) {
+	jsonValue, err := json.Marshal(self.GetActionFields())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxSample3 struct {
+	*ActionNicira
+	Probability    uint16
+	CollectorSetId uint32
+	ObsDomainId    uint32
+	ObsPointId     uint32
+	SamplingPort   uint16
+	Direction      uint8
+}
+
+type IActionNxSample3 interface {
+	IActionNicira
+	GetProbability() uint16
+	GetCollectorSetId() uint32
+	GetObsDomainId() uint32
+	GetObsPointId() uint32
+	GetSamplingPort() uint16
+	GetDirection() uint8
+}
+
+func (self *ActionNxSample3) GetProbability() uint16 {
+	return self.Probability
+}
+
+func (self *ActionNxSample3) SetProbability(v uint16) {
+	self.Probability = v
+}
+
+func (self *ActionNxSample3) GetCollectorSetId() uint32 {
+	return self.CollectorSetId
+}
+
+func (self *ActionNxSample3) SetCollectorSetId(v uint32) {
+	self.CollectorSetId = v
+}
+
+func (self *ActionNxSample3) GetObsDomainId() uint32 {
+	return self.ObsDomainId
+}
+
+func (self *ActionNxSample3) SetObsDomainId(v uint32) {
+	self.ObsDomainId = v
+}
+
+func (self *ActionNxSample3) GetObsPointId() uint32 {
+	return self.ObsPointId
+}
+
+func (self *ActionNxSample3) SetObsPointId(v uint32) {
+	self.ObsPointId = v
+}
+
+func (self *ActionNxSample3) GetSamplingPort() uint16 {
+	return self.SamplingPort
+}
+
+func (self *ActionNxSample3) SetSamplingPort(v uint16) {
+	self.SamplingPort = v
+}
+
+func (self *ActionNxSample3) GetDirection() uint8 {
+	return self.Direction
+}
+
+func (self *ActionNxSample3) SetDirection(v uint8) {
+	self.Direction = v
+}
+
+func (self *ActionNxSample3) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionNicira.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Probability))
+	encoder.PutUint32(uint32(self.CollectorSetId))
+	encoder.PutUint32(uint32(self.ObsDomainId))
+	encoder.PutUint32(uint32(self.ObsPointId))
+	encoder.PutUint16(uint16(self.SamplingPort))
+	encoder.PutUint8(uint8(self.Direction))
+	encoder.Write(bytes.Repeat([]byte{0}, 5))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionNxSample3(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxSample3, error) {
+	_actionnxsample3 := &ActionNxSample3{ActionNicira: parent}
+	if decoder.Length() < 22 {
+		return nil, fmt.Errorf("ActionNxSample3 packet too short: %d < 22", decoder.Length())
+	}
+	_actionnxsample3.Probability = uint16(decoder.ReadUint16())
+	_actionnxsample3.CollectorSetId = uint32(decoder.ReadUint32())
+	_actionnxsample3.ObsDomainId = uint32(decoder.ReadUint32())
+	_actionnxsample3.ObsPointId = uint32(decoder.ReadUint32())
+	_actionnxsample3.SamplingPort = uint16(decoder.ReadUint16())
+	_actionnxsample3.Direction = uint8(decoder.ReadByte())
+	decoder.Skip(5)
+	return _actionnxsample3, nil
+}
+
+func NewActionNxSample3() *ActionNxSample3 {
+	obj := &ActionNxSample3{
+		ActionNicira: NewActionNicira(41),
+	}
+	return obj
+}
+func (self *ActionNxSample3) GetActionName() string {
+	return "nx_sample3"
+}
+
+func (self *ActionNxSample3) GetActionFields() map[string]interface{} {
+	return map[string]interface{}{
+		"Probability":    self.Probability,
+		"CollectorSetId": self.CollectorSetId,
+		"ObsDomainId":    self.ObsDomainId,
+		"ObsPointId":     self.ObsPointId,
+		"SamplingPort":   self.SamplingPort,
+		"Direction":      self.Direction,
+	}
+}
+
+func (self *ActionNxSample3) MarshalJSON() ([]byte, error) {
+	jsonValue, err := json.Marshal(self.GetActionFields())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxSetMplsLabel struct {
+	*ActionNicira
+	Value uint32
+}
+
+type IActionNxSetMplsLabel interface {
+	IActionNicira
+	GetValue() uint32
+}
+
+func (self *ActionNxSetMplsLabel) GetValue() uint32 {
+	return self.Value
+}
+
+func (self *ActionNxSetMplsLabel) SetValue(v uint32) {
+	self.Value = v
+}
+
+func (self *ActionNxSetMplsLabel) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionNicira.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Value))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionNxSetMplsLabel(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxSetMplsLabel, error) {
+	_actionnxsetmplslabel := &ActionNxSetMplsLabel{ActionNicira: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("ActionNxSetMplsLabel packet too short: %d < 4", decoder.Length())
+	}
+	_actionnxsetmplslabel.Value = uint32(decoder.ReadUint32())
+	return _actionnxsetmplslabel, nil
+}
+
+func NewActionNxSetMplsLabel() *ActionNxSetMplsLabel {
+	obj := &ActionNxSetMplsLabel{
+		ActionNicira: NewActionNicira(30),
+	}
+	return obj
+}
+func (self *ActionNxSetMplsLabel) GetActionName() string {
+	return "nx_set_mpls_label"
+}
+
+func (self *ActionNxSetMplsLabel) GetActionFields() map[string]interface{} {
+	return map[string]interface{}{
+		"Value": self.Value,
+	}
+}
+
+func (self *ActionNxSetMplsLabel) MarshalJSON() ([]byte, error) {
+	jsonValue, err := json.Marshal(self.GetActionFields())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxSetMplsTc struct {
+	*ActionNicira
+	Value uint8
+}
+
+type IActionNxSetMplsTc interface {
+	IActionNicira
+	GetValue() uint8
+}
+
+func (self *ActionNxSetMplsTc) GetValue() uint8 {
+	return self.Value
+}
+
+func (self *ActionNxSetMplsTc) SetValue(v uint8) {
+	self.Value = v
+}
+
+func (self *ActionNxSetMplsTc) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionNicira.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint8(uint8(self.Value))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionNxSetMplsTc(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxSetMplsTc, error) {
+	_actionnxsetmplstc := &ActionNxSetMplsTc{ActionNicira: parent}
+	if decoder.Length() < 1 {
+		return nil, fmt.Errorf("ActionNxSetMplsTc packet too short: %d < 1", decoder.Length())
+	}
+	_actionnxsetmplstc.Value = uint8(decoder.ReadByte())
+	return _actionnxsetmplstc, nil
+}
+
+func NewActionNxSetMplsTc() *ActionNxSetMplsTc {
+	obj := &ActionNxSetMplsTc{
+		ActionNicira: NewActionNicira(31),
+	}
+	return obj
+}
+func (self *ActionNxSetMplsTc) GetActionName() string {
+	return "nx_set_mpls_tc"
+}
+
+func (self *ActionNxSetMplsTc) GetActionFields() map[string]interface{} {
+	return map[string]interface{}{
+		"Value": self.Value,
+	}
+}
+
+func (self *ActionNxSetMplsTc) MarshalJSON() ([]byte, error) {
+	jsonValue, err := json.Marshal(self.GetActionFields())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxSetMplsTtl struct {
+	*ActionNicira
+	Value uint8
+}
+
+type IActionNxSetMplsTtl interface {
+	IActionNicira
+	GetValue() uint8
+}
+
+func (self *ActionNxSetMplsTtl) GetValue() uint8 {
+	return self.Value
+}
+
+func (self *ActionNxSetMplsTtl) SetValue(v uint8) {
+	self.Value = v
+}
+
+func (self *ActionNxSetMplsTtl) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionNicira.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint8(uint8(self.Value))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionNxSetMplsTtl(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxSetMplsTtl, error) {
+	_actionnxsetmplsttl := &ActionNxSetMplsTtl{ActionNicira: parent}
+	if decoder.Length() < 1 {
+		return nil, fmt.Errorf("ActionNxSetMplsTtl packet too short: %d < 1", decoder.Length())
+	}
+	_actionnxsetmplsttl.Value = uint8(decoder.ReadByte())
+	return _actionnxsetmplsttl, nil
+}
+
+func NewActionNxSetMplsTtl() *ActionNxSetMplsTtl {
+	obj := &ActionNxSetMplsTtl{
+		ActionNicira: NewActionNicira(25),
+	}
+	return obj
+}
+func (self *ActionNxSetMplsTtl) GetActionName() string {
+	return "nx_set_mpls_ttl"
+}
+
+func (self *ActionNxSetMplsTtl) GetActionFields() map[string]interface{} {
+	return map[string]interface{}{
+		"Value": self.Value,
+	}
+}
+
+func (self *ActionNxSetMplsTtl) MarshalJSON() ([]byte, error) {
+	jsonValue, err := json.Marshal(self.GetActionFields())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxSetQueue struct {
+	*ActionNicira
+	Value uint32
+}
+
+type IActionNxSetQueue interface {
+	IActionNicira
+	GetValue() uint32
+}
+
+func (self *ActionNxSetQueue) GetValue() uint32 {
+	return self.Value
+}
+
+func (self *ActionNxSetQueue) SetValue(v uint32) {
+	self.Value = v
+}
+
+func (self *ActionNxSetQueue) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionNicira.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Value))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionNxSetQueue(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxSetQueue, error) {
+	_actionnxsetqueue := &ActionNxSetQueue{ActionNicira: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("ActionNxSetQueue packet too short: %d < 4", decoder.Length())
+	}
+	_actionnxsetqueue.Value = uint32(decoder.ReadUint32())
+	return _actionnxsetqueue, nil
+}
+
+func NewActionNxSetQueue() *ActionNxSetQueue {
+	obj := &ActionNxSetQueue{
+		ActionNicira: NewActionNicira(4),
+	}
+	return obj
+}
+func (self *ActionNxSetQueue) GetActionName() string {
+	return "nx_set_queue"
+}
+
+func (self *ActionNxSetQueue) GetActionFields() map[string]interface{} {
+	return map[string]interface{}{
+		"Value": self.Value,
+	}
+}
+
+func (self *ActionNxSetQueue) MarshalJSON() ([]byte, error) {
+	jsonValue, err := json.Marshal(self.GetActionFields())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxSetTunnel struct {
+	*ActionNicira
+	Value uint32
+}
+
+type IActionNxSetTunnel interface {
+	IActionNicira
+	GetValue() uint32
+}
+
+func (self *ActionNxSetTunnel) GetValue() uint32 {
+	return self.Value
+}
+
+func (self *ActionNxSetTunnel) SetValue(v uint32) {
+	self.Value = v
+}
+
+func (self *ActionNxSetTunnel) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionNicira.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Value))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionNxSetTunnel(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxSetTunnel, error) {
+	_actionnxsettunnel := &ActionNxSetTunnel{ActionNicira: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("ActionNxSetTunnel packet too short: %d < 4", decoder.Length())
+	}
+	_actionnxsettunnel.Value = uint32(decoder.ReadUint32())
+	return _actionnxsettunnel, nil
+}
+
+func NewActionNxSetTunnel() *ActionNxSetTunnel {
+	obj := &ActionNxSetTunnel{
+		ActionNicira: NewActionNicira(2),
+	}
+	return obj
+}
+func (self *ActionNxSetTunnel) GetActionName() string {
+	return "nx_set_tunnel"
+}
+
+func (self *ActionNxSetTunnel) GetActionFields() map[string]interface{} {
+	return map[string]interface{}{
+		"Value": self.Value,
+	}
+}
+
+func (self *ActionNxSetTunnel) MarshalJSON() ([]byte, error) {
+	jsonValue, err := json.Marshal(self.GetActionFields())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxSetTunnel64 struct {
+	*ActionNicira
+	Value uint64
+}
+
+type IActionNxSetTunnel64 interface {
+	IActionNicira
+	GetValue() uint64
+}
+
+func (self *ActionNxSetTunnel64) GetValue() uint64 {
+	return self.Value
+}
+
+func (self *ActionNxSetTunnel64) SetValue(v uint64) {
+	self.Value = v
+}
+
+func (self *ActionNxSetTunnel64) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionNicira.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint64(uint64(self.Value))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionNxSetTunnel64(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxSetTunnel64, error) {
+	_actionnxsettunnel64 := &ActionNxSetTunnel64{ActionNicira: parent}
+	if decoder.Length() < 8 {
+		return nil, fmt.Errorf("ActionNxSetTunnel64 packet too short: %d < 8", decoder.Length())
+	}
+	_actionnxsettunnel64.Value = uint64(decoder.ReadUint64())
+	return _actionnxsettunnel64, nil
+}
+
+func NewActionNxSetTunnel64() *ActionNxSetTunnel64 {
+	obj := &ActionNxSetTunnel64{
+		ActionNicira: NewActionNicira(9),
+	}
+	return obj
+}
+func (self *ActionNxSetTunnel64) GetActionName() string {
+	return "nx_set_tunnel64"
+}
+
+func (self *ActionNxSetTunnel64) GetActionFields() map[string]interface{} {
+	return map[string]interface{}{
+		"Value": self.Value,
+	}
+}
+
+func (self *ActionNxSetTunnel64) MarshalJSON() ([]byte, error) {
+	jsonValue, err := json.Marshal(self.GetActionFields())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxStackPop struct {
+	*ActionNicira
+	Offset uint16
+	Field  goloxi.IOxmId
+	NBits  uint16
+}
+
+type IActionNxStackPop interface {
+	IActionNicira
+	GetOffset() uint16
+	GetField() goloxi.IOxmId
+	GetNBits() uint16
+}
+
+func (self *ActionNxStackPop) GetOffset() uint16 {
+	return self.Offset
+}
+
+func (self *ActionNxStackPop) SetOffset(v uint16) {
+	self.Offset = v
+}
+
+func (self *ActionNxStackPop) GetField() goloxi.IOxmId {
+	return self.Field
+}
+
+func (self *ActionNxStackPop) SetField(v goloxi.IOxmId) {
+	self.Field = v
+}
+
+func (self *ActionNxStackPop) GetNBits() uint16 {
+	return self.NBits
+}
+
+func (self *ActionNxStackPop) SetNBits(v uint16) {
+	self.NBits = v
+}
+
+func (self *ActionNxStackPop) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionNicira.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Offset))
+	self.Field.Serialize(encoder)
+	encoder.PutUint16(uint16(self.NBits))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionNxStackPop(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxStackPop, error) {
+	_actionnxstackpop := &ActionNxStackPop{ActionNicira: parent}
+	if decoder.Length() < 8 {
+		return nil, fmt.Errorf("ActionNxStackPop packet too short: %d < 8", decoder.Length())
+	}
+	_actionnxstackpop.Offset = uint16(decoder.ReadUint16())
+	if obj, err := DecodeOxmId(decoder); err != nil {
+		return nil, err
+	} else {
+		_actionnxstackpop.Field = obj
+	}
+
+	_actionnxstackpop.NBits = uint16(decoder.ReadUint16())
+	return _actionnxstackpop, nil
+}
+
+func NewActionNxStackPop() *ActionNxStackPop {
+	obj := &ActionNxStackPop{
+		ActionNicira: NewActionNicira(28),
+	}
+	return obj
+}
+func (self *ActionNxStackPop) GetActionName() string {
+	return "nx_stack_pop"
+}
+
+func (self *ActionNxStackPop) GetActionFields() map[string]interface{} {
+	return map[string]interface{}{
+		"Offset": self.Offset,
+		"Field":  self.Field,
+		"NBits":  self.NBits,
+	}
+}
+
+func (self *ActionNxStackPop) MarshalJSON() ([]byte, error) {
+	jsonValue, err := json.Marshal(self.GetActionFields())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxStackPush struct {
+	*ActionNicira
+	Offset uint16
+	Field  goloxi.IOxmId
+	NBits  uint16
+}
+
+type IActionNxStackPush interface {
+	IActionNicira
+	GetOffset() uint16
+	GetField() goloxi.IOxmId
+	GetNBits() uint16
+}
+
+func (self *ActionNxStackPush) GetOffset() uint16 {
+	return self.Offset
+}
+
+func (self *ActionNxStackPush) SetOffset(v uint16) {
+	self.Offset = v
+}
+
+func (self *ActionNxStackPush) GetField() goloxi.IOxmId {
+	return self.Field
+}
+
+func (self *ActionNxStackPush) SetField(v goloxi.IOxmId) {
+	self.Field = v
+}
+
+func (self *ActionNxStackPush) GetNBits() uint16 {
+	return self.NBits
+}
+
+func (self *ActionNxStackPush) SetNBits(v uint16) {
+	self.NBits = v
+}
+
+func (self *ActionNxStackPush) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionNicira.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Offset))
+	self.Field.Serialize(encoder)
+	encoder.PutUint16(uint16(self.NBits))
+	length := len(encoder.Bytes()) - startIndex
+	alignedLength := ((length + 23) / 24 * 24)
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
+
+	return nil
+}
+
+func DecodeActionNxStackPush(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxStackPush, error) {
+	_actionnxstackpush := &ActionNxStackPush{ActionNicira: parent}
+	if decoder.Length() < 8 {
+		return nil, fmt.Errorf("ActionNxStackPush packet too short: %d < 8", decoder.Length())
+	}
+	_actionnxstackpush.Offset = uint16(decoder.ReadUint16())
+	if obj, err := DecodeOxmId(decoder); err != nil {
+		return nil, err
+	} else {
+		_actionnxstackpush.Field = obj
+	}
+
+	_actionnxstackpush.NBits = uint16(decoder.ReadUint16())
+	return _actionnxstackpush, nil
+}
+
+func NewActionNxStackPush() *ActionNxStackPush {
+	obj := &ActionNxStackPush{
+		ActionNicira: NewActionNicira(27),
+	}
+	return obj
+}
+func (self *ActionNxStackPush) GetActionName() string {
+	return "nx_stack_push"
+}
+
+func (self *ActionNxStackPush) GetActionFields() map[string]interface{} {
+	return map[string]interface{}{
+		"Offset": self.Offset,
+		"Field":  self.Field,
+		"NBits":  self.NBits,
+	}
+}
+
+func (self *ActionNxStackPush) MarshalJSON() ([]byte, error) {
+	jsonValue, err := json.Marshal(self.GetActionFields())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionNxWriteMetadata struct {
+	*ActionNicira
+	Metadata uint64
+	Mask     uint64
+}
+
+type IActionNxWriteMetadata interface {
+	IActionNicira
+	GetMetadata() uint64
+	GetMask() uint64
+}
+
+func (self *ActionNxWriteMetadata) GetMetadata() uint64 {
+	return self.Metadata
+}
+
+func (self *ActionNxWriteMetadata) SetMetadata(v uint64) {
+	self.Metadata = v
+}
+
+func (self *ActionNxWriteMetadata) GetMask() uint64 {
+	return self.Mask
+}
+
+func (self *ActionNxWriteMetadata) SetMask(v uint64) {
+	self.Mask = v
+}
+
+func (self *ActionNxWriteMetadata) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionNicira.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(bytes.Repeat([]byte{0}, 6))
+	encoder.PutUint64(uint64(self.Metadata))
+	encoder.PutUint64(uint64(self.Mask))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionNxWriteMetadata(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionNxWriteMetadata, error) {
+	_actionnxwritemetadata := &ActionNxWriteMetadata{ActionNicira: parent}
+	if decoder.Length() < 22 {
+		return nil, fmt.Errorf("ActionNxWriteMetadata packet too short: %d < 22", decoder.Length())
+	}
+	decoder.Skip(6)
+	_actionnxwritemetadata.Metadata = uint64(decoder.ReadUint64())
+	_actionnxwritemetadata.Mask = uint64(decoder.ReadUint64())
+	return _actionnxwritemetadata, nil
+}
+
+func NewActionNxWriteMetadata() *ActionNxWriteMetadata {
+	obj := &ActionNxWriteMetadata{
+		ActionNicira: NewActionNicira(22),
+	}
+	return obj
+}
+func (self *ActionNxWriteMetadata) GetActionName() string {
+	return "nx_write_metadata"
+}
+
+func (self *ActionNxWriteMetadata) GetActionFields() map[string]interface{} {
+	return map[string]interface{}{
+		"Metadata": self.Metadata,
+		"Mask":     self.Mask,
+	}
+}
+
+func (self *ActionNxWriteMetadata) MarshalJSON() ([]byte, error) {
+	jsonValue, err := json.Marshal(self.GetActionFields())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionOutput struct {
+	*Action
+	Port   Port
+	MaxLen uint16
+}
+
+type IActionOutput interface {
+	goloxi.IAction
+	GetPort() Port
+	GetMaxLen() uint16
+}
+
+func (self *ActionOutput) GetPort() Port {
+	return self.Port
+}
+
+func (self *ActionOutput) SetPort(v Port) {
+	self.Port = v
+}
+
+func (self *ActionOutput) GetMaxLen() uint16 {
+	return self.MaxLen
+}
+
+func (self *ActionOutput) SetMaxLen(v uint16) {
+	self.MaxLen = v
+}
+
+func (self *ActionOutput) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.Action.Serialize(encoder); err != nil {
+		return err
+	}
+
+	self.Port.Serialize(encoder)
+	encoder.PutUint16(uint16(self.MaxLen))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionOutput(parent *Action, decoder *goloxi.Decoder) (*ActionOutput, error) {
+	_actionoutput := &ActionOutput{Action: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("ActionOutput packet too short: %d < 4", decoder.Length())
+	}
+	_actionoutput.Port.Decode(decoder)
+	_actionoutput.MaxLen = uint16(decoder.ReadUint16())
+	return _actionoutput, nil
+}
+
+func NewActionOutput() *ActionOutput {
+	obj := &ActionOutput{
+		Action: NewAction(0),
+	}
+	return obj
+}
+func (self *ActionOutput) GetActionName() string {
+	return "output"
+}
+
+func (self *ActionOutput) GetActionFields() map[string]interface{} {
+	return map[string]interface{}{
+		"Port":   self.Port,
+		"MaxLen": self.MaxLen,
+	}
+}
+
+func (self *ActionOutput) MarshalJSON() ([]byte, error) {
+	jsonValue, err := json.Marshal(self.GetActionFields())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionResubmit struct {
+	*ActionNicira
+	InPort uint16
+	Table  uint8
+}
+
+type IActionResubmit interface {
+	IActionNicira
+	GetInPort() uint16
+	GetTable() uint8
+}
+
+func (self *ActionResubmit) GetInPort() uint16 {
+	return self.InPort
+}
+
+func (self *ActionResubmit) SetInPort(v uint16) {
+	self.InPort = v
+}
+
+func (self *ActionResubmit) GetTable() uint8 {
+	return self.Table
+}
+
+func (self *ActionResubmit) SetTable(v uint8) {
+	self.Table = v
+}
+
+func (self *ActionResubmit) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionNicira.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.InPort))
+	encoder.PutUint8(uint8(self.Table))
+	encoder.Write(bytes.Repeat([]byte{0}, 3))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionResubmit(parent *ActionNicira, decoder *goloxi.Decoder) (*ActionResubmit, error) {
+	_actionresubmit := &ActionResubmit{ActionNicira: parent}
+	if decoder.Length() < 6 {
+		return nil, fmt.Errorf("ActionResubmit packet too short: %d < 6", decoder.Length())
+	}
+	_actionresubmit.InPort = uint16(decoder.ReadUint16())
+	_actionresubmit.Table = uint8(decoder.ReadByte())
+	decoder.Skip(3)
+	return _actionresubmit, nil
+}
+
+func NewActionResubmit() *ActionResubmit {
+	obj := &ActionResubmit{
+		ActionNicira: NewActionNicira(14),
+	}
+	return obj
+}
+func (self *ActionResubmit) GetActionName() string {
+	return "resubmit"
+}
+
+func (self *ActionResubmit) GetActionFields() map[string]interface{} {
+	return map[string]interface{}{
+		"InPort": self.InPort,
+		"Table":  self.Table,
+	}
+}
+
+func (self *ActionResubmit) MarshalJSON() ([]byte, error) {
+	jsonValue, err := json.Marshal(self.GetActionFields())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionSetDlDst struct {
+	*Action
+	DlAddr net.HardwareAddr
+}
+
+type IActionSetDlDst interface {
+	goloxi.IAction
+	GetDlAddr() net.HardwareAddr
+}
+
+func (self *ActionSetDlDst) GetDlAddr() net.HardwareAddr {
+	return self.DlAddr
+}
+
+func (self *ActionSetDlDst) SetDlAddr(v net.HardwareAddr) {
+	self.DlAddr = v
+}
+
+func (self *ActionSetDlDst) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.Action.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.DlAddr)
+	encoder.Write(bytes.Repeat([]byte{0}, 6))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionSetDlDst(parent *Action, decoder *goloxi.Decoder) (*ActionSetDlDst, error) {
+	_actionsetdldst := &ActionSetDlDst{Action: parent}
+	if decoder.Length() < 12 {
+		return nil, fmt.Errorf("ActionSetDlDst packet too short: %d < 12", decoder.Length())
+	}
+	_actionsetdldst.DlAddr = net.HardwareAddr(decoder.Read(6))
+	decoder.Skip(6)
+	return _actionsetdldst, nil
+}
+
+func NewActionSetDlDst() *ActionSetDlDst {
+	obj := &ActionSetDlDst{
+		Action: NewAction(5),
+	}
+	return obj
+}
+func (self *ActionSetDlDst) GetActionName() string {
+	return "set_dl_dst"
+}
+
+func (self *ActionSetDlDst) GetActionFields() map[string]interface{} {
+	return map[string]interface{}{
+		"DlAddr": self.DlAddr,
+	}
+}
+
+func (self *ActionSetDlDst) MarshalJSON() ([]byte, error) {
+	jsonValue, err := json.Marshal(self.GetActionFields())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionSetDlSrc struct {
+	*Action
+	DlAddr net.HardwareAddr
+}
+
+type IActionSetDlSrc interface {
+	goloxi.IAction
+	GetDlAddr() net.HardwareAddr
+}
+
+func (self *ActionSetDlSrc) GetDlAddr() net.HardwareAddr {
+	return self.DlAddr
+}
+
+func (self *ActionSetDlSrc) SetDlAddr(v net.HardwareAddr) {
+	self.DlAddr = v
+}
+
+func (self *ActionSetDlSrc) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.Action.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.DlAddr)
+	encoder.Write(bytes.Repeat([]byte{0}, 6))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionSetDlSrc(parent *Action, decoder *goloxi.Decoder) (*ActionSetDlSrc, error) {
+	_actionsetdlsrc := &ActionSetDlSrc{Action: parent}
+	if decoder.Length() < 12 {
+		return nil, fmt.Errorf("ActionSetDlSrc packet too short: %d < 12", decoder.Length())
+	}
+	_actionsetdlsrc.DlAddr = net.HardwareAddr(decoder.Read(6))
+	decoder.Skip(6)
+	return _actionsetdlsrc, nil
+}
+
+func NewActionSetDlSrc() *ActionSetDlSrc {
+	obj := &ActionSetDlSrc{
+		Action: NewAction(4),
+	}
+	return obj
+}
+func (self *ActionSetDlSrc) GetActionName() string {
+	return "set_dl_src"
+}
+
+func (self *ActionSetDlSrc) GetActionFields() map[string]interface{} {
+	return map[string]interface{}{
+		"DlAddr": self.DlAddr,
+	}
+}
+
+func (self *ActionSetDlSrc) MarshalJSON() ([]byte, error) {
+	jsonValue, err := json.Marshal(self.GetActionFields())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionSetNwDst struct {
+	*Action
+	NwAddr uint32
+}
+
+type IActionSetNwDst interface {
+	goloxi.IAction
+	GetNwAddr() uint32
+}
+
+func (self *ActionSetNwDst) GetNwAddr() uint32 {
+	return self.NwAddr
+}
+
+func (self *ActionSetNwDst) SetNwAddr(v uint32) {
+	self.NwAddr = v
+}
+
+func (self *ActionSetNwDst) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.Action.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.NwAddr))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionSetNwDst(parent *Action, decoder *goloxi.Decoder) (*ActionSetNwDst, error) {
+	_actionsetnwdst := &ActionSetNwDst{Action: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("ActionSetNwDst packet too short: %d < 4", decoder.Length())
+	}
+	_actionsetnwdst.NwAddr = uint32(decoder.ReadUint32())
+	return _actionsetnwdst, nil
+}
+
+func NewActionSetNwDst() *ActionSetNwDst {
+	obj := &ActionSetNwDst{
+		Action: NewAction(7),
+	}
+	return obj
+}
+func (self *ActionSetNwDst) GetActionName() string {
+	return "set_nw_dst"
+}
+
+func (self *ActionSetNwDst) GetActionFields() map[string]interface{} {
+	return map[string]interface{}{
+		"NwAddr": self.NwAddr,
+	}
+}
+
+func (self *ActionSetNwDst) MarshalJSON() ([]byte, error) {
+	jsonValue, err := json.Marshal(self.GetActionFields())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionSetNwSrc struct {
+	*Action
+	NwAddr uint32
+}
+
+type IActionSetNwSrc interface {
+	goloxi.IAction
+	GetNwAddr() uint32
+}
+
+func (self *ActionSetNwSrc) GetNwAddr() uint32 {
+	return self.NwAddr
+}
+
+func (self *ActionSetNwSrc) SetNwAddr(v uint32) {
+	self.NwAddr = v
+}
+
+func (self *ActionSetNwSrc) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.Action.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.NwAddr))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionSetNwSrc(parent *Action, decoder *goloxi.Decoder) (*ActionSetNwSrc, error) {
+	_actionsetnwsrc := &ActionSetNwSrc{Action: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("ActionSetNwSrc packet too short: %d < 4", decoder.Length())
+	}
+	_actionsetnwsrc.NwAddr = uint32(decoder.ReadUint32())
+	return _actionsetnwsrc, nil
+}
+
+func NewActionSetNwSrc() *ActionSetNwSrc {
+	obj := &ActionSetNwSrc{
+		Action: NewAction(6),
+	}
+	return obj
+}
+func (self *ActionSetNwSrc) GetActionName() string {
+	return "set_nw_src"
+}
+
+func (self *ActionSetNwSrc) GetActionFields() map[string]interface{} {
+	return map[string]interface{}{
+		"NwAddr": self.NwAddr,
+	}
+}
+
+func (self *ActionSetNwSrc) MarshalJSON() ([]byte, error) {
+	jsonValue, err := json.Marshal(self.GetActionFields())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionSetNwTos struct {
+	*Action
+	NwTos uint8
+}
+
+type IActionSetNwTos interface {
+	goloxi.IAction
+	GetNwTos() uint8
+}
+
+func (self *ActionSetNwTos) GetNwTos() uint8 {
+	return self.NwTos
+}
+
+func (self *ActionSetNwTos) SetNwTos(v uint8) {
+	self.NwTos = v
+}
+
+func (self *ActionSetNwTos) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.Action.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint8(uint8(self.NwTos))
+	encoder.Write(bytes.Repeat([]byte{0}, 3))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionSetNwTos(parent *Action, decoder *goloxi.Decoder) (*ActionSetNwTos, error) {
+	_actionsetnwtos := &ActionSetNwTos{Action: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("ActionSetNwTos packet too short: %d < 4", decoder.Length())
+	}
+	_actionsetnwtos.NwTos = uint8(decoder.ReadByte())
+	decoder.Skip(3)
+	return _actionsetnwtos, nil
+}
+
+func NewActionSetNwTos() *ActionSetNwTos {
+	obj := &ActionSetNwTos{
+		Action: NewAction(8),
+	}
+	return obj
+}
+func (self *ActionSetNwTos) GetActionName() string {
+	return "set_nw_tos"
+}
+
+func (self *ActionSetNwTos) GetActionFields() map[string]interface{} {
+	return map[string]interface{}{
+		"NwTos": self.NwTos,
+	}
+}
+
+func (self *ActionSetNwTos) MarshalJSON() ([]byte, error) {
+	jsonValue, err := json.Marshal(self.GetActionFields())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionSetTpDst struct {
+	*Action
+	TpPort uint16
+}
+
+type IActionSetTpDst interface {
+	goloxi.IAction
+	GetTpPort() uint16
+}
+
+func (self *ActionSetTpDst) GetTpPort() uint16 {
+	return self.TpPort
+}
+
+func (self *ActionSetTpDst) SetTpPort(v uint16) {
+	self.TpPort = v
+}
+
+func (self *ActionSetTpDst) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.Action.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.TpPort))
+	encoder.Write(bytes.Repeat([]byte{0}, 2))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionSetTpDst(parent *Action, decoder *goloxi.Decoder) (*ActionSetTpDst, error) {
+	_actionsettpdst := &ActionSetTpDst{Action: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("ActionSetTpDst packet too short: %d < 4", decoder.Length())
+	}
+	_actionsettpdst.TpPort = uint16(decoder.ReadUint16())
+	decoder.Skip(2)
+	return _actionsettpdst, nil
+}
+
+func NewActionSetTpDst() *ActionSetTpDst {
+	obj := &ActionSetTpDst{
+		Action: NewAction(10),
+	}
+	return obj
+}
+func (self *ActionSetTpDst) GetActionName() string {
+	return "set_tp_dst"
+}
+
+func (self *ActionSetTpDst) GetActionFields() map[string]interface{} {
+	return map[string]interface{}{
+		"TpPort": self.TpPort,
+	}
+}
+
+func (self *ActionSetTpDst) MarshalJSON() ([]byte, error) {
+	jsonValue, err := json.Marshal(self.GetActionFields())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionSetTpSrc struct {
+	*Action
+	TpPort uint16
+}
+
+type IActionSetTpSrc interface {
+	goloxi.IAction
+	GetTpPort() uint16
+}
+
+func (self *ActionSetTpSrc) GetTpPort() uint16 {
+	return self.TpPort
+}
+
+func (self *ActionSetTpSrc) SetTpPort(v uint16) {
+	self.TpPort = v
+}
+
+func (self *ActionSetTpSrc) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.Action.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.TpPort))
+	encoder.Write(bytes.Repeat([]byte{0}, 2))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionSetTpSrc(parent *Action, decoder *goloxi.Decoder) (*ActionSetTpSrc, error) {
+	_actionsettpsrc := &ActionSetTpSrc{Action: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("ActionSetTpSrc packet too short: %d < 4", decoder.Length())
+	}
+	_actionsettpsrc.TpPort = uint16(decoder.ReadUint16())
+	decoder.Skip(2)
+	return _actionsettpsrc, nil
+}
+
+func NewActionSetTpSrc() *ActionSetTpSrc {
+	obj := &ActionSetTpSrc{
+		Action: NewAction(9),
+	}
+	return obj
+}
+func (self *ActionSetTpSrc) GetActionName() string {
+	return "set_tp_src"
+}
+
+func (self *ActionSetTpSrc) GetActionFields() map[string]interface{} {
+	return map[string]interface{}{
+		"TpPort": self.TpPort,
+	}
+}
+
+func (self *ActionSetTpSrc) MarshalJSON() ([]byte, error) {
+	jsonValue, err := json.Marshal(self.GetActionFields())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionSetVlanPcp struct {
+	*Action
+	VlanPcp uint8
+}
+
+type IActionSetVlanPcp interface {
+	goloxi.IAction
+	GetVlanPcp() uint8
+}
+
+func (self *ActionSetVlanPcp) GetVlanPcp() uint8 {
+	return self.VlanPcp
+}
+
+func (self *ActionSetVlanPcp) SetVlanPcp(v uint8) {
+	self.VlanPcp = v
+}
+
+func (self *ActionSetVlanPcp) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.Action.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint8(uint8(self.VlanPcp))
+	encoder.Write(bytes.Repeat([]byte{0}, 3))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionSetVlanPcp(parent *Action, decoder *goloxi.Decoder) (*ActionSetVlanPcp, error) {
+	_actionsetvlanpcp := &ActionSetVlanPcp{Action: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("ActionSetVlanPcp packet too short: %d < 4", decoder.Length())
+	}
+	_actionsetvlanpcp.VlanPcp = uint8(decoder.ReadByte())
+	decoder.Skip(3)
+	return _actionsetvlanpcp, nil
+}
+
+func NewActionSetVlanPcp() *ActionSetVlanPcp {
+	obj := &ActionSetVlanPcp{
+		Action: NewAction(2),
+	}
+	return obj
+}
+func (self *ActionSetVlanPcp) GetActionName() string {
+	return "set_vlan_pcp"
+}
+
+func (self *ActionSetVlanPcp) GetActionFields() map[string]interface{} {
+	return map[string]interface{}{
+		"VlanPcp": self.VlanPcp,
+	}
+}
+
+func (self *ActionSetVlanPcp) MarshalJSON() ([]byte, error) {
+	jsonValue, err := json.Marshal(self.GetActionFields())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionSetVlanVid struct {
+	*Action
+	VlanVid uint16
+}
+
+type IActionSetVlanVid interface {
+	goloxi.IAction
+	GetVlanVid() uint16
+}
+
+func (self *ActionSetVlanVid) GetVlanVid() uint16 {
+	return self.VlanVid
+}
+
+func (self *ActionSetVlanVid) SetVlanVid(v uint16) {
+	self.VlanVid = v
+}
+
+func (self *ActionSetVlanVid) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.Action.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.VlanVid))
+	encoder.Write(bytes.Repeat([]byte{0}, 2))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionSetVlanVid(parent *Action, decoder *goloxi.Decoder) (*ActionSetVlanVid, error) {
+	_actionsetvlanvid := &ActionSetVlanVid{Action: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("ActionSetVlanVid packet too short: %d < 4", decoder.Length())
+	}
+	_actionsetvlanvid.VlanVid = uint16(decoder.ReadUint16())
+	decoder.Skip(2)
+	return _actionsetvlanvid, nil
+}
+
+func NewActionSetVlanVid() *ActionSetVlanVid {
+	obj := &ActionSetVlanVid{
+		Action: NewAction(1),
+	}
+	return obj
+}
+func (self *ActionSetVlanVid) GetActionName() string {
+	return "set_vlan_vid"
+}
+
+func (self *ActionSetVlanVid) GetActionFields() map[string]interface{} {
+	return map[string]interface{}{
+		"VlanVid": self.VlanVid,
+	}
+}
+
+func (self *ActionSetVlanVid) MarshalJSON() ([]byte, error) {
+	jsonValue, err := json.Marshal(self.GetActionFields())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
+
+type ActionStripVlan struct {
+	*Action
+}
+
+type IActionStripVlan interface {
+	goloxi.IAction
+}
+
+func (self *ActionStripVlan) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.Action.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(bytes.Repeat([]byte{0}, 4))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionStripVlan(parent *Action, decoder *goloxi.Decoder) (*ActionStripVlan, error) {
+	_actionstripvlan := &ActionStripVlan{Action: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("ActionStripVlan packet too short: %d < 4", decoder.Length())
+	}
+	decoder.Skip(4)
+	return _actionstripvlan, nil
+}
+
+func NewActionStripVlan() *ActionStripVlan {
+	obj := &ActionStripVlan{
+		Action: NewAction(3),
+	}
+	return obj
+}
+func (self *ActionStripVlan) GetActionName() string {
+	return "strip_vlan"
+}
+
+func (self *ActionStripVlan) GetActionFields() map[string]interface{} {
+	return map[string]interface{}{}
+}
+
+func (self *ActionStripVlan) MarshalJSON() ([]byte, error) {
+	jsonValue, err := json.Marshal(self.GetActionFields())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Arguments\":%s}", self.GetActionName(), string(jsonValue))), nil
+}
diff --git a/of10/action_id.go b/of10/action_id.go
new file mode 100644
index 0000000..6693c2f
--- /dev/null
+++ b/of10/action_id.go
@@ -0,0 +1,2475 @@
+/*
+ * Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
+ * Copyright (c) 2011, 2012 Open Networking Foundation
+ * Copyright 2013, Big Switch Networks, Inc. This library was generated by the LoxiGen Compiler.
+ * Copyright 2018, Red Hat, Inc.
+ */
+// Automatically generated by LOXI from template module.go
+// Do not modify
+
+package of10
+
+import (
+	"encoding/binary"
+	"fmt"
+
+	"github.com/opencord/goloxi"
+)
+
+type ActionId struct {
+	Type uint16
+	Len  uint16
+}
+
+type IActionId interface {
+	goloxi.Serializable
+	GetType() uint16
+	GetLen() uint16
+}
+
+func (self *ActionId) GetType() uint16 {
+	return self.Type
+}
+
+func (self *ActionId) SetType(v uint16) {
+	self.Type = v
+}
+
+func (self *ActionId) GetLen() uint16 {
+	return self.Len
+}
+
+func (self *ActionId) SetLen(v uint16) {
+	self.Len = v
+}
+
+func (self *ActionId) Serialize(encoder *goloxi.Encoder) error {
+
+	encoder.PutUint16(uint16(self.Type))
+	encoder.PutUint16(uint16(self.Len))
+
+	return nil
+}
+
+func DecodeActionId(decoder *goloxi.Decoder) (IActionId, error) {
+	_actionid := &ActionId{}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("ActionId packet too short: %d < 4", decoder.Length())
+	}
+	_actionid.Type = uint16(decoder.ReadUint16())
+	_actionid.Len = uint16(decoder.ReadUint16())
+	oldDecoder := decoder
+	defer func() { decoder = oldDecoder }()
+	decoder = decoder.SliceDecoder(int(_actionid.Len), 2+2)
+
+	switch _actionid.Type {
+	case 0:
+		return DecodeActionIdOutput(_actionid, decoder)
+	case 1:
+		return DecodeActionIdSetVlanVid(_actionid, decoder)
+	case 2:
+		return DecodeActionIdSetVlanPcp(_actionid, decoder)
+	case 3:
+		return DecodeActionIdStripVlan(_actionid, decoder)
+	case 4:
+		return DecodeActionIdSetDlSrc(_actionid, decoder)
+	case 5:
+		return DecodeActionIdSetDlDst(_actionid, decoder)
+	case 6:
+		return DecodeActionIdSetNwSrc(_actionid, decoder)
+	case 7:
+		return DecodeActionIdSetNwDst(_actionid, decoder)
+	case 8:
+		return DecodeActionIdSetNwTos(_actionid, decoder)
+	case 9:
+		return DecodeActionIdSetTpSrc(_actionid, decoder)
+	case 10:
+		return DecodeActionIdSetTpDst(_actionid, decoder)
+	case 11:
+		return DecodeActionIdEnqueue(_actionid, decoder)
+	case 65535:
+		return DecodeActionIdExperimenter(_actionid, decoder)
+	default:
+		return _actionid, nil
+	}
+}
+
+func NewActionId(_type uint16) *ActionId {
+	obj := &ActionId{}
+	obj.Type = _type
+	return obj
+}
+
+type ActionIdExperimenter struct {
+	*ActionId
+	Experimenter uint32
+}
+
+type IActionIdExperimenter interface {
+	IActionId
+	GetExperimenter() uint32
+}
+
+func (self *ActionIdExperimenter) GetExperimenter() uint32 {
+	return self.Experimenter
+}
+
+func (self *ActionIdExperimenter) SetExperimenter(v uint32) {
+	self.Experimenter = v
+}
+
+func (self *ActionIdExperimenter) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.ActionId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Experimenter))
+
+	return nil
+}
+
+func DecodeActionIdExperimenter(parent *ActionId, decoder *goloxi.Decoder) (IActionIdExperimenter, error) {
+	_actionidexperimenter := &ActionIdExperimenter{ActionId: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("ActionIdExperimenter packet too short: %d < 4", decoder.Length())
+	}
+	_actionidexperimenter.Experimenter = uint32(decoder.ReadUint32())
+
+	switch _actionidexperimenter.Experimenter {
+	case 8992:
+		return DecodeActionIdNicira(_actionidexperimenter, decoder)
+	case 6035143:
+		return DecodeActionIdBsn(_actionidexperimenter, decoder)
+	default:
+		return _actionidexperimenter, nil
+	}
+}
+
+func NewActionIdExperimenter(_experimenter uint32) *ActionIdExperimenter {
+	obj := &ActionIdExperimenter{
+		ActionId: NewActionId(65535),
+	}
+	obj.Experimenter = _experimenter
+	return obj
+}
+
+type ActionIdBsn struct {
+	*ActionIdExperimenter
+	Subtype uint32
+}
+
+type IActionIdBsn interface {
+	IActionIdExperimenter
+	GetSubtype() uint32
+}
+
+func (self *ActionIdBsn) GetSubtype() uint32 {
+	return self.Subtype
+}
+
+func (self *ActionIdBsn) SetSubtype(v uint32) {
+	self.Subtype = v
+}
+
+func (self *ActionIdBsn) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.ActionIdExperimenter.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Subtype))
+
+	return nil
+}
+
+func DecodeActionIdBsn(parent *ActionIdExperimenter, decoder *goloxi.Decoder) (IActionIdBsn, error) {
+	_actionidbsn := &ActionIdBsn{ActionIdExperimenter: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("ActionIdBsn packet too short: %d < 4", decoder.Length())
+	}
+	_actionidbsn.Subtype = uint32(decoder.ReadUint32())
+
+	switch _actionidbsn.Subtype {
+	case 1:
+		return DecodeActionIdBsnMirror(_actionidbsn, decoder)
+	case 2:
+		return DecodeActionIdBsnSetTunnelDst(_actionidbsn, decoder)
+	case 4:
+		return DecodeActionIdBsnChecksum(_actionidbsn, decoder)
+	default:
+		return _actionidbsn, nil
+	}
+}
+
+func NewActionIdBsn(_subtype uint32) *ActionIdBsn {
+	obj := &ActionIdBsn{
+		ActionIdExperimenter: NewActionIdExperimenter(6035143),
+	}
+	obj.Subtype = _subtype
+	return obj
+}
+
+type ActionIdBsnChecksum struct {
+	*ActionIdBsn
+}
+
+type IActionIdBsnChecksum interface {
+	IActionIdBsn
+}
+
+func (self *ActionIdBsnChecksum) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionIdBsn.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionIdBsnChecksum(parent *ActionIdBsn, decoder *goloxi.Decoder) (*ActionIdBsnChecksum, error) {
+	_actionidbsnchecksum := &ActionIdBsnChecksum{ActionIdBsn: parent}
+	return _actionidbsnchecksum, nil
+}
+
+func NewActionIdBsnChecksum() *ActionIdBsnChecksum {
+	obj := &ActionIdBsnChecksum{
+		ActionIdBsn: NewActionIdBsn(4),
+	}
+	return obj
+}
+
+type ActionIdBsnMirror struct {
+	*ActionIdBsn
+}
+
+type IActionIdBsnMirror interface {
+	IActionIdBsn
+}
+
+func (self *ActionIdBsnMirror) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionIdBsn.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionIdBsnMirror(parent *ActionIdBsn, decoder *goloxi.Decoder) (*ActionIdBsnMirror, error) {
+	_actionidbsnmirror := &ActionIdBsnMirror{ActionIdBsn: parent}
+	return _actionidbsnmirror, nil
+}
+
+func NewActionIdBsnMirror() *ActionIdBsnMirror {
+	obj := &ActionIdBsnMirror{
+		ActionIdBsn: NewActionIdBsn(1),
+	}
+	return obj
+}
+
+type ActionIdBsnSetTunnelDst struct {
+	*ActionIdBsn
+}
+
+type IActionIdBsnSetTunnelDst interface {
+	IActionIdBsn
+}
+
+func (self *ActionIdBsnSetTunnelDst) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionIdBsn.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionIdBsnSetTunnelDst(parent *ActionIdBsn, decoder *goloxi.Decoder) (*ActionIdBsnSetTunnelDst, error) {
+	_actionidbsnsettunneldst := &ActionIdBsnSetTunnelDst{ActionIdBsn: parent}
+	return _actionidbsnsettunneldst, nil
+}
+
+func NewActionIdBsnSetTunnelDst() *ActionIdBsnSetTunnelDst {
+	obj := &ActionIdBsnSetTunnelDst{
+		ActionIdBsn: NewActionIdBsn(2),
+	}
+	return obj
+}
+
+type ActionIdEnqueue struct {
+	*ActionId
+}
+
+type IActionIdEnqueue interface {
+	IActionId
+}
+
+func (self *ActionIdEnqueue) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionId.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionIdEnqueue(parent *ActionId, decoder *goloxi.Decoder) (*ActionIdEnqueue, error) {
+	_actionidenqueue := &ActionIdEnqueue{ActionId: parent}
+	return _actionidenqueue, nil
+}
+
+func NewActionIdEnqueue() *ActionIdEnqueue {
+	obj := &ActionIdEnqueue{
+		ActionId: NewActionId(11),
+	}
+	return obj
+}
+
+type ActionIdNicira struct {
+	*ActionIdExperimenter
+	Subtype uint16
+}
+
+type IActionIdNicira interface {
+	IActionIdExperimenter
+	GetSubtype() uint16
+}
+
+func (self *ActionIdNicira) GetSubtype() uint16 {
+	return self.Subtype
+}
+
+func (self *ActionIdNicira) SetSubtype(v uint16) {
+	self.Subtype = v
+}
+
+func (self *ActionIdNicira) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.ActionIdExperimenter.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Subtype))
+
+	return nil
+}
+
+func DecodeActionIdNicira(parent *ActionIdExperimenter, decoder *goloxi.Decoder) (IActionIdNicira, error) {
+	_actionidnicira := &ActionIdNicira{ActionIdExperimenter: parent}
+	if decoder.Length() < 2 {
+		return nil, fmt.Errorf("ActionIdNicira packet too short: %d < 2", decoder.Length())
+	}
+	_actionidnicira.Subtype = uint16(decoder.ReadUint16())
+
+	switch _actionidnicira.Subtype {
+	case 1:
+		return DecodeActionIdNxResubmit(_actionidnicira, decoder)
+	case 2:
+		return DecodeActionIdNxSetTunnel(_actionidnicira, decoder)
+	case 4:
+		return DecodeActionIdNxSetQueue(_actionidnicira, decoder)
+	case 5:
+		return DecodeActionIdNxPopQueue(_actionidnicira, decoder)
+	case 6:
+		return DecodeActionIdNxRegMove(_actionidnicira, decoder)
+	case 7:
+		return DecodeActionIdNxRegLoad(_actionidnicira, decoder)
+	case 8:
+		return DecodeActionIdNxNote(_actionidnicira, decoder)
+	case 9:
+		return DecodeActionIdNxSetTunnel64(_actionidnicira, decoder)
+	case 10:
+		return DecodeActionIdNxMultipath(_actionidnicira, decoder)
+	case 12:
+		return DecodeActionIdNxBundle(_actionidnicira, decoder)
+	case 13:
+		return DecodeActionIdNxBundleLoadInPort(_actionidnicira, decoder)
+	case 14:
+		return DecodeActionIdResubmit(_actionidnicira, decoder)
+	case 15:
+		return DecodeActionIdNxOutputReg(_actionidnicira, decoder)
+	case 16:
+		return DecodeActionIdNxLearn(_actionidnicira, decoder)
+	case 17:
+		return DecodeActionIdNxExit(_actionidnicira, decoder)
+	case 18:
+		return DecodeActionIdNiciraDecTtl(_actionidnicira, decoder)
+	case 19:
+		return DecodeActionIdNxFinTimeout(_actionidnicira, decoder)
+	case 20:
+		return DecodeActionIdNxController(_actionidnicira, decoder)
+	case 21:
+		return DecodeActionIdNxDecTtlCntIds(_actionidnicira, decoder)
+	case 22:
+		return DecodeActionIdNxWriteMetadata(_actionidnicira, decoder)
+	case 23:
+		return DecodeActionIdNxPushMpls(_actionidnicira, decoder)
+	case 24:
+		return DecodeActionIdNxPopMpls(_actionidnicira, decoder)
+	case 25:
+		return DecodeActionIdNxSetMplsTtl(_actionidnicira, decoder)
+	case 26:
+		return DecodeActionIdNxDecMplsTtl(_actionidnicira, decoder)
+	case 27:
+		return DecodeActionIdNxStackPush(_actionidnicira, decoder)
+	case 28:
+		return DecodeActionIdNxStackPop(_actionidnicira, decoder)
+	case 29:
+		return DecodeActionIdNxSample(_actionidnicira, decoder)
+	case 30:
+		return DecodeActionIdNxSetMplsLabel(_actionidnicira, decoder)
+	case 31:
+		return DecodeActionIdNxSetMplsTc(_actionidnicira, decoder)
+	case 32:
+		return DecodeActionIdNxOutputReg2(_actionidnicira, decoder)
+	case 33:
+		return DecodeActionIdNxRegLoad2(_actionidnicira, decoder)
+	case 34:
+		return DecodeActionIdNxConjunction(_actionidnicira, decoder)
+	case 35:
+		return DecodeActionIdNxCt(_actionidnicira, decoder)
+	case 36:
+		return DecodeActionIdNxNat(_actionidnicira, decoder)
+	case 37:
+		return DecodeActionIdNxController2(_actionidnicira, decoder)
+	case 38:
+		return DecodeActionIdNxSample2(_actionidnicira, decoder)
+	case 39:
+		return DecodeActionIdNxOutputTrunc(_actionidnicira, decoder)
+	case 40:
+		return DecodeActionIdNxGroup(_actionidnicira, decoder)
+	case 41:
+		return DecodeActionIdNxSample3(_actionidnicira, decoder)
+	case 42:
+		return DecodeActionIdNxClone(_actionidnicira, decoder)
+	case 43:
+		return DecodeActionIdNxCtClear(_actionidnicira, decoder)
+	case 44:
+		return DecodeActionIdNxResubmitTableCt(_actionidnicira, decoder)
+	case 45:
+		return DecodeActionIdNxLearn2(_actionidnicira, decoder)
+	case 46:
+		return DecodeActionIdNxEncap(_actionidnicira, decoder)
+	case 47:
+		return DecodeActionIdNxDecap(_actionidnicira, decoder)
+	case 48:
+		return DecodeActionIdNxDecNshTtl(_actionidnicira, decoder)
+	case 254:
+		return DecodeActionIdNxDebugSlow(_actionidnicira, decoder)
+	case 255:
+		return DecodeActionIdNxDebugRecirc(_actionidnicira, decoder)
+	default:
+		return _actionidnicira, nil
+	}
+}
+
+func NewActionIdNicira(_subtype uint16) *ActionIdNicira {
+	obj := &ActionIdNicira{
+		ActionIdExperimenter: NewActionIdExperimenter(8992),
+	}
+	obj.Subtype = _subtype
+	return obj
+}
+
+type ActionIdNiciraDecTtl struct {
+	*ActionIdNicira
+}
+
+type IActionIdNiciraDecTtl interface {
+	IActionIdNicira
+}
+
+func (self *ActionIdNiciraDecTtl) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionIdNicira.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionIdNiciraDecTtl(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNiciraDecTtl, error) {
+	_actionidniciradecttl := &ActionIdNiciraDecTtl{ActionIdNicira: parent}
+	return _actionidniciradecttl, nil
+}
+
+func NewActionIdNiciraDecTtl() *ActionIdNiciraDecTtl {
+	obj := &ActionIdNiciraDecTtl{
+		ActionIdNicira: NewActionIdNicira(18),
+	}
+	return obj
+}
+
+type ActionIdNxBundle struct {
+	*ActionIdNicira
+}
+
+type IActionIdNxBundle interface {
+	IActionIdNicira
+}
+
+func (self *ActionIdNxBundle) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionIdNicira.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionIdNxBundle(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxBundle, error) {
+	_actionidnxbundle := &ActionIdNxBundle{ActionIdNicira: parent}
+	return _actionidnxbundle, nil
+}
+
+func NewActionIdNxBundle() *ActionIdNxBundle {
+	obj := &ActionIdNxBundle{
+		ActionIdNicira: NewActionIdNicira(12),
+	}
+	return obj
+}
+
+type ActionIdNxBundleLoad struct {
+	*ActionIdNicira
+	SlaveType ActionNxBundleSlaveType
+}
+
+type IActionIdNxBundleLoad interface {
+	IActionIdNicira
+	GetSlaveType() ActionNxBundleSlaveType
+}
+
+func (self *ActionIdNxBundleLoad) GetSlaveType() ActionNxBundleSlaveType {
+	return self.SlaveType
+}
+
+func (self *ActionIdNxBundleLoad) SetSlaveType(v ActionNxBundleSlaveType) {
+	self.SlaveType = v
+}
+
+func (self *ActionIdNxBundleLoad) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.ActionIdNicira.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.SlaveType))
+
+	return nil
+}
+
+func DecodeActionIdNxBundleLoad(parent *ActionIdNicira, decoder *goloxi.Decoder) (IActionIdNxBundleLoad, error) {
+	_actionidnxbundleload := &ActionIdNxBundleLoad{ActionIdNicira: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("ActionIdNxBundleLoad packet too short: %d < 4", decoder.Length())
+	}
+	_actionidnxbundleload.SlaveType = ActionNxBundleSlaveType(decoder.ReadUint32())
+	return _actionidnxbundleload, nil
+}
+
+func NewActionIdNxBundleLoad(_slave_type ActionNxBundleSlaveType) *ActionIdNxBundleLoad {
+	obj := &ActionIdNxBundleLoad{
+		ActionIdNicira: NewActionIdNicira(13),
+	}
+	obj.SlaveType = _slave_type
+	return obj
+}
+
+type ActionIdNxBundleLoadInPort struct {
+	*ActionIdNicira
+	SlaveType ActionNxBundleSlaveType
+	NSlaves   uint16
+}
+
+type IActionIdNxBundleLoadInPort interface {
+	IActionIdNicira
+	GetSlaveType() ActionNxBundleSlaveType
+	GetNSlaves() uint16
+}
+
+func (self *ActionIdNxBundleLoadInPort) GetSlaveType() ActionNxBundleSlaveType {
+	return self.SlaveType
+}
+
+func (self *ActionIdNxBundleLoadInPort) SetSlaveType(v ActionNxBundleSlaveType) {
+	self.SlaveType = v
+}
+
+func (self *ActionIdNxBundleLoadInPort) GetNSlaves() uint16 {
+	return self.NSlaves
+}
+
+func (self *ActionIdNxBundleLoadInPort) SetNSlaves(v uint16) {
+	self.NSlaves = v
+}
+
+func (self *ActionIdNxBundleLoadInPort) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionIdNicira.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.SlaveType))
+	encoder.PutUint16(uint16(self.NSlaves))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionIdNxBundleLoadInPort(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxBundleLoadInPort, error) {
+	_actionidnxbundleloadinport := &ActionIdNxBundleLoadInPort{ActionIdNicira: parent}
+	if decoder.Length() < 6 {
+		return nil, fmt.Errorf("ActionIdNxBundleLoadInPort packet too short: %d < 6", decoder.Length())
+	}
+	_actionidnxbundleloadinport.SlaveType = ActionNxBundleSlaveType(decoder.ReadUint32())
+	_actionidnxbundleloadinport.NSlaves = uint16(decoder.ReadUint16())
+	return _actionidnxbundleloadinport, nil
+}
+
+func NewActionIdNxBundleLoadInPort() *ActionIdNxBundleLoadInPort {
+	obj := &ActionIdNxBundleLoadInPort{
+		ActionIdNicira: NewActionIdNicira(13),
+	}
+	return obj
+}
+
+type ActionIdNxClone struct {
+	*ActionIdNicira
+}
+
+type IActionIdNxClone interface {
+	IActionIdNicira
+}
+
+func (self *ActionIdNxClone) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionIdNicira.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionIdNxClone(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxClone, error) {
+	_actionidnxclone := &ActionIdNxClone{ActionIdNicira: parent}
+	return _actionidnxclone, nil
+}
+
+func NewActionIdNxClone() *ActionIdNxClone {
+	obj := &ActionIdNxClone{
+		ActionIdNicira: NewActionIdNicira(42),
+	}
+	return obj
+}
+
+type ActionIdNxConjunction struct {
+	*ActionIdNicira
+}
+
+type IActionIdNxConjunction interface {
+	IActionIdNicira
+}
+
+func (self *ActionIdNxConjunction) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionIdNicira.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionIdNxConjunction(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxConjunction, error) {
+	_actionidnxconjunction := &ActionIdNxConjunction{ActionIdNicira: parent}
+	return _actionidnxconjunction, nil
+}
+
+func NewActionIdNxConjunction() *ActionIdNxConjunction {
+	obj := &ActionIdNxConjunction{
+		ActionIdNicira: NewActionIdNicira(34),
+	}
+	return obj
+}
+
+type ActionIdNxController struct {
+	*ActionIdNicira
+}
+
+type IActionIdNxController interface {
+	IActionIdNicira
+}
+
+func (self *ActionIdNxController) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionIdNicira.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionIdNxController(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxController, error) {
+	_actionidnxcontroller := &ActionIdNxController{ActionIdNicira: parent}
+	return _actionidnxcontroller, nil
+}
+
+func NewActionIdNxController() *ActionIdNxController {
+	obj := &ActionIdNxController{
+		ActionIdNicira: NewActionIdNicira(20),
+	}
+	return obj
+}
+
+type ActionIdNxController2 struct {
+	*ActionIdNicira
+}
+
+type IActionIdNxController2 interface {
+	IActionIdNicira
+}
+
+func (self *ActionIdNxController2) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionIdNicira.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionIdNxController2(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxController2, error) {
+	_actionidnxcontroller2 := &ActionIdNxController2{ActionIdNicira: parent}
+	return _actionidnxcontroller2, nil
+}
+
+func NewActionIdNxController2() *ActionIdNxController2 {
+	obj := &ActionIdNxController2{
+		ActionIdNicira: NewActionIdNicira(37),
+	}
+	return obj
+}
+
+type ActionIdNxCt struct {
+	*ActionIdNicira
+}
+
+type IActionIdNxCt interface {
+	IActionIdNicira
+}
+
+func (self *ActionIdNxCt) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionIdNicira.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionIdNxCt(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxCt, error) {
+	_actionidnxct := &ActionIdNxCt{ActionIdNicira: parent}
+	return _actionidnxct, nil
+}
+
+func NewActionIdNxCt() *ActionIdNxCt {
+	obj := &ActionIdNxCt{
+		ActionIdNicira: NewActionIdNicira(35),
+	}
+	return obj
+}
+
+type ActionIdNxCtClear struct {
+	*ActionIdNicira
+}
+
+type IActionIdNxCtClear interface {
+	IActionIdNicira
+}
+
+func (self *ActionIdNxCtClear) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionIdNicira.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionIdNxCtClear(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxCtClear, error) {
+	_actionidnxctclear := &ActionIdNxCtClear{ActionIdNicira: parent}
+	return _actionidnxctclear, nil
+}
+
+func NewActionIdNxCtClear() *ActionIdNxCtClear {
+	obj := &ActionIdNxCtClear{
+		ActionIdNicira: NewActionIdNicira(43),
+	}
+	return obj
+}
+
+type ActionIdNxDebugRecirc struct {
+	*ActionIdNicira
+}
+
+type IActionIdNxDebugRecirc interface {
+	IActionIdNicira
+}
+
+func (self *ActionIdNxDebugRecirc) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionIdNicira.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionIdNxDebugRecirc(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxDebugRecirc, error) {
+	_actionidnxdebugrecirc := &ActionIdNxDebugRecirc{ActionIdNicira: parent}
+	return _actionidnxdebugrecirc, nil
+}
+
+func NewActionIdNxDebugRecirc() *ActionIdNxDebugRecirc {
+	obj := &ActionIdNxDebugRecirc{
+		ActionIdNicira: NewActionIdNicira(255),
+	}
+	return obj
+}
+
+type ActionIdNxDebugSlow struct {
+	*ActionIdNicira
+}
+
+type IActionIdNxDebugSlow interface {
+	IActionIdNicira
+}
+
+func (self *ActionIdNxDebugSlow) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionIdNicira.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionIdNxDebugSlow(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxDebugSlow, error) {
+	_actionidnxdebugslow := &ActionIdNxDebugSlow{ActionIdNicira: parent}
+	return _actionidnxdebugslow, nil
+}
+
+func NewActionIdNxDebugSlow() *ActionIdNxDebugSlow {
+	obj := &ActionIdNxDebugSlow{
+		ActionIdNicira: NewActionIdNicira(254),
+	}
+	return obj
+}
+
+type ActionIdNxDecMplsTtl struct {
+	*ActionIdNicira
+}
+
+type IActionIdNxDecMplsTtl interface {
+	IActionIdNicira
+}
+
+func (self *ActionIdNxDecMplsTtl) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionIdNicira.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionIdNxDecMplsTtl(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxDecMplsTtl, error) {
+	_actionidnxdecmplsttl := &ActionIdNxDecMplsTtl{ActionIdNicira: parent}
+	return _actionidnxdecmplsttl, nil
+}
+
+func NewActionIdNxDecMplsTtl() *ActionIdNxDecMplsTtl {
+	obj := &ActionIdNxDecMplsTtl{
+		ActionIdNicira: NewActionIdNicira(26),
+	}
+	return obj
+}
+
+type ActionIdNxDecNshTtl struct {
+	*ActionIdNicira
+}
+
+type IActionIdNxDecNshTtl interface {
+	IActionIdNicira
+}
+
+func (self *ActionIdNxDecNshTtl) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionIdNicira.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionIdNxDecNshTtl(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxDecNshTtl, error) {
+	_actionidnxdecnshttl := &ActionIdNxDecNshTtl{ActionIdNicira: parent}
+	return _actionidnxdecnshttl, nil
+}
+
+func NewActionIdNxDecNshTtl() *ActionIdNxDecNshTtl {
+	obj := &ActionIdNxDecNshTtl{
+		ActionIdNicira: NewActionIdNicira(48),
+	}
+	return obj
+}
+
+type ActionIdNxDecTtlCntIds struct {
+	*ActionIdNicira
+}
+
+type IActionIdNxDecTtlCntIds interface {
+	IActionIdNicira
+}
+
+func (self *ActionIdNxDecTtlCntIds) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionIdNicira.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionIdNxDecTtlCntIds(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxDecTtlCntIds, error) {
+	_actionidnxdecttlcntids := &ActionIdNxDecTtlCntIds{ActionIdNicira: parent}
+	return _actionidnxdecttlcntids, nil
+}
+
+func NewActionIdNxDecTtlCntIds() *ActionIdNxDecTtlCntIds {
+	obj := &ActionIdNxDecTtlCntIds{
+		ActionIdNicira: NewActionIdNicira(21),
+	}
+	return obj
+}
+
+type ActionIdNxDecap struct {
+	*ActionIdNicira
+}
+
+type IActionIdNxDecap interface {
+	IActionIdNicira
+}
+
+func (self *ActionIdNxDecap) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionIdNicira.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionIdNxDecap(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxDecap, error) {
+	_actionidnxdecap := &ActionIdNxDecap{ActionIdNicira: parent}
+	return _actionidnxdecap, nil
+}
+
+func NewActionIdNxDecap() *ActionIdNxDecap {
+	obj := &ActionIdNxDecap{
+		ActionIdNicira: NewActionIdNicira(47),
+	}
+	return obj
+}
+
+type ActionIdNxEncap struct {
+	*ActionIdNicira
+}
+
+type IActionIdNxEncap interface {
+	IActionIdNicira
+}
+
+func (self *ActionIdNxEncap) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionIdNicira.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionIdNxEncap(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxEncap, error) {
+	_actionidnxencap := &ActionIdNxEncap{ActionIdNicira: parent}
+	return _actionidnxencap, nil
+}
+
+func NewActionIdNxEncap() *ActionIdNxEncap {
+	obj := &ActionIdNxEncap{
+		ActionIdNicira: NewActionIdNicira(46),
+	}
+	return obj
+}
+
+type ActionIdNxExit struct {
+	*ActionIdNicira
+}
+
+type IActionIdNxExit interface {
+	IActionIdNicira
+}
+
+func (self *ActionIdNxExit) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionIdNicira.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionIdNxExit(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxExit, error) {
+	_actionidnxexit := &ActionIdNxExit{ActionIdNicira: parent}
+	return _actionidnxexit, nil
+}
+
+func NewActionIdNxExit() *ActionIdNxExit {
+	obj := &ActionIdNxExit{
+		ActionIdNicira: NewActionIdNicira(17),
+	}
+	return obj
+}
+
+type ActionIdNxFinTimeout struct {
+	*ActionIdNicira
+}
+
+type IActionIdNxFinTimeout interface {
+	IActionIdNicira
+}
+
+func (self *ActionIdNxFinTimeout) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionIdNicira.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionIdNxFinTimeout(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxFinTimeout, error) {
+	_actionidnxfintimeout := &ActionIdNxFinTimeout{ActionIdNicira: parent}
+	return _actionidnxfintimeout, nil
+}
+
+func NewActionIdNxFinTimeout() *ActionIdNxFinTimeout {
+	obj := &ActionIdNxFinTimeout{
+		ActionIdNicira: NewActionIdNicira(19),
+	}
+	return obj
+}
+
+type ActionIdNxGroup struct {
+	*ActionIdNicira
+}
+
+type IActionIdNxGroup interface {
+	IActionIdNicira
+}
+
+func (self *ActionIdNxGroup) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionIdNicira.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionIdNxGroup(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxGroup, error) {
+	_actionidnxgroup := &ActionIdNxGroup{ActionIdNicira: parent}
+	return _actionidnxgroup, nil
+}
+
+func NewActionIdNxGroup() *ActionIdNxGroup {
+	obj := &ActionIdNxGroup{
+		ActionIdNicira: NewActionIdNicira(40),
+	}
+	return obj
+}
+
+type ActionIdNxLearn struct {
+	*ActionIdNicira
+}
+
+type IActionIdNxLearn interface {
+	IActionIdNicira
+}
+
+func (self *ActionIdNxLearn) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionIdNicira.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionIdNxLearn(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxLearn, error) {
+	_actionidnxlearn := &ActionIdNxLearn{ActionIdNicira: parent}
+	return _actionidnxlearn, nil
+}
+
+func NewActionIdNxLearn() *ActionIdNxLearn {
+	obj := &ActionIdNxLearn{
+		ActionIdNicira: NewActionIdNicira(16),
+	}
+	return obj
+}
+
+type ActionIdNxLearn2 struct {
+	*ActionIdNicira
+}
+
+type IActionIdNxLearn2 interface {
+	IActionIdNicira
+}
+
+func (self *ActionIdNxLearn2) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionIdNicira.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionIdNxLearn2(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxLearn2, error) {
+	_actionidnxlearn2 := &ActionIdNxLearn2{ActionIdNicira: parent}
+	return _actionidnxlearn2, nil
+}
+
+func NewActionIdNxLearn2() *ActionIdNxLearn2 {
+	obj := &ActionIdNxLearn2{
+		ActionIdNicira: NewActionIdNicira(45),
+	}
+	return obj
+}
+
+type ActionIdNxMultipath struct {
+	*ActionIdNicira
+}
+
+type IActionIdNxMultipath interface {
+	IActionIdNicira
+}
+
+func (self *ActionIdNxMultipath) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionIdNicira.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionIdNxMultipath(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxMultipath, error) {
+	_actionidnxmultipath := &ActionIdNxMultipath{ActionIdNicira: parent}
+	return _actionidnxmultipath, nil
+}
+
+func NewActionIdNxMultipath() *ActionIdNxMultipath {
+	obj := &ActionIdNxMultipath{
+		ActionIdNicira: NewActionIdNicira(10),
+	}
+	return obj
+}
+
+type ActionIdNxNat struct {
+	*ActionIdNicira
+}
+
+type IActionIdNxNat interface {
+	IActionIdNicira
+}
+
+func (self *ActionIdNxNat) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionIdNicira.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionIdNxNat(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxNat, error) {
+	_actionidnxnat := &ActionIdNxNat{ActionIdNicira: parent}
+	return _actionidnxnat, nil
+}
+
+func NewActionIdNxNat() *ActionIdNxNat {
+	obj := &ActionIdNxNat{
+		ActionIdNicira: NewActionIdNicira(36),
+	}
+	return obj
+}
+
+type ActionIdNxNote struct {
+	*ActionIdNicira
+}
+
+type IActionIdNxNote interface {
+	IActionIdNicira
+}
+
+func (self *ActionIdNxNote) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionIdNicira.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionIdNxNote(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxNote, error) {
+	_actionidnxnote := &ActionIdNxNote{ActionIdNicira: parent}
+	return _actionidnxnote, nil
+}
+
+func NewActionIdNxNote() *ActionIdNxNote {
+	obj := &ActionIdNxNote{
+		ActionIdNicira: NewActionIdNicira(8),
+	}
+	return obj
+}
+
+type ActionIdNxOutputReg struct {
+	*ActionIdNicira
+}
+
+type IActionIdNxOutputReg interface {
+	IActionIdNicira
+}
+
+func (self *ActionIdNxOutputReg) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionIdNicira.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionIdNxOutputReg(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxOutputReg, error) {
+	_actionidnxoutputreg := &ActionIdNxOutputReg{ActionIdNicira: parent}
+	return _actionidnxoutputreg, nil
+}
+
+func NewActionIdNxOutputReg() *ActionIdNxOutputReg {
+	obj := &ActionIdNxOutputReg{
+		ActionIdNicira: NewActionIdNicira(15),
+	}
+	return obj
+}
+
+type ActionIdNxOutputReg2 struct {
+	*ActionIdNicira
+}
+
+type IActionIdNxOutputReg2 interface {
+	IActionIdNicira
+}
+
+func (self *ActionIdNxOutputReg2) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionIdNicira.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionIdNxOutputReg2(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxOutputReg2, error) {
+	_actionidnxoutputreg2 := &ActionIdNxOutputReg2{ActionIdNicira: parent}
+	return _actionidnxoutputreg2, nil
+}
+
+func NewActionIdNxOutputReg2() *ActionIdNxOutputReg2 {
+	obj := &ActionIdNxOutputReg2{
+		ActionIdNicira: NewActionIdNicira(32),
+	}
+	return obj
+}
+
+type ActionIdNxOutputTrunc struct {
+	*ActionIdNicira
+}
+
+type IActionIdNxOutputTrunc interface {
+	IActionIdNicira
+}
+
+func (self *ActionIdNxOutputTrunc) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionIdNicira.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionIdNxOutputTrunc(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxOutputTrunc, error) {
+	_actionidnxoutputtrunc := &ActionIdNxOutputTrunc{ActionIdNicira: parent}
+	return _actionidnxoutputtrunc, nil
+}
+
+func NewActionIdNxOutputTrunc() *ActionIdNxOutputTrunc {
+	obj := &ActionIdNxOutputTrunc{
+		ActionIdNicira: NewActionIdNicira(39),
+	}
+	return obj
+}
+
+type ActionIdNxPopMpls struct {
+	*ActionIdNicira
+}
+
+type IActionIdNxPopMpls interface {
+	IActionIdNicira
+}
+
+func (self *ActionIdNxPopMpls) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionIdNicira.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionIdNxPopMpls(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxPopMpls, error) {
+	_actionidnxpopmpls := &ActionIdNxPopMpls{ActionIdNicira: parent}
+	return _actionidnxpopmpls, nil
+}
+
+func NewActionIdNxPopMpls() *ActionIdNxPopMpls {
+	obj := &ActionIdNxPopMpls{
+		ActionIdNicira: NewActionIdNicira(24),
+	}
+	return obj
+}
+
+type ActionIdNxPopQueue struct {
+	*ActionIdNicira
+}
+
+type IActionIdNxPopQueue interface {
+	IActionIdNicira
+}
+
+func (self *ActionIdNxPopQueue) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionIdNicira.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionIdNxPopQueue(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxPopQueue, error) {
+	_actionidnxpopqueue := &ActionIdNxPopQueue{ActionIdNicira: parent}
+	return _actionidnxpopqueue, nil
+}
+
+func NewActionIdNxPopQueue() *ActionIdNxPopQueue {
+	obj := &ActionIdNxPopQueue{
+		ActionIdNicira: NewActionIdNicira(5),
+	}
+	return obj
+}
+
+type ActionIdNxPushMpls struct {
+	*ActionIdNicira
+}
+
+type IActionIdNxPushMpls interface {
+	IActionIdNicira
+}
+
+func (self *ActionIdNxPushMpls) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionIdNicira.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionIdNxPushMpls(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxPushMpls, error) {
+	_actionidnxpushmpls := &ActionIdNxPushMpls{ActionIdNicira: parent}
+	return _actionidnxpushmpls, nil
+}
+
+func NewActionIdNxPushMpls() *ActionIdNxPushMpls {
+	obj := &ActionIdNxPushMpls{
+		ActionIdNicira: NewActionIdNicira(23),
+	}
+	return obj
+}
+
+type ActionIdNxRegLoad struct {
+	*ActionIdNicira
+}
+
+type IActionIdNxRegLoad interface {
+	IActionIdNicira
+}
+
+func (self *ActionIdNxRegLoad) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionIdNicira.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionIdNxRegLoad(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxRegLoad, error) {
+	_actionidnxregload := &ActionIdNxRegLoad{ActionIdNicira: parent}
+	return _actionidnxregload, nil
+}
+
+func NewActionIdNxRegLoad() *ActionIdNxRegLoad {
+	obj := &ActionIdNxRegLoad{
+		ActionIdNicira: NewActionIdNicira(7),
+	}
+	return obj
+}
+
+type ActionIdNxRegLoad2 struct {
+	*ActionIdNicira
+}
+
+type IActionIdNxRegLoad2 interface {
+	IActionIdNicira
+}
+
+func (self *ActionIdNxRegLoad2) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionIdNicira.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionIdNxRegLoad2(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxRegLoad2, error) {
+	_actionidnxregload2 := &ActionIdNxRegLoad2{ActionIdNicira: parent}
+	return _actionidnxregload2, nil
+}
+
+func NewActionIdNxRegLoad2() *ActionIdNxRegLoad2 {
+	obj := &ActionIdNxRegLoad2{
+		ActionIdNicira: NewActionIdNicira(33),
+	}
+	return obj
+}
+
+type ActionIdNxRegMove struct {
+	*ActionIdNicira
+}
+
+type IActionIdNxRegMove interface {
+	IActionIdNicira
+}
+
+func (self *ActionIdNxRegMove) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionIdNicira.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionIdNxRegMove(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxRegMove, error) {
+	_actionidnxregmove := &ActionIdNxRegMove{ActionIdNicira: parent}
+	return _actionidnxregmove, nil
+}
+
+func NewActionIdNxRegMove() *ActionIdNxRegMove {
+	obj := &ActionIdNxRegMove{
+		ActionIdNicira: NewActionIdNicira(6),
+	}
+	return obj
+}
+
+type ActionIdNxResubmit struct {
+	*ActionIdNicira
+}
+
+type IActionIdNxResubmit interface {
+	IActionIdNicira
+}
+
+func (self *ActionIdNxResubmit) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionIdNicira.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionIdNxResubmit(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxResubmit, error) {
+	_actionidnxresubmit := &ActionIdNxResubmit{ActionIdNicira: parent}
+	return _actionidnxresubmit, nil
+}
+
+func NewActionIdNxResubmit() *ActionIdNxResubmit {
+	obj := &ActionIdNxResubmit{
+		ActionIdNicira: NewActionIdNicira(1),
+	}
+	return obj
+}
+
+type ActionIdNxResubmitTable struct {
+	*ActionIdNicira
+}
+
+type IActionIdNxResubmitTable interface {
+	IActionIdNicira
+}
+
+func (self *ActionIdNxResubmitTable) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionIdNicira.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionIdNxResubmitTable(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxResubmitTable, error) {
+	_actionidnxresubmittable := &ActionIdNxResubmitTable{ActionIdNicira: parent}
+	return _actionidnxresubmittable, nil
+}
+
+func NewActionIdNxResubmitTable() *ActionIdNxResubmitTable {
+	obj := &ActionIdNxResubmitTable{
+		ActionIdNicira: NewActionIdNicira(14),
+	}
+	return obj
+}
+
+type ActionIdNxResubmitTableCt struct {
+	*ActionIdNicira
+}
+
+type IActionIdNxResubmitTableCt interface {
+	IActionIdNicira
+}
+
+func (self *ActionIdNxResubmitTableCt) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionIdNicira.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionIdNxResubmitTableCt(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxResubmitTableCt, error) {
+	_actionidnxresubmittablect := &ActionIdNxResubmitTableCt{ActionIdNicira: parent}
+	return _actionidnxresubmittablect, nil
+}
+
+func NewActionIdNxResubmitTableCt() *ActionIdNxResubmitTableCt {
+	obj := &ActionIdNxResubmitTableCt{
+		ActionIdNicira: NewActionIdNicira(44),
+	}
+	return obj
+}
+
+type ActionIdNxSample struct {
+	*ActionIdNicira
+}
+
+type IActionIdNxSample interface {
+	IActionIdNicira
+}
+
+func (self *ActionIdNxSample) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionIdNicira.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionIdNxSample(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxSample, error) {
+	_actionidnxsample := &ActionIdNxSample{ActionIdNicira: parent}
+	return _actionidnxsample, nil
+}
+
+func NewActionIdNxSample() *ActionIdNxSample {
+	obj := &ActionIdNxSample{
+		ActionIdNicira: NewActionIdNicira(29),
+	}
+	return obj
+}
+
+type ActionIdNxSample2 struct {
+	*ActionIdNicira
+}
+
+type IActionIdNxSample2 interface {
+	IActionIdNicira
+}
+
+func (self *ActionIdNxSample2) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionIdNicira.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionIdNxSample2(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxSample2, error) {
+	_actionidnxsample2 := &ActionIdNxSample2{ActionIdNicira: parent}
+	return _actionidnxsample2, nil
+}
+
+func NewActionIdNxSample2() *ActionIdNxSample2 {
+	obj := &ActionIdNxSample2{
+		ActionIdNicira: NewActionIdNicira(38),
+	}
+	return obj
+}
+
+type ActionIdNxSample3 struct {
+	*ActionIdNicira
+}
+
+type IActionIdNxSample3 interface {
+	IActionIdNicira
+}
+
+func (self *ActionIdNxSample3) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionIdNicira.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionIdNxSample3(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxSample3, error) {
+	_actionidnxsample3 := &ActionIdNxSample3{ActionIdNicira: parent}
+	return _actionidnxsample3, nil
+}
+
+func NewActionIdNxSample3() *ActionIdNxSample3 {
+	obj := &ActionIdNxSample3{
+		ActionIdNicira: NewActionIdNicira(41),
+	}
+	return obj
+}
+
+type ActionIdNxSetMplsLabel struct {
+	*ActionIdNicira
+}
+
+type IActionIdNxSetMplsLabel interface {
+	IActionIdNicira
+}
+
+func (self *ActionIdNxSetMplsLabel) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionIdNicira.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionIdNxSetMplsLabel(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxSetMplsLabel, error) {
+	_actionidnxsetmplslabel := &ActionIdNxSetMplsLabel{ActionIdNicira: parent}
+	return _actionidnxsetmplslabel, nil
+}
+
+func NewActionIdNxSetMplsLabel() *ActionIdNxSetMplsLabel {
+	obj := &ActionIdNxSetMplsLabel{
+		ActionIdNicira: NewActionIdNicira(30),
+	}
+	return obj
+}
+
+type ActionIdNxSetMplsTc struct {
+	*ActionIdNicira
+}
+
+type IActionIdNxSetMplsTc interface {
+	IActionIdNicira
+}
+
+func (self *ActionIdNxSetMplsTc) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionIdNicira.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionIdNxSetMplsTc(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxSetMplsTc, error) {
+	_actionidnxsetmplstc := &ActionIdNxSetMplsTc{ActionIdNicira: parent}
+	return _actionidnxsetmplstc, nil
+}
+
+func NewActionIdNxSetMplsTc() *ActionIdNxSetMplsTc {
+	obj := &ActionIdNxSetMplsTc{
+		ActionIdNicira: NewActionIdNicira(31),
+	}
+	return obj
+}
+
+type ActionIdNxSetMplsTtl struct {
+	*ActionIdNicira
+}
+
+type IActionIdNxSetMplsTtl interface {
+	IActionIdNicira
+}
+
+func (self *ActionIdNxSetMplsTtl) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionIdNicira.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionIdNxSetMplsTtl(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxSetMplsTtl, error) {
+	_actionidnxsetmplsttl := &ActionIdNxSetMplsTtl{ActionIdNicira: parent}
+	return _actionidnxsetmplsttl, nil
+}
+
+func NewActionIdNxSetMplsTtl() *ActionIdNxSetMplsTtl {
+	obj := &ActionIdNxSetMplsTtl{
+		ActionIdNicira: NewActionIdNicira(25),
+	}
+	return obj
+}
+
+type ActionIdNxSetQueue struct {
+	*ActionIdNicira
+}
+
+type IActionIdNxSetQueue interface {
+	IActionIdNicira
+}
+
+func (self *ActionIdNxSetQueue) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionIdNicira.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionIdNxSetQueue(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxSetQueue, error) {
+	_actionidnxsetqueue := &ActionIdNxSetQueue{ActionIdNicira: parent}
+	return _actionidnxsetqueue, nil
+}
+
+func NewActionIdNxSetQueue() *ActionIdNxSetQueue {
+	obj := &ActionIdNxSetQueue{
+		ActionIdNicira: NewActionIdNicira(4),
+	}
+	return obj
+}
+
+type ActionIdNxSetTunnel struct {
+	*ActionIdNicira
+}
+
+type IActionIdNxSetTunnel interface {
+	IActionIdNicira
+}
+
+func (self *ActionIdNxSetTunnel) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionIdNicira.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionIdNxSetTunnel(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxSetTunnel, error) {
+	_actionidnxsettunnel := &ActionIdNxSetTunnel{ActionIdNicira: parent}
+	return _actionidnxsettunnel, nil
+}
+
+func NewActionIdNxSetTunnel() *ActionIdNxSetTunnel {
+	obj := &ActionIdNxSetTunnel{
+		ActionIdNicira: NewActionIdNicira(2),
+	}
+	return obj
+}
+
+type ActionIdNxSetTunnel64 struct {
+	*ActionIdNicira
+}
+
+type IActionIdNxSetTunnel64 interface {
+	IActionIdNicira
+}
+
+func (self *ActionIdNxSetTunnel64) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionIdNicira.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionIdNxSetTunnel64(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxSetTunnel64, error) {
+	_actionidnxsettunnel64 := &ActionIdNxSetTunnel64{ActionIdNicira: parent}
+	return _actionidnxsettunnel64, nil
+}
+
+func NewActionIdNxSetTunnel64() *ActionIdNxSetTunnel64 {
+	obj := &ActionIdNxSetTunnel64{
+		ActionIdNicira: NewActionIdNicira(9),
+	}
+	return obj
+}
+
+type ActionIdNxStackPop struct {
+	*ActionIdNicira
+}
+
+type IActionIdNxStackPop interface {
+	IActionIdNicira
+}
+
+func (self *ActionIdNxStackPop) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionIdNicira.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionIdNxStackPop(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxStackPop, error) {
+	_actionidnxstackpop := &ActionIdNxStackPop{ActionIdNicira: parent}
+	return _actionidnxstackpop, nil
+}
+
+func NewActionIdNxStackPop() *ActionIdNxStackPop {
+	obj := &ActionIdNxStackPop{
+		ActionIdNicira: NewActionIdNicira(28),
+	}
+	return obj
+}
+
+type ActionIdNxStackPush struct {
+	*ActionIdNicira
+}
+
+type IActionIdNxStackPush interface {
+	IActionIdNicira
+}
+
+func (self *ActionIdNxStackPush) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionIdNicira.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionIdNxStackPush(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxStackPush, error) {
+	_actionidnxstackpush := &ActionIdNxStackPush{ActionIdNicira: parent}
+	return _actionidnxstackpush, nil
+}
+
+func NewActionIdNxStackPush() *ActionIdNxStackPush {
+	obj := &ActionIdNxStackPush{
+		ActionIdNicira: NewActionIdNicira(27),
+	}
+	return obj
+}
+
+type ActionIdNxWriteMetadata struct {
+	*ActionIdNicira
+}
+
+type IActionIdNxWriteMetadata interface {
+	IActionIdNicira
+}
+
+func (self *ActionIdNxWriteMetadata) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionIdNicira.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionIdNxWriteMetadata(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxWriteMetadata, error) {
+	_actionidnxwritemetadata := &ActionIdNxWriteMetadata{ActionIdNicira: parent}
+	return _actionidnxwritemetadata, nil
+}
+
+func NewActionIdNxWriteMetadata() *ActionIdNxWriteMetadata {
+	obj := &ActionIdNxWriteMetadata{
+		ActionIdNicira: NewActionIdNicira(22),
+	}
+	return obj
+}
+
+type ActionIdOutput struct {
+	*ActionId
+}
+
+type IActionIdOutput interface {
+	IActionId
+}
+
+func (self *ActionIdOutput) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionId.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionIdOutput(parent *ActionId, decoder *goloxi.Decoder) (*ActionIdOutput, error) {
+	_actionidoutput := &ActionIdOutput{ActionId: parent}
+	return _actionidoutput, nil
+}
+
+func NewActionIdOutput() *ActionIdOutput {
+	obj := &ActionIdOutput{
+		ActionId: NewActionId(0),
+	}
+	return obj
+}
+
+type ActionIdResubmit struct {
+	*ActionIdNicira
+}
+
+type IActionIdResubmit interface {
+	IActionIdNicira
+}
+
+func (self *ActionIdResubmit) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionIdNicira.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionIdResubmit(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdResubmit, error) {
+	_actionidresubmit := &ActionIdResubmit{ActionIdNicira: parent}
+	return _actionidresubmit, nil
+}
+
+func NewActionIdResubmit() *ActionIdResubmit {
+	obj := &ActionIdResubmit{
+		ActionIdNicira: NewActionIdNicira(14),
+	}
+	return obj
+}
+
+type ActionIdSetDlDst struct {
+	*ActionId
+}
+
+type IActionIdSetDlDst interface {
+	IActionId
+}
+
+func (self *ActionIdSetDlDst) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionId.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionIdSetDlDst(parent *ActionId, decoder *goloxi.Decoder) (*ActionIdSetDlDst, error) {
+	_actionidsetdldst := &ActionIdSetDlDst{ActionId: parent}
+	return _actionidsetdldst, nil
+}
+
+func NewActionIdSetDlDst() *ActionIdSetDlDst {
+	obj := &ActionIdSetDlDst{
+		ActionId: NewActionId(5),
+	}
+	return obj
+}
+
+type ActionIdSetDlSrc struct {
+	*ActionId
+}
+
+type IActionIdSetDlSrc interface {
+	IActionId
+}
+
+func (self *ActionIdSetDlSrc) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionId.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionIdSetDlSrc(parent *ActionId, decoder *goloxi.Decoder) (*ActionIdSetDlSrc, error) {
+	_actionidsetdlsrc := &ActionIdSetDlSrc{ActionId: parent}
+	return _actionidsetdlsrc, nil
+}
+
+func NewActionIdSetDlSrc() *ActionIdSetDlSrc {
+	obj := &ActionIdSetDlSrc{
+		ActionId: NewActionId(4),
+	}
+	return obj
+}
+
+type ActionIdSetNwDst struct {
+	*ActionId
+}
+
+type IActionIdSetNwDst interface {
+	IActionId
+}
+
+func (self *ActionIdSetNwDst) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionId.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionIdSetNwDst(parent *ActionId, decoder *goloxi.Decoder) (*ActionIdSetNwDst, error) {
+	_actionidsetnwdst := &ActionIdSetNwDst{ActionId: parent}
+	return _actionidsetnwdst, nil
+}
+
+func NewActionIdSetNwDst() *ActionIdSetNwDst {
+	obj := &ActionIdSetNwDst{
+		ActionId: NewActionId(7),
+	}
+	return obj
+}
+
+type ActionIdSetNwSrc struct {
+	*ActionId
+}
+
+type IActionIdSetNwSrc interface {
+	IActionId
+}
+
+func (self *ActionIdSetNwSrc) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionId.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionIdSetNwSrc(parent *ActionId, decoder *goloxi.Decoder) (*ActionIdSetNwSrc, error) {
+	_actionidsetnwsrc := &ActionIdSetNwSrc{ActionId: parent}
+	return _actionidsetnwsrc, nil
+}
+
+func NewActionIdSetNwSrc() *ActionIdSetNwSrc {
+	obj := &ActionIdSetNwSrc{
+		ActionId: NewActionId(6),
+	}
+	return obj
+}
+
+type ActionIdSetNwTos struct {
+	*ActionId
+}
+
+type IActionIdSetNwTos interface {
+	IActionId
+}
+
+func (self *ActionIdSetNwTos) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionId.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionIdSetNwTos(parent *ActionId, decoder *goloxi.Decoder) (*ActionIdSetNwTos, error) {
+	_actionidsetnwtos := &ActionIdSetNwTos{ActionId: parent}
+	return _actionidsetnwtos, nil
+}
+
+func NewActionIdSetNwTos() *ActionIdSetNwTos {
+	obj := &ActionIdSetNwTos{
+		ActionId: NewActionId(8),
+	}
+	return obj
+}
+
+type ActionIdSetTpDst struct {
+	*ActionId
+}
+
+type IActionIdSetTpDst interface {
+	IActionId
+}
+
+func (self *ActionIdSetTpDst) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionId.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionIdSetTpDst(parent *ActionId, decoder *goloxi.Decoder) (*ActionIdSetTpDst, error) {
+	_actionidsettpdst := &ActionIdSetTpDst{ActionId: parent}
+	return _actionidsettpdst, nil
+}
+
+func NewActionIdSetTpDst() *ActionIdSetTpDst {
+	obj := &ActionIdSetTpDst{
+		ActionId: NewActionId(10),
+	}
+	return obj
+}
+
+type ActionIdSetTpSrc struct {
+	*ActionId
+}
+
+type IActionIdSetTpSrc interface {
+	IActionId
+}
+
+func (self *ActionIdSetTpSrc) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionId.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionIdSetTpSrc(parent *ActionId, decoder *goloxi.Decoder) (*ActionIdSetTpSrc, error) {
+	_actionidsettpsrc := &ActionIdSetTpSrc{ActionId: parent}
+	return _actionidsettpsrc, nil
+}
+
+func NewActionIdSetTpSrc() *ActionIdSetTpSrc {
+	obj := &ActionIdSetTpSrc{
+		ActionId: NewActionId(9),
+	}
+	return obj
+}
+
+type ActionIdSetVlanPcp struct {
+	*ActionId
+}
+
+type IActionIdSetVlanPcp interface {
+	IActionId
+}
+
+func (self *ActionIdSetVlanPcp) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionId.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionIdSetVlanPcp(parent *ActionId, decoder *goloxi.Decoder) (*ActionIdSetVlanPcp, error) {
+	_actionidsetvlanpcp := &ActionIdSetVlanPcp{ActionId: parent}
+	return _actionidsetvlanpcp, nil
+}
+
+func NewActionIdSetVlanPcp() *ActionIdSetVlanPcp {
+	obj := &ActionIdSetVlanPcp{
+		ActionId: NewActionId(2),
+	}
+	return obj
+}
+
+type ActionIdSetVlanVid struct {
+	*ActionId
+}
+
+type IActionIdSetVlanVid interface {
+	IActionId
+}
+
+func (self *ActionIdSetVlanVid) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionId.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionIdSetVlanVid(parent *ActionId, decoder *goloxi.Decoder) (*ActionIdSetVlanVid, error) {
+	_actionidsetvlanvid := &ActionIdSetVlanVid{ActionId: parent}
+	return _actionidsetvlanvid, nil
+}
+
+func NewActionIdSetVlanVid() *ActionIdSetVlanVid {
+	obj := &ActionIdSetVlanVid{
+		ActionId: NewActionId(1),
+	}
+	return obj
+}
+
+type ActionIdStripVlan struct {
+	*ActionId
+}
+
+type IActionIdStripVlan interface {
+	IActionId
+}
+
+func (self *ActionIdStripVlan) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionId.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeActionIdStripVlan(parent *ActionId, decoder *goloxi.Decoder) (*ActionIdStripVlan, error) {
+	_actionidstripvlan := &ActionIdStripVlan{ActionId: parent}
+	return _actionidstripvlan, nil
+}
+
+func NewActionIdStripVlan() *ActionIdStripVlan {
+	obj := &ActionIdStripVlan{
+		ActionId: NewActionId(3),
+	}
+	return obj
+}
diff --git a/of10/common.go b/of10/common.go
new file mode 100644
index 0000000..fb45672
--- /dev/null
+++ b/of10/common.go
@@ -0,0 +1,16999 @@
+/*
+ * Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
+ * Copyright (c) 2011, 2012 Open Networking Foundation
+ * Copyright 2013, Big Switch Networks, Inc. This library was generated by the LoxiGen Compiler.
+ * Copyright 2018, Red Hat, Inc.
+ */
+// Automatically generated by LOXI from template module.go
+// Do not modify
+
+package of10
+
+import (
+	"bytes"
+	"encoding/binary"
+	"fmt"
+	"net"
+
+	"github.com/opencord/goloxi"
+)
+
+type OxmId struct {
+	TypeLen uint32
+}
+
+type IOxmId interface {
+	goloxi.Serializable
+	GetTypeLen() uint32
+	GetOXMName() string
+}
+
+func (self *OxmId) GetTypeLen() uint32 {
+	return self.TypeLen
+}
+
+func (self *OxmId) SetTypeLen(v uint32) {
+	self.TypeLen = v
+}
+
+func (self *OxmId) Serialize(encoder *goloxi.Encoder) error {
+
+	encoder.PutUint32(uint32(self.TypeLen))
+
+	return nil
+}
+
+func DecodeOxmId(decoder *goloxi.Decoder) (IOxmId, error) {
+	_oxmid := &OxmId{}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("OxmId packet too short: %d < 4", decoder.Length())
+	}
+	_oxmid.TypeLen = uint32(decoder.ReadUint32())
+
+	switch _oxmid.TypeLen {
+	case 126465:
+		return DecodeOxmIdConnTrackingNwProto(_oxmid, decoder)
+	case 7682:
+		return DecodeOxmIdArpOp(_oxmid, decoder)
+	case 2147500550:
+		return DecodeOxmIdIpv6NdTll(_oxmid, decoder)
+	case 84484:
+		return DecodeOxmIdConjId(_oxmid, decoder)
+	case 105976:
+		return DecodeOxmIdTunMetadata38Masked(_oxmid, decoder)
+	case 74246:
+		return DecodeOxmIdArpSha(_oxmid, decoder)
+	case 7169:
+		return DecodeOxmIdIcmpCode(_oxmid, decoder)
+	case 73736:
+		return DecodeOxmIdTunId(_oxmid, decoder)
+	case 2147484424:
+		return DecodeOxmIdInPhyPortMasked(_oxmid, decoder)
+	case 70408:
+		return DecodeOxmIdReg9Masked(_oxmid, decoder)
+	case 129026:
+		return DecodeOxmIdConnTrackingTpSrc(_oxmid, decoder)
+	case 127492:
+		return DecodeOxmIdConnTrackingNwDst(_oxmid, decoder)
+	case 2147484680:
+		return DecodeOxmIdMetadata(_oxmid, decoder)
+	case 128528:
+		return DecodeOxmIdConnTrackingIpv6Dst(_oxmid, decoder)
+	case 94332:
+		return DecodeOxmIdTunMetadata16(_oxmid, decoder)
+	case 129538:
+		return DecodeOxmIdConnTrackingTpDst(_oxmid, decoder)
+	case 108536:
+		return DecodeOxmIdTunMetadata43Masked(_oxmid, decoder)
+	case 106488:
+		return DecodeOxmIdTunMetadata39Masked(_oxmid, decoder)
+	case 112764:
+		return DecodeOxmIdTunMetadata52(_oxmid, decoder)
+	case 8708:
+		return DecodeOxmIdArpTpa(_oxmid, decoder)
+	case 2147498754:
+		return DecodeOxmIdIcmpv6TypeMasked(_oxmid, decoder)
+	case 89080:
+		return DecodeOxmIdTunMetadata5Masked(_oxmid, decoder)
+	case 94844:
+		return DecodeOxmIdTunMetadata17(_oxmid, decoder)
+	case 74758:
+		return DecodeOxmIdArpTha(_oxmid, decoder)
+	case 99964:
+		return DecodeOxmIdTunMetadata27(_oxmid, decoder)
+	case 67336:
+		return DecodeOxmIdReg3Masked(_oxmid, decoder)
+	case 115192:
+		return DecodeOxmIdTunMetadata56Masked(_oxmid, decoder)
+	case 71172:
+		return DecodeOxmIdReg11(_oxmid, decoder)
+	case 79364:
+		return DecodeOxmIdIpv6Label(_oxmid, decoder)
+	case 73480:
+		return DecodeOxmIdReg15Masked(_oxmid, decoder)
+	case 120068:
+		return DecodeOxmIdConnTrackingZoneMasked(_oxmid, decoder)
+	case 107512:
+		return DecodeOxmIdTunMetadata41Masked(_oxmid, decoder)
+	case 116348:
+		return DecodeOxmIdTunMetadata59(_oxmid, decoder)
+	case 89592:
+		return DecodeOxmIdTunMetadata6Masked(_oxmid, decoder)
+	case 110204:
+		return DecodeOxmIdTunMetadata47(_oxmid, decoder)
+	case 77830:
+		return DecodeOxmIdNdSll(_oxmid, decoder)
+	case 117372:
+		return DecodeOxmIdTunMetadata61(_oxmid, decoder)
+	case 2147489796:
+		return DecodeOxmIdIpv4Dst(_oxmid, decoder)
+	case 2147497988:
+		return DecodeOxmIdIpv6Flabel(_oxmid, decoder)
+	case 103928:
+		return DecodeOxmIdTunMetadata34Masked(_oxmid, decoder)
+	case 95868:
+		return DecodeOxmIdTunMetadata19(_oxmid, decoder)
+	case 2:
+		return DecodeOxmIdInPort(_oxmid, decoder)
+	case 74507:
+		return DecodeOxmIdArpShaMasked(_oxmid, decoder)
+	case 96892:
+		return DecodeOxmIdTunMetadata21(_oxmid, decoder)
+	case 108024:
+		return DecodeOxmIdTunMetadata42Masked(_oxmid, decoder)
+	case 129284:
+		return DecodeOxmIdConnTrackingTpSrcMasked(_oxmid, decoder)
+	case 112120:
+		return DecodeOxmIdTunMetadata50Masked(_oxmid, decoder)
+	case 2147484944:
+		return DecodeOxmIdMetadataMasked(_oxmid, decoder)
+	case 2147500812:
+		return DecodeOxmIdIpv6NdTllMasked(_oxmid, decoder)
+	case 78342:
+		return DecodeOxmIdNdTll(_oxmid, decoder)
+	case 2147486468:
+		return DecodeOxmIdEthTypeMasked(_oxmid, decoder)
+	case 96380:
+		return DecodeOxmIdTunMetadata20(_oxmid, decoder)
+	case 113276:
+		return DecodeOxmIdTunMetadata53(_oxmid, decoder)
+	case 92152:
+		return DecodeOxmIdTunMetadata11Masked(_oxmid, decoder)
+	case 129796:
+		return DecodeOxmIdConnTrackingTpDstMasked(_oxmid, decoder)
+	case 103548:
+		return DecodeOxmIdTunMetadata34(_oxmid, decoder)
+	case 120324:
+		return DecodeOxmIdConnTrackingMark(_oxmid, decoder)
+	case 118776:
+		return DecodeOxmIdTunMetadata63Masked(_oxmid, decoder)
+	case 90748:
+		return DecodeOxmIdTunMetadata9(_oxmid, decoder)
+	case 128016:
+		return DecodeOxmIdConnTrackingIpv6Src(_oxmid, decoder)
+	case 82946:
+		return DecodeOxmIdTcpFlags(_oxmid, decoder)
+	case 80897:
+		return DecodeOxmIdMplsTtl(_oxmid, decoder)
+	case 92664:
+		return DecodeOxmIdTunMetadata12Masked(_oxmid, decoder)
+	case 123408:
+		return DecodeOxmIdXxreg2(_oxmid, decoder)
+	case 2147499266:
+		return DecodeOxmIdIcmpv6CodeMasked(_oxmid, decoder)
+	case 2147489544:
+		return DecodeOxmIdIpv4SrcMasked(_oxmid, decoder)
+	case 2147487490:
+		return DecodeOxmIdVlanPcpMasked(_oxmid, decoder)
+	case 81412:
+		return DecodeOxmIdTunSrc(_oxmid, decoder)
+	case 5122:
+		return DecodeOxmIdTcpDst(_oxmid, decoder)
+	case 97404:
+		return DecodeOxmIdTunMetadata22(_oxmid, decoder)
+	case 1538:
+		return DecodeOxmIdEthType(_oxmid, decoder)
+	case 2561:
+		return DecodeOxmIdNwTos(_oxmid, decoder)
+	case 93176:
+		return DecodeOxmIdTunMetadata13Masked(_oxmid, decoder)
+	case 67848:
+		return DecodeOxmIdReg4Masked(_oxmid, decoder)
+	case 115704:
+		return DecodeOxmIdTunMetadata57Masked(_oxmid, decoder)
+	case 86140:
+		return DecodeOxmIdTunMetadata0(_oxmid, decoder)
+	case 65540:
+		return DecodeOxmIdReg0(_oxmid, decoder)
+	case 2147500038:
+		return DecodeOxmIdIpv6NdSll(_oxmid, decoder)
+	case 97916:
+		return DecodeOxmIdTunMetadata23(_oxmid, decoder)
+	case 2050:
+		return DecodeOxmIdVlanTci(_oxmid, decoder)
+	case 3073:
+		return DecodeOxmIdNwProto(_oxmid, decoder)
+	case 93688:
+		return DecodeOxmIdTunMetadata14Masked(_oxmid, decoder)
+	case 116860:
+		return DecodeOxmIdTunMetadata60(_oxmid, decoder)
+	case 2147487233:
+		return DecodeOxmIdVlanPcp(_oxmid, decoder)
+	case 2147484164:
+		return DecodeOxmIdInPhyPort(_oxmid, decoder)
+	case 2147486980:
+		return DecodeOxmIdVlanVidMasked(_oxmid, decoder)
+	case 113144:
+		return DecodeOxmIdTunMetadata52Masked(_oxmid, decoder)
+	case 82436:
+		return DecodeOxmIdPktMark(_oxmid, decoder)
+	case 121120:
+		return DecodeOxmIdConnTrackingLabelMasked(_oxmid, decoder)
+	case 98428:
+		return DecodeOxmIdTunMetadata24(_oxmid, decoder)
+	case 85505:
+		return DecodeOxmIdTunGbpFlags(_oxmid, decoder)
+	case 94200:
+		return DecodeOxmIdTunMetadata15Masked(_oxmid, decoder)
+	case 112632:
+		return DecodeOxmIdTunMetadata51Masked(_oxmid, decoder)
+	case 5378:
+		return DecodeOxmIdTcpDstMasked(_oxmid, decoder)
+	case 2147486722:
+		return DecodeOxmIdVlanVid(_oxmid, decoder)
+	case 66564:
+		return DecodeOxmIdReg2(_oxmid, decoder)
+	case 121632:
+		return DecodeOxmIdTunIpv6SrcMasked(_oxmid, decoder)
+	case 103416:
+		return DecodeOxmIdTunMetadata33Masked(_oxmid, decoder)
+	case 98940:
+		return DecodeOxmIdTunMetadata25(_oxmid, decoder)
+	case 84994:
+		return DecodeOxmIdTunGbpId(_oxmid, decoder)
+	case 2147487745:
+		return DecodeOxmIdIpDscp(_oxmid, decoder)
+	case 94712:
+		return DecodeOxmIdTunMetadata16Masked(_oxmid, decoder)
+	case 120848:
+		return DecodeOxmIdConnTrackingLabel(_oxmid, decoder)
+	case 109692:
+		return DecodeOxmIdTunMetadata46(_oxmid, decoder)
+	case 69896:
+		return DecodeOxmIdReg8Masked(_oxmid, decoder)
+	case 104060:
+		return DecodeOxmIdTunMetadata35(_oxmid, decoder)
+	case 71432:
+		return DecodeOxmIdReg11Masked(_oxmid, decoder)
+	case 110584:
+		return DecodeOxmIdTunMetadata47Masked(_oxmid, decoder)
+	case 79624:
+		return DecodeOxmIdIpv6LabelMasked(_oxmid, decoder)
+	case 122144:
+		return DecodeOxmIdTunIpv6DstMasked(_oxmid, decoder)
+	case 99452:
+		return DecodeOxmIdTunMetadata26(_oxmid, decoder)
+	case 109560:
+		return DecodeOxmIdTunMetadata45Masked(_oxmid, decoder)
+	case 95224:
+		return DecodeOxmIdTunMetadata17Masked(_oxmid, decoder)
+	case 121360:
+		return DecodeOxmIdTunIpv6Src(_oxmid, decoder)
+	case 85762:
+		return DecodeOxmIdTunGbpFlagsMasked(_oxmid, decoder)
+	case 2147490056:
+		return DecodeOxmIdIpv4DstMasked(_oxmid, decoder)
+	case 83972:
+		return DecodeOxmIdRecircId(_oxmid, decoder)
+	case 122656:
+		return DecodeOxmIdXxreg0Masked(_oxmid, decoder)
+	case 128800:
+		return DecodeOxmIdConnTrackingIpv6DstMasked(_oxmid, decoder)
+	case 118786:
+		return DecodeOxmIdTunFlags(_oxmid, decoder)
+	case 2147488769:
+		return DecodeOxmIdIpProto(_oxmid, decoder)
+	case 95736:
+		return DecodeOxmIdTunMetadata18Masked(_oxmid, decoder)
+	case 121872:
+		return DecodeOxmIdTunIpv6Dst(_oxmid, decoder)
+	case 81924:
+		return DecodeOxmIdTunDst(_oxmid, decoder)
+	case 68360:
+		return DecodeOxmIdReg5Masked(_oxmid, decoder)
+	case 518:
+		return DecodeOxmIdEthDst(_oxmid, decoder)
+	case 116216:
+		return DecodeOxmIdTunMetadata58Masked(_oxmid, decoder)
+	case 114300:
+		return DecodeOxmIdTunMetadata55(_oxmid, decoder)
+	case 68100:
+		return DecodeOxmIdReg5(_oxmid, decoder)
+	case 123168:
+		return DecodeOxmIdXxreg1Masked(_oxmid, decoder)
+	case 100476:
+		return DecodeOxmIdTunMetadata28(_oxmid, decoder)
+	case 4610:
+		return DecodeOxmIdTcpSrc(_oxmid, decoder)
+	case 123680:
+		return DecodeOxmIdXxreg2Masked(_oxmid, decoder)
+	case 96248:
+		return DecodeOxmIdTunMetadata19Masked(_oxmid, decoder)
+	case 122384:
+		return DecodeOxmIdXxreg0(_oxmid, decoder)
+	case 78091:
+		return DecodeOxmIdNdSllMasked(_oxmid, decoder)
+	case 1030:
+		return DecodeOxmIdEthSrc(_oxmid, decoder)
+	case 68612:
+		return DecodeOxmIdReg6(_oxmid, decoder)
+	case 107644:
+		return DecodeOxmIdTunMetadata42(_oxmid, decoder)
+	case 100988:
+		return DecodeOxmIdTunMetadata29(_oxmid, decoder)
+	case 119810:
+		return DecodeOxmIdConnTrackingZone(_oxmid, decoder)
+	case 96760:
+		return DecodeOxmIdTunMetadata20Masked(_oxmid, decoder)
+	case 85252:
+		return DecodeOxmIdTunGbpIdMasked(_oxmid, decoder)
+	case 78603:
+		return DecodeOxmIdNdTllMasked(_oxmid, decoder)
+	case 86652:
+		return DecodeOxmIdTunMetadata1(_oxmid, decoder)
+	case 69124:
+		return DecodeOxmIdReg7(_oxmid, decoder)
+	case 88188:
+		return DecodeOxmIdTunMetadata4(_oxmid, decoder)
+	case 3588:
+		return DecodeOxmIdIpSrc(_oxmid, decoder)
+	case 124192:
+		return DecodeOxmIdXxreg3Masked(_oxmid, decoder)
+	case 101500:
+		return DecodeOxmIdTunMetadata30(_oxmid, decoder)
+	case 5634:
+		return DecodeOxmIdUdpSrc(_oxmid, decoder)
+	case 127240:
+		return DecodeOxmIdConnTrackingNwSrcMasked(_oxmid, decoder)
+	case 6657:
+		return DecodeOxmIdIcmpType(_oxmid, decoder)
+	case 97272:
+		return DecodeOxmIdTunMetadata21Masked(_oxmid, decoder)
+	case 81672:
+		return DecodeOxmIdTunSrcMasked(_oxmid, decoder)
+	case 122896:
+		return DecodeOxmIdXxreg1(_oxmid, decoder)
+	case 2147489026:
+		return DecodeOxmIdIpProtoMasked(_oxmid, decoder)
+	case 2147483912:
+		return DecodeOxmIdInPortMasked(_oxmid, decoder)
+	case 4100:
+		return DecodeOxmIdIpDst(_oxmid, decoder)
+	case 65800:
+		return DecodeOxmIdReg0Masked(_oxmid, decoder)
+	case 75552:
+		return DecodeOxmIdIpv6SrcMasked(_oxmid, decoder)
+	case 102012:
+		return DecodeOxmIdTunMetadata31(_oxmid, decoder)
+	case 79106:
+		return DecodeOxmIdIpFragMasked(_oxmid, decoder)
+	case 2147501826:
+		return DecodeOxmIdMplsTcMasked(_oxmid, decoder)
+	case 8452:
+		return DecodeOxmIdArpSpaMasked(_oxmid, decoder)
+	case 97784:
+		return DecodeOxmIdTunMetadata22Masked(_oxmid, decoder)
+	case 1286:
+		return DecodeOxmIdEthSrcMasked(_oxmid, decoder)
+	case 66052:
+		return DecodeOxmIdReg1(_oxmid, decoder)
+	case 8968:
+		return DecodeOxmIdArpTpaMasked(_oxmid, decoder)
+	case 2147488514:
+		return DecodeOxmIdIpEcnMasked(_oxmid, decoder)
+	case 75019:
+		return DecodeOxmIdArpThaMasked(_oxmid, decoder)
+	case 2147500300:
+		return DecodeOxmIdIpv6NdSllMasked(_oxmid, decoder)
+	case 66312:
+		return DecodeOxmIdReg1Masked(_oxmid, decoder)
+	case 74000:
+		return DecodeOxmIdTunIdMasked(_oxmid, decoder)
+	case 102524:
+		return DecodeOxmIdTunMetadata32(_oxmid, decoder)
+	case 111228:
+		return DecodeOxmIdTunMetadata49(_oxmid, decoder)
+	case 88568:
+		return DecodeOxmIdTunMetadata4Masked(_oxmid, decoder)
+	case 2147499536:
+		return DecodeOxmIdIpv6NdTarget(_oxmid, decoder)
+	case 98296:
+		return DecodeOxmIdTunMetadata23Masked(_oxmid, decoder)
+	case 75280:
+		return DecodeOxmIdIpv6Src(_oxmid, decoder)
+	case 68872:
+		return DecodeOxmIdReg6Masked(_oxmid, decoder)
+	case 116728:
+		return DecodeOxmIdTunMetadata59Masked(_oxmid, decoder)
+	case 110072:
+		return DecodeOxmIdTunMetadata46Masked(_oxmid, decoder)
+	case 70660:
+		return DecodeOxmIdReg10(_oxmid, decoder)
+	case 76064:
+		return DecodeOxmIdIpv6DstMasked(_oxmid, decoder)
+	case 103036:
+		return DecodeOxmIdTunMetadata33(_oxmid, decoder)
+	case 107000:
+		return DecodeOxmIdTunMetadata40Masked(_oxmid, decoder)
+	case 110716:
+		return DecodeOxmIdTunMetadata48(_oxmid, decoder)
+	case 98808:
+		return DecodeOxmIdTunMetadata24Masked(_oxmid, decoder)
+	case 75792:
+		return DecodeOxmIdIpv6Dst(_oxmid, decoder)
+	case 2147501060:
+		return DecodeOxmIdMplsLabel(_oxmid, decoder)
+	case 73220:
+		return DecodeOxmIdReg15(_oxmid, decoder)
+	case 117884:
+		return DecodeOxmIdTunMetadata62(_oxmid, decoder)
+	case 83720:
+		return DecodeOxmIdDpHashMasked(_oxmid, decoder)
+	case 108156:
+		return DecodeOxmIdTunMetadata43(_oxmid, decoder)
+	case 87164:
+		return DecodeOxmIdTunMetadata2(_oxmid, decoder)
+	case 99320:
+		return DecodeOxmIdTunMetadata25Masked(_oxmid, decoder)
+	case 5892:
+		return DecodeOxmIdUdpSrcMasked(_oxmid, decoder)
+	case 113656:
+		return DecodeOxmIdTunMetadata53Masked(_oxmid, decoder)
+	case 69636:
+		return DecodeOxmIdReg8(_oxmid, decoder)
+	case 88700:
+		return DecodeOxmIdTunMetadata5(_oxmid, decoder)
+	case 113788:
+		return DecodeOxmIdTunMetadata54(_oxmid, decoder)
+	case 71684:
+		return DecodeOxmIdReg12(_oxmid, decoder)
+	case 77600:
+		return DecodeOxmIdNdTargetMasked(_oxmid, decoder)
+	case 87676:
+		return DecodeOxmIdTunMetadata3(_oxmid, decoder)
+	case 127752:
+		return DecodeOxmIdConnTrackingNwDstMasked(_oxmid, decoder)
+	case 99832:
+		return DecodeOxmIdTunMetadata26Masked(_oxmid, decoder)
+	case 114812:
+		return DecodeOxmIdTunMetadata56(_oxmid, decoder)
+	case 82184:
+		return DecodeOxmIdTunDstMasked(_oxmid, decoder)
+	case 90236:
+		return DecodeOxmIdTunMetadata8(_oxmid, decoder)
+	case 72196:
+		return DecodeOxmIdReg13(_oxmid, decoder)
+	case 104572:
+		return DecodeOxmIdTunMetadata36(_oxmid, decoder)
+	case 2147492354:
+		return DecodeOxmIdSctpSrc(_oxmid, decoder)
+	case 95356:
+		return DecodeOxmIdTunMetadata18(_oxmid, decoder)
+	case 2147493377:
+		return DecodeOxmIdIcmpv4Type(_oxmid, decoder)
+	case 100344:
+		return DecodeOxmIdTunMetadata27Masked(_oxmid, decoder)
+	case 77328:
+		return DecodeOxmIdNdTarget(_oxmid, decoder)
+	case 2147488257:
+		return DecodeOxmIdIpEcn(_oxmid, decoder)
+	case 118264:
+		return DecodeOxmIdTunMetadata62Masked(_oxmid, decoder)
+	case 90616:
+		return DecodeOxmIdTunMetadata8Masked(_oxmid, decoder)
+	case 72708:
+		return DecodeOxmIdReg14(_oxmid, decoder)
+	case 114680:
+		return DecodeOxmIdTunMetadata55Masked(_oxmid, decoder)
+	case 105084:
+		return DecodeOxmIdTunMetadata37(_oxmid, decoder)
+	case 91128:
+		return DecodeOxmIdTunMetadata9Masked(_oxmid, decoder)
+	case 111740:
+		return DecodeOxmIdTunMetadata50(_oxmid, decoder)
+	case 2147493889:
+		return DecodeOxmIdIcmpv4Code(_oxmid, decoder)
+	case 100856:
+		return DecodeOxmIdTunMetadata28Masked(_oxmid, decoder)
+	case 2308:
+		return DecodeOxmIdVlanTciMasked(_oxmid, decoder)
+	case 2147501320:
+		return DecodeOxmIdMplsLabelMasked(_oxmid, decoder)
+	case 779:
+		return DecodeOxmIdEthDstMasked(_oxmid, decoder)
+	case 2147493124:
+		return DecodeOxmIdSctpDstMasked(_oxmid, decoder)
+	case 69384:
+		return DecodeOxmIdReg7Masked(_oxmid, decoder)
+	case 117240:
+		return DecodeOxmIdTunMetadata60Masked(_oxmid, decoder)
+	case 3848:
+		return DecodeOxmIdIpSrcMasked(_oxmid, decoder)
+	case 128288:
+		return DecodeOxmIdConnTrackingIpv6SrcMasked(_oxmid, decoder)
+	case 92284:
+		return DecodeOxmIdTunMetadata12(_oxmid, decoder)
+	case 105596:
+		return DecodeOxmIdTunMetadata38(_oxmid, decoder)
+	case 4868:
+		return DecodeOxmIdTcpSrcMasked(_oxmid, decoder)
+	case 76289:
+		return DecodeOxmIdIcmpv6Type(_oxmid, decoder)
+	case 101368:
+		return DecodeOxmIdTunMetadata29Masked(_oxmid, decoder)
+	case 88056:
+		return DecodeOxmIdTunMetadata3Masked(_oxmid, decoder)
+	case 118396:
+		return DecodeOxmIdTunMetadata63(_oxmid, decoder)
+	case 2147493634:
+		return DecodeOxmIdIcmpv4TypeMasked(_oxmid, decoder)
+	case 4360:
+		return DecodeOxmIdIpDstMasked(_oxmid, decoder)
+	case 8196:
+		return DecodeOxmIdArpSpa(_oxmid, decoder)
+	case 108668:
+		return DecodeOxmIdTunMetadata44(_oxmid, decoder)
+	case 106108:
+		return DecodeOxmIdTunMetadata39(_oxmid, decoder)
+	case 76801:
+		return DecodeOxmIdIcmpv6Code(_oxmid, decoder)
+	case 101880:
+		return DecodeOxmIdTunMetadata30Masked(_oxmid, decoder)
+	case 114168:
+		return DecodeOxmIdTunMetadata54Masked(_oxmid, decoder)
+	case 2147494146:
+		return DecodeOxmIdIcmpv4CodeMasked(_oxmid, decoder)
+	case 70148:
+		return DecodeOxmIdReg9(_oxmid, decoder)
+	case 89212:
+		return DecodeOxmIdTunMetadata6(_oxmid, decoder)
+	case 119560:
+		return DecodeOxmIdConnTrackingStateMasked(_oxmid, decoder)
+	case 83204:
+		return DecodeOxmIdTcpFlagsMasked(_oxmid, decoder)
+	case 106620:
+		return DecodeOxmIdTunMetadata40(_oxmid, decoder)
+	case 6146:
+		return DecodeOxmIdUdpDst(_oxmid, decoder)
+	case 119044:
+		return DecodeOxmIdTunFlagsMasked(_oxmid, decoder)
+	case 102392:
+		return DecodeOxmIdTunMetadata31Masked(_oxmid, decoder)
+	case 115324:
+		return DecodeOxmIdTunMetadata57(_oxmid, decoder)
+	case 82696:
+		return DecodeOxmIdPktMarkMasked(_oxmid, decoder)
+	case 123920:
+		return DecodeOxmIdXxreg3(_oxmid, decoder)
+	case 70920:
+		return DecodeOxmIdReg10Masked(_oxmid, decoder)
+	case 107132:
+		return DecodeOxmIdTunMetadata41(_oxmid, decoder)
+	case 102904:
+		return DecodeOxmIdTunMetadata32Masked(_oxmid, decoder)
+	case 111096:
+		return DecodeOxmIdTunMetadata48Masked(_oxmid, decoder)
+	case 67076:
+		return DecodeOxmIdReg3(_oxmid, decoder)
+	case 120584:
+		return DecodeOxmIdConnTrackingMarkMasked(_oxmid, decoder)
+	case 91260:
+		return DecodeOxmIdTunMetadata10(_oxmid, decoder)
+	case 112252:
+		return DecodeOxmIdTunMetadata51(_oxmid, decoder)
+	case 87032:
+		return DecodeOxmIdTunMetadata1Masked(_oxmid, decoder)
+	case 2147501569:
+		return DecodeOxmIdMplsTc(_oxmid, decoder)
+	case 83460:
+		return DecodeOxmIdDpHash(_oxmid, decoder)
+	case 126722:
+		return DecodeOxmIdConnTrackingNwProtoMasked(_oxmid, decoder)
+	case 119300:
+		return DecodeOxmIdConnTrackingState(_oxmid, decoder)
+	case 117752:
+		return DecodeOxmIdTunMetadata61Masked(_oxmid, decoder)
+	case 71944:
+		return DecodeOxmIdReg12Masked(_oxmid, decoder)
+	case 2147499808:
+		return DecodeOxmIdIpv6NdTargetMasked(_oxmid, decoder)
+	case 91772:
+		return DecodeOxmIdTunMetadata11(_oxmid, decoder)
+	case 78849:
+		return DecodeOxmIdIpFrag(_oxmid, decoder)
+	case 87544:
+		return DecodeOxmIdTunMetadata2Masked(_oxmid, decoder)
+	case 90104:
+		return DecodeOxmIdTunMetadata7Masked(_oxmid, decoder)
+	case 72456:
+		return DecodeOxmIdReg13Masked(_oxmid, decoder)
+	case 109180:
+		return DecodeOxmIdTunMetadata45(_oxmid, decoder)
+	case 91640:
+		return DecodeOxmIdTunMetadata10Masked(_oxmid, decoder)
+	case 2147498248:
+		return DecodeOxmIdIpv6FlabelMasked(_oxmid, decoder)
+	case 2147492612:
+		return DecodeOxmIdSctpSrcMasked(_oxmid, decoder)
+	case 104440:
+		return DecodeOxmIdTunMetadata35Masked(_oxmid, decoder)
+	case 2147494660:
+		return DecodeOxmIdArpOpMasked(_oxmid, decoder)
+	case 66824:
+		return DecodeOxmIdReg2Masked(_oxmid, decoder)
+	case 109048:
+		return DecodeOxmIdTunMetadata44Masked(_oxmid, decoder)
+	case 2147492866:
+		return DecodeOxmIdSctpDst(_oxmid, decoder)
+	case 89724:
+		return DecodeOxmIdTunMetadata7(_oxmid, decoder)
+	case 72968:
+		return DecodeOxmIdReg14Masked(_oxmid, decoder)
+	case 92796:
+		return DecodeOxmIdTunMetadata13(_oxmid, decoder)
+	case 79873:
+		return DecodeOxmIdNwEcn(_oxmid, decoder)
+	case 104952:
+		return DecodeOxmIdTunMetadata36Masked(_oxmid, decoder)
+	case 115836:
+		return DecodeOxmIdTunMetadata58(_oxmid, decoder)
+	case 93820:
+		return DecodeOxmIdTunMetadata15(_oxmid, decoder)
+	case 2147489284:
+		return DecodeOxmIdIpv4Src(_oxmid, decoder)
+	case 93308:
+		return DecodeOxmIdTunMetadata14(_oxmid, decoder)
+	case 80385:
+		return DecodeOxmIdNwTtl(_oxmid, decoder)
+	case 105464:
+		return DecodeOxmIdTunMetadata37Masked(_oxmid, decoder)
+	case 111608:
+		return DecodeOxmIdTunMetadata49Masked(_oxmid, decoder)
+	case 2147488002:
+		return DecodeOxmIdIpDscpMasked(_oxmid, decoder)
+	case 86520:
+		return DecodeOxmIdTunMetadata0Masked(_oxmid, decoder)
+	case 67588:
+		return DecodeOxmIdReg4(_oxmid, decoder)
+	case 6404:
+		return DecodeOxmIdUdpDstMasked(_oxmid, decoder)
+	case 126980:
+		return DecodeOxmIdConnTrackingNwSrc(_oxmid, decoder)
+	default:
+		return _oxmid, nil
+	}
+}
+
+func NewOxmId(_type_len uint32) *OxmId {
+	obj := &OxmId{}
+	obj.TypeLen = _type_len
+	return obj
+}
+func (self *OxmId) GetOXMName() string {
+	return ""
+}
+
+func (self *OxmId) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type ActionNxBundleLoadSlave struct {
+	Port Port
+}
+
+type IActionNxBundleLoadSlave interface {
+	goloxi.Serializable
+	GetPort() Port
+}
+
+func (self *ActionNxBundleLoadSlave) GetPort() Port {
+	return self.Port
+}
+
+func (self *ActionNxBundleLoadSlave) SetPort(v Port) {
+	self.Port = v
+}
+
+func (self *ActionNxBundleLoadSlave) Serialize(encoder *goloxi.Encoder) error {
+
+	encoder.PutUint16(uint16(self.Port))
+
+	return nil
+}
+
+func DecodeActionNxBundleLoadSlave(decoder *goloxi.Decoder) (*ActionNxBundleLoadSlave, error) {
+	_actionnxbundleloadslave := &ActionNxBundleLoadSlave{}
+	if decoder.Length() < 2 {
+		return nil, fmt.Errorf("ActionNxBundleLoadSlave packet too short: %d < 2", decoder.Length())
+	}
+	_actionnxbundleloadslave.Port = Port(decoder.ReadUint16())
+	return _actionnxbundleloadslave, nil
+}
+
+func NewActionNxBundleLoadSlave() *ActionNxBundleLoadSlave {
+	obj := &ActionNxBundleLoadSlave{}
+	return obj
+}
+
+type ActionNxController2Property struct {
+	Type NxActionController2PropType
+}
+
+type IActionNxController2Property interface {
+	goloxi.Serializable
+	GetType() NxActionController2PropType
+}
+
+func (self *ActionNxController2Property) GetType() NxActionController2PropType {
+	return self.Type
+}
+
+func (self *ActionNxController2Property) SetType(v NxActionController2PropType) {
+	self.Type = v
+}
+
+func (self *ActionNxController2Property) Serialize(encoder *goloxi.Encoder) error {
+
+	encoder.PutUint16(uint16(self.Type))
+
+	return nil
+}
+
+func DecodeActionNxController2Property(decoder *goloxi.Decoder) (IActionNxController2Property, error) {
+	_actionnxcontroller2property := &ActionNxController2Property{}
+	if decoder.Length() < 2 {
+		return nil, fmt.Errorf("ActionNxController2Property packet too short: %d < 2", decoder.Length())
+	}
+	_actionnxcontroller2property.Type = NxActionController2PropType(decoder.ReadUint16())
+
+	switch _actionnxcontroller2property.Type {
+	case 0:
+		return DecodeActionNxController2PropertyMaxLen(_actionnxcontroller2property, decoder)
+	case 1:
+		return DecodeActionNxController2PropertyControllerId(_actionnxcontroller2property, decoder)
+	case 2:
+		return DecodeActionNxController2PropertyReason(_actionnxcontroller2property, decoder)
+	case 3:
+		return DecodeActionNxController2PropertyUserdata(_actionnxcontroller2property, decoder)
+	case 4:
+		return DecodeActionNxController2PropertyPause(_actionnxcontroller2property, decoder)
+	case 5:
+		return DecodeActionNxController2PropertyMeterId(_actionnxcontroller2property, decoder)
+	default:
+		return nil, fmt.Errorf("Invalid type '%d' for 'ActionNxController2Property'", _actionnxcontroller2property.Type)
+	}
+}
+
+func NewActionNxController2Property(_type NxActionController2PropType) *ActionNxController2Property {
+	obj := &ActionNxController2Property{}
+	obj.Type = _type
+	return obj
+}
+
+type ActionNxController2PropertyControllerId struct {
+	*ActionNxController2Property
+	ControllerId uint16
+}
+
+type IActionNxController2PropertyControllerId interface {
+	IActionNxController2Property
+	GetControllerId() uint16
+}
+
+func (self *ActionNxController2PropertyControllerId) GetControllerId() uint16 {
+	return self.ControllerId
+}
+
+func (self *ActionNxController2PropertyControllerId) SetControllerId(v uint16) {
+	self.ControllerId = v
+}
+
+func (self *ActionNxController2PropertyControllerId) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionNxController2Property.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.ControllerId))
+	length := len(encoder.Bytes()) - startIndex
+	alignedLength := ((length + 7) / 8 * 8)
+
+	encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
+
+	return nil
+}
+
+func DecodeActionNxController2PropertyControllerId(parent *ActionNxController2Property, decoder *goloxi.Decoder) (*ActionNxController2PropertyControllerId, error) {
+	_actionnxcontroller2propertycontrollerid := &ActionNxController2PropertyControllerId{ActionNxController2Property: parent}
+	if decoder.Length() < 2 {
+		return nil, fmt.Errorf("ActionNxController2PropertyControllerId packet too short: %d < 2", decoder.Length())
+	}
+	defer decoder.SkipAlign()
+
+	_actionnxcontroller2propertycontrollerid.ControllerId = uint16(decoder.ReadUint16())
+	return _actionnxcontroller2propertycontrollerid, nil
+}
+
+func NewActionNxController2PropertyControllerId() *ActionNxController2PropertyControllerId {
+	obj := &ActionNxController2PropertyControllerId{
+		ActionNxController2Property: NewActionNxController2Property(1),
+	}
+	return obj
+}
+
+type ActionNxController2PropertyMaxLen struct {
+	*ActionNxController2Property
+	MaxLen uint16
+}
+
+type IActionNxController2PropertyMaxLen interface {
+	IActionNxController2Property
+	GetMaxLen() uint16
+}
+
+func (self *ActionNxController2PropertyMaxLen) GetMaxLen() uint16 {
+	return self.MaxLen
+}
+
+func (self *ActionNxController2PropertyMaxLen) SetMaxLen(v uint16) {
+	self.MaxLen = v
+}
+
+func (self *ActionNxController2PropertyMaxLen) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionNxController2Property.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.MaxLen))
+	length := len(encoder.Bytes()) - startIndex
+	alignedLength := ((length + 7) / 8 * 8)
+
+	encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
+
+	return nil
+}
+
+func DecodeActionNxController2PropertyMaxLen(parent *ActionNxController2Property, decoder *goloxi.Decoder) (*ActionNxController2PropertyMaxLen, error) {
+	_actionnxcontroller2propertymaxlen := &ActionNxController2PropertyMaxLen{ActionNxController2Property: parent}
+	if decoder.Length() < 2 {
+		return nil, fmt.Errorf("ActionNxController2PropertyMaxLen packet too short: %d < 2", decoder.Length())
+	}
+	defer decoder.SkipAlign()
+
+	_actionnxcontroller2propertymaxlen.MaxLen = uint16(decoder.ReadUint16())
+	return _actionnxcontroller2propertymaxlen, nil
+}
+
+func NewActionNxController2PropertyMaxLen() *ActionNxController2PropertyMaxLen {
+	obj := &ActionNxController2PropertyMaxLen{
+		ActionNxController2Property: NewActionNxController2Property(0),
+	}
+	return obj
+}
+
+type ActionNxController2PropertyMeterId struct {
+	*ActionNxController2Property
+	MeterId uint32
+}
+
+type IActionNxController2PropertyMeterId interface {
+	IActionNxController2Property
+	GetMeterId() uint32
+}
+
+func (self *ActionNxController2PropertyMeterId) GetMeterId() uint32 {
+	return self.MeterId
+}
+
+func (self *ActionNxController2PropertyMeterId) SetMeterId(v uint32) {
+	self.MeterId = v
+}
+
+func (self *ActionNxController2PropertyMeterId) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionNxController2Property.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.MeterId))
+	length := len(encoder.Bytes()) - startIndex
+	alignedLength := ((length + 7) / 8 * 8)
+
+	encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
+
+	return nil
+}
+
+func DecodeActionNxController2PropertyMeterId(parent *ActionNxController2Property, decoder *goloxi.Decoder) (*ActionNxController2PropertyMeterId, error) {
+	_actionnxcontroller2propertymeterid := &ActionNxController2PropertyMeterId{ActionNxController2Property: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("ActionNxController2PropertyMeterId packet too short: %d < 4", decoder.Length())
+	}
+	defer decoder.SkipAlign()
+
+	_actionnxcontroller2propertymeterid.MeterId = uint32(decoder.ReadUint32())
+	return _actionnxcontroller2propertymeterid, nil
+}
+
+func NewActionNxController2PropertyMeterId() *ActionNxController2PropertyMeterId {
+	obj := &ActionNxController2PropertyMeterId{
+		ActionNxController2Property: NewActionNxController2Property(5),
+	}
+	return obj
+}
+
+type ActionNxController2PropertyPause struct {
+	*ActionNxController2Property
+}
+
+type IActionNxController2PropertyPause interface {
+	IActionNxController2Property
+}
+
+func (self *ActionNxController2PropertyPause) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionNxController2Property.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+	alignedLength := ((length + 7) / 8 * 8)
+
+	encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
+
+	return nil
+}
+
+func DecodeActionNxController2PropertyPause(parent *ActionNxController2Property, decoder *goloxi.Decoder) (*ActionNxController2PropertyPause, error) {
+	_actionnxcontroller2propertypause := &ActionNxController2PropertyPause{ActionNxController2Property: parent}
+	defer decoder.SkipAlign()
+
+	return _actionnxcontroller2propertypause, nil
+}
+
+func NewActionNxController2PropertyPause() *ActionNxController2PropertyPause {
+	obj := &ActionNxController2PropertyPause{
+		ActionNxController2Property: NewActionNxController2Property(4),
+	}
+	return obj
+}
+
+type ActionNxController2PropertyReason struct {
+	*ActionNxController2Property
+	Reason PacketInReason
+}
+
+type IActionNxController2PropertyReason interface {
+	IActionNxController2Property
+	GetReason() PacketInReason
+}
+
+func (self *ActionNxController2PropertyReason) GetReason() PacketInReason {
+	return self.Reason
+}
+
+func (self *ActionNxController2PropertyReason) SetReason(v PacketInReason) {
+	self.Reason = v
+}
+
+func (self *ActionNxController2PropertyReason) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionNxController2Property.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint8(uint8(self.Reason))
+	length := len(encoder.Bytes()) - startIndex
+	alignedLength := ((length + 7) / 8 * 8)
+
+	encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
+
+	return nil
+}
+
+func DecodeActionNxController2PropertyReason(parent *ActionNxController2Property, decoder *goloxi.Decoder) (*ActionNxController2PropertyReason, error) {
+	_actionnxcontroller2propertyreason := &ActionNxController2PropertyReason{ActionNxController2Property: parent}
+	if decoder.Length() < 1 {
+		return nil, fmt.Errorf("ActionNxController2PropertyReason packet too short: %d < 1", decoder.Length())
+	}
+	defer decoder.SkipAlign()
+
+	_actionnxcontroller2propertyreason.Reason = PacketInReason(decoder.ReadByte())
+	return _actionnxcontroller2propertyreason, nil
+}
+
+func NewActionNxController2PropertyReason() *ActionNxController2PropertyReason {
+	obj := &ActionNxController2PropertyReason{
+		ActionNxController2Property: NewActionNxController2Property(2),
+	}
+	return obj
+}
+
+type ActionNxController2PropertyUserdata struct {
+	*ActionNxController2Property
+	Length   uint16
+	Userdata []byte
+}
+
+type IActionNxController2PropertyUserdata interface {
+	IActionNxController2Property
+	GetLength() uint16
+	GetUserdata() []byte
+}
+
+func (self *ActionNxController2PropertyUserdata) GetLength() uint16 {
+	return self.Length
+}
+
+func (self *ActionNxController2PropertyUserdata) SetLength(v uint16) {
+	self.Length = v
+}
+
+func (self *ActionNxController2PropertyUserdata) GetUserdata() []byte {
+	return self.Userdata
+}
+
+func (self *ActionNxController2PropertyUserdata) SetUserdata(v []byte) {
+	self.Userdata = v
+}
+
+func (self *ActionNxController2PropertyUserdata) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ActionNxController2Property.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Length))
+	encoder.Write(self.Userdata)
+	length := len(encoder.Bytes()) - startIndex
+	alignedLength := ((length + 7) / 8 * 8)
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
+
+	return nil
+}
+
+func DecodeActionNxController2PropertyUserdata(parent *ActionNxController2Property, decoder *goloxi.Decoder) (*ActionNxController2PropertyUserdata, error) {
+	_actionnxcontroller2propertyuserdata := &ActionNxController2PropertyUserdata{ActionNxController2Property: parent}
+	if decoder.Length() < 2 {
+		return nil, fmt.Errorf("ActionNxController2PropertyUserdata packet too short: %d < 2", decoder.Length())
+	}
+	defer decoder.SkipAlign()
+
+	_actionnxcontroller2propertyuserdata.Length = uint16(decoder.ReadUint16())
+	oldDecoder := decoder
+	defer func() { decoder = oldDecoder }()
+	decoder = decoder.SliceDecoder(int(((_actionnxcontroller2propertyuserdata.Length)+7)/8*8), 2+2)
+	_actionnxcontroller2propertyuserdata.Userdata = decoder.Read(int(decoder.Length()))
+	return _actionnxcontroller2propertyuserdata, nil
+}
+
+func NewActionNxController2PropertyUserdata() *ActionNxController2PropertyUserdata {
+	obj := &ActionNxController2PropertyUserdata{
+		ActionNxController2Property: NewActionNxController2Property(3),
+	}
+	return obj
+}
+
+type BsnInterface struct {
+	HwAddr      net.HardwareAddr
+	Name        string
+	Ipv4Addr    net.IP
+	Ipv4Netmask net.IP
+}
+
+type IBsnInterface interface {
+	goloxi.Serializable
+	GetHwAddr() net.HardwareAddr
+	GetName() string
+	GetIpv4Addr() net.IP
+	GetIpv4Netmask() net.IP
+}
+
+func (self *BsnInterface) GetHwAddr() net.HardwareAddr {
+	return self.HwAddr
+}
+
+func (self *BsnInterface) SetHwAddr(v net.HardwareAddr) {
+	self.HwAddr = v
+}
+
+func (self *BsnInterface) GetName() string {
+	return self.Name
+}
+
+func (self *BsnInterface) SetName(v string) {
+	self.Name = v
+}
+
+func (self *BsnInterface) GetIpv4Addr() net.IP {
+	return self.Ipv4Addr
+}
+
+func (self *BsnInterface) SetIpv4Addr(v net.IP) {
+	self.Ipv4Addr = v
+}
+
+func (self *BsnInterface) GetIpv4Netmask() net.IP {
+	return self.Ipv4Netmask
+}
+
+func (self *BsnInterface) SetIpv4Netmask(v net.IP) {
+	self.Ipv4Netmask = v
+}
+
+func (self *BsnInterface) Serialize(encoder *goloxi.Encoder) error {
+
+	encoder.Write(self.HwAddr)
+	encoder.Write(bytes.Repeat([]byte{0}, 2))
+	encoder.Write([]byte(self.Name))
+	encoder.Write(self.Ipv4Addr.To4())
+	encoder.Write(self.Ipv4Netmask.To4())
+
+	return nil
+}
+
+func DecodeBsnInterface(decoder *goloxi.Decoder) (*BsnInterface, error) {
+	_bsninterface := &BsnInterface{}
+	if decoder.Length() < 32 {
+		return nil, fmt.Errorf("BsnInterface packet too short: %d < 32", decoder.Length())
+	}
+	_bsninterface.HwAddr = net.HardwareAddr(decoder.Read(6))
+	decoder.Skip(2)
+	_bsninterface.Name = string(bytes.Trim(decoder.Read(16), "\x00"))
+	_bsninterface.Ipv4Addr = net.IP(decoder.Read(4))
+	_bsninterface.Ipv4Netmask = net.IP(decoder.Read(4))
+	return _bsninterface, nil
+}
+
+func NewBsnInterface() *BsnInterface {
+	obj := &BsnInterface{}
+	return obj
+}
+
+type BsnVport struct {
+	Type   uint16
+	Length uint16
+}
+
+type IBsnVport interface {
+	goloxi.Serializable
+	GetType() uint16
+	GetLength() uint16
+}
+
+func (self *BsnVport) GetType() uint16 {
+	return self.Type
+}
+
+func (self *BsnVport) SetType(v uint16) {
+	self.Type = v
+}
+
+func (self *BsnVport) GetLength() uint16 {
+	return self.Length
+}
+
+func (self *BsnVport) SetLength(v uint16) {
+	self.Length = v
+}
+
+func (self *BsnVport) Serialize(encoder *goloxi.Encoder) error {
+
+	encoder.PutUint16(uint16(self.Type))
+	encoder.PutUint16(uint16(self.Length))
+
+	return nil
+}
+func (self *BsnVport) Decode(decoder *goloxi.Decoder) error {
+	if decoder.Length() < 4 {
+		return fmt.Errorf("BsnVport packet too short: %d < 4", decoder.Length())
+	}
+
+	self.Type = uint16(decoder.ReadUint16())
+	self.Length = uint16(decoder.ReadUint16())
+	oldDecoder := decoder
+	defer func() { decoder = oldDecoder }()
+	decoder = decoder.SliceDecoder(int(self.Length), 2+2)
+
+	return nil
+}
+
+func NewBsnVport(_type uint16) *BsnVport {
+	obj := &BsnVport{}
+	obj.Type = _type
+	return obj
+}
+
+type BsnVportL2Gre struct {
+	*BsnVport
+	Flags          BsnVportL2GreFlags
+	PortNo         Port
+	LoopbackPortNo Port
+	LocalMac       net.HardwareAddr
+	NhMac          net.HardwareAddr
+	SrcIp          net.IP
+	DstIp          net.IP
+	Dscp           uint8
+	Ttl            uint8
+	Vpn            uint32
+	RateLimit      uint32
+	IfName         string
+}
+
+type IBsnVportL2Gre interface {
+	IBsnVport
+	GetFlags() BsnVportL2GreFlags
+	GetPortNo() Port
+	GetLoopbackPortNo() Port
+	GetLocalMac() net.HardwareAddr
+	GetNhMac() net.HardwareAddr
+	GetSrcIp() net.IP
+	GetDstIp() net.IP
+	GetDscp() uint8
+	GetTtl() uint8
+	GetVpn() uint32
+	GetRateLimit() uint32
+	GetIfName() string
+}
+
+func (self *BsnVportL2Gre) GetFlags() BsnVportL2GreFlags {
+	return self.Flags
+}
+
+func (self *BsnVportL2Gre) SetFlags(v BsnVportL2GreFlags) {
+	self.Flags = v
+}
+
+func (self *BsnVportL2Gre) GetPortNo() Port {
+	return self.PortNo
+}
+
+func (self *BsnVportL2Gre) SetPortNo(v Port) {
+	self.PortNo = v
+}
+
+func (self *BsnVportL2Gre) GetLoopbackPortNo() Port {
+	return self.LoopbackPortNo
+}
+
+func (self *BsnVportL2Gre) SetLoopbackPortNo(v Port) {
+	self.LoopbackPortNo = v
+}
+
+func (self *BsnVportL2Gre) GetLocalMac() net.HardwareAddr {
+	return self.LocalMac
+}
+
+func (self *BsnVportL2Gre) SetLocalMac(v net.HardwareAddr) {
+	self.LocalMac = v
+}
+
+func (self *BsnVportL2Gre) GetNhMac() net.HardwareAddr {
+	return self.NhMac
+}
+
+func (self *BsnVportL2Gre) SetNhMac(v net.HardwareAddr) {
+	self.NhMac = v
+}
+
+func (self *BsnVportL2Gre) GetSrcIp() net.IP {
+	return self.SrcIp
+}
+
+func (self *BsnVportL2Gre) SetSrcIp(v net.IP) {
+	self.SrcIp = v
+}
+
+func (self *BsnVportL2Gre) GetDstIp() net.IP {
+	return self.DstIp
+}
+
+func (self *BsnVportL2Gre) SetDstIp(v net.IP) {
+	self.DstIp = v
+}
+
+func (self *BsnVportL2Gre) GetDscp() uint8 {
+	return self.Dscp
+}
+
+func (self *BsnVportL2Gre) SetDscp(v uint8) {
+	self.Dscp = v
+}
+
+func (self *BsnVportL2Gre) GetTtl() uint8 {
+	return self.Ttl
+}
+
+func (self *BsnVportL2Gre) SetTtl(v uint8) {
+	self.Ttl = v
+}
+
+func (self *BsnVportL2Gre) GetVpn() uint32 {
+	return self.Vpn
+}
+
+func (self *BsnVportL2Gre) SetVpn(v uint32) {
+	self.Vpn = v
+}
+
+func (self *BsnVportL2Gre) GetRateLimit() uint32 {
+	return self.RateLimit
+}
+
+func (self *BsnVportL2Gre) SetRateLimit(v uint32) {
+	self.RateLimit = v
+}
+
+func (self *BsnVportL2Gre) GetIfName() string {
+	return self.IfName
+}
+
+func (self *BsnVportL2Gre) SetIfName(v string) {
+	self.IfName = v
+}
+
+func (self *BsnVportL2Gre) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.BsnVport.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Flags))
+	self.PortNo.Serialize(encoder)
+	self.LoopbackPortNo.Serialize(encoder)
+	encoder.Write(self.LocalMac)
+	encoder.Write(self.NhMac)
+	encoder.Write(self.SrcIp.To4())
+	encoder.Write(self.DstIp.To4())
+	encoder.PutUint8(uint8(self.Dscp))
+	encoder.PutUint8(uint8(self.Ttl))
+	encoder.Write(bytes.Repeat([]byte{0}, 2))
+	encoder.PutUint32(uint32(self.Vpn))
+	encoder.PutUint32(uint32(self.RateLimit))
+	encoder.Write([]byte(self.IfName))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeBsnVportL2Gre(parent *BsnVport, decoder *goloxi.Decoder) (*BsnVportL2Gre, error) {
+	_bsnvportl2gre := &BsnVportL2Gre{BsnVport: parent}
+	if decoder.Length() < 56 {
+		return nil, fmt.Errorf("BsnVportL2Gre packet too short: %d < 56", decoder.Length())
+	}
+	_bsnvportl2gre.Flags = BsnVportL2GreFlags(decoder.ReadUint32())
+	_bsnvportl2gre.PortNo.Decode(decoder)
+	_bsnvportl2gre.LoopbackPortNo.Decode(decoder)
+	_bsnvportl2gre.LocalMac = net.HardwareAddr(decoder.Read(6))
+	_bsnvportl2gre.NhMac = net.HardwareAddr(decoder.Read(6))
+	_bsnvportl2gre.SrcIp = net.IP(decoder.Read(4))
+	_bsnvportl2gre.DstIp = net.IP(decoder.Read(4))
+	_bsnvportl2gre.Dscp = uint8(decoder.ReadByte())
+	_bsnvportl2gre.Ttl = uint8(decoder.ReadByte())
+	decoder.Skip(2)
+	_bsnvportl2gre.Vpn = uint32(decoder.ReadUint32())
+	_bsnvportl2gre.RateLimit = uint32(decoder.ReadUint32())
+	_bsnvportl2gre.IfName = string(bytes.Trim(decoder.Read(16), "\x00"))
+	return _bsnvportl2gre, nil
+}
+
+func NewBsnVportL2Gre() *BsnVportL2Gre {
+	obj := &BsnVportL2Gre{
+		BsnVport: NewBsnVport(1),
+	}
+	return obj
+}
+
+type BsnVportQInQ struct {
+	*BsnVport
+	PortNo        uint32
+	IngressTpid   uint16
+	IngressVlanId uint16
+	EgressTpid    uint16
+	EgressVlanId  uint16
+	IfName        string
+}
+
+type IBsnVportQInQ interface {
+	IBsnVport
+	GetPortNo() uint32
+	GetIngressTpid() uint16
+	GetIngressVlanId() uint16
+	GetEgressTpid() uint16
+	GetEgressVlanId() uint16
+	GetIfName() string
+}
+
+func (self *BsnVportQInQ) GetPortNo() uint32 {
+	return self.PortNo
+}
+
+func (self *BsnVportQInQ) SetPortNo(v uint32) {
+	self.PortNo = v
+}
+
+func (self *BsnVportQInQ) GetIngressTpid() uint16 {
+	return self.IngressTpid
+}
+
+func (self *BsnVportQInQ) SetIngressTpid(v uint16) {
+	self.IngressTpid = v
+}
+
+func (self *BsnVportQInQ) GetIngressVlanId() uint16 {
+	return self.IngressVlanId
+}
+
+func (self *BsnVportQInQ) SetIngressVlanId(v uint16) {
+	self.IngressVlanId = v
+}
+
+func (self *BsnVportQInQ) GetEgressTpid() uint16 {
+	return self.EgressTpid
+}
+
+func (self *BsnVportQInQ) SetEgressTpid(v uint16) {
+	self.EgressTpid = v
+}
+
+func (self *BsnVportQInQ) GetEgressVlanId() uint16 {
+	return self.EgressVlanId
+}
+
+func (self *BsnVportQInQ) SetEgressVlanId(v uint16) {
+	self.EgressVlanId = v
+}
+
+func (self *BsnVportQInQ) GetIfName() string {
+	return self.IfName
+}
+
+func (self *BsnVportQInQ) SetIfName(v string) {
+	self.IfName = v
+}
+
+func (self *BsnVportQInQ) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.BsnVport.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.PortNo))
+	encoder.PutUint16(uint16(self.IngressTpid))
+	encoder.PutUint16(uint16(self.IngressVlanId))
+	encoder.PutUint16(uint16(self.EgressTpid))
+	encoder.PutUint16(uint16(self.EgressVlanId))
+	encoder.Write([]byte(self.IfName))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeBsnVportQInQ(parent *BsnVport, decoder *goloxi.Decoder) (*BsnVportQInQ, error) {
+	_bsnvportqinq := &BsnVportQInQ{BsnVport: parent}
+	if decoder.Length() < 28 {
+		return nil, fmt.Errorf("BsnVportQInQ packet too short: %d < 28", decoder.Length())
+	}
+	_bsnvportqinq.PortNo = uint32(decoder.ReadUint32())
+	_bsnvportqinq.IngressTpid = uint16(decoder.ReadUint16())
+	_bsnvportqinq.IngressVlanId = uint16(decoder.ReadUint16())
+	_bsnvportqinq.EgressTpid = uint16(decoder.ReadUint16())
+	_bsnvportqinq.EgressVlanId = uint16(decoder.ReadUint16())
+	_bsnvportqinq.IfName = string(bytes.Trim(decoder.Read(16), "\x00"))
+	return _bsnvportqinq, nil
+}
+
+func NewBsnVportQInQ() *BsnVportQInQ {
+	obj := &BsnVportQInQ{
+		BsnVport: NewBsnVport(0),
+	}
+	return obj
+}
+
+type EdPropHeader struct {
+	PropClass uint16
+}
+
+type IEdPropHeader interface {
+	goloxi.Serializable
+	GetPropClass() uint16
+}
+
+func (self *EdPropHeader) GetPropClass() uint16 {
+	return self.PropClass
+}
+
+func (self *EdPropHeader) SetPropClass(v uint16) {
+	self.PropClass = v
+}
+
+func (self *EdPropHeader) Serialize(encoder *goloxi.Encoder) error {
+
+	encoder.PutUint16(uint16(self.PropClass))
+
+	return nil
+}
+
+func DecodeEdPropHeader(decoder *goloxi.Decoder) (IEdPropHeader, error) {
+	_edpropheader := &EdPropHeader{}
+	if decoder.Length() < 2 {
+		return nil, fmt.Errorf("EdPropHeader packet too short: %d < 2", decoder.Length())
+	}
+	_edpropheader.PropClass = uint16(decoder.ReadUint16())
+
+	switch _edpropheader.PropClass {
+	case 4:
+		return DecodeEdPropNsh(_edpropheader, decoder)
+	default:
+		return nil, fmt.Errorf("Invalid type '%d' for 'EdPropHeader'", _edpropheader.PropClass)
+	}
+}
+
+func NewEdPropHeader(_prop_class uint16) *EdPropHeader {
+	obj := &EdPropHeader{}
+	obj.PropClass = _prop_class
+	return obj
+}
+
+type EdPropNsh struct {
+	*EdPropHeader
+	Type uint8
+	Len  uint8
+}
+
+type IEdPropNsh interface {
+	IEdPropHeader
+	GetType() uint8
+	GetLen() uint8
+}
+
+func (self *EdPropNsh) GetType() uint8 {
+	return self.Type
+}
+
+func (self *EdPropNsh) SetType(v uint8) {
+	self.Type = v
+}
+
+func (self *EdPropNsh) GetLen() uint8 {
+	return self.Len
+}
+
+func (self *EdPropNsh) SetLen(v uint8) {
+	self.Len = v
+}
+
+func (self *EdPropNsh) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.EdPropHeader.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint8(uint8(self.Type))
+	encoder.PutUint8(uint8(self.Len))
+
+	return nil
+}
+
+func DecodeEdPropNsh(parent *EdPropHeader, decoder *goloxi.Decoder) (IEdPropNsh, error) {
+	_edpropnsh := &EdPropNsh{EdPropHeader: parent}
+	if decoder.Length() < 2 {
+		return nil, fmt.Errorf("EdPropNsh packet too short: %d < 2", decoder.Length())
+	}
+	defer decoder.SkipAlign()
+
+	_edpropnsh.Type = uint8(decoder.ReadByte())
+	_edpropnsh.Len = uint8(decoder.ReadByte())
+	oldDecoder := decoder
+	defer func() { decoder = oldDecoder }()
+	decoder = decoder.SliceDecoder(int(((_edpropnsh.Len)+7)/8*8), 1+3)
+
+	switch _edpropnsh.Type {
+	case 1:
+		return DecodeEdPropNshMdType(_edpropnsh, decoder)
+	case 2:
+		return DecodeEdPropNshTlv(_edpropnsh, decoder)
+	default:
+		return nil, fmt.Errorf("Invalid type '%d' for 'EdPropNsh'", _edpropnsh.Type)
+	}
+}
+
+func NewEdPropNsh(_type uint8) *EdPropNsh {
+	obj := &EdPropNsh{
+		EdPropHeader: NewEdPropHeader(4),
+	}
+	obj.Type = _type
+	return obj
+}
+
+type EdPropNshMdType struct {
+	*EdPropNsh
+	MdType uint8
+}
+
+type IEdPropNshMdType interface {
+	IEdPropNsh
+	GetMdType() uint8
+}
+
+func (self *EdPropNshMdType) GetMdType() uint8 {
+	return self.MdType
+}
+
+func (self *EdPropNshMdType) SetMdType(v uint8) {
+	self.MdType = v
+}
+
+func (self *EdPropNshMdType) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.EdPropNsh.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint8(uint8(self.MdType))
+	encoder.Write(bytes.Repeat([]byte{0}, 3))
+	length := len(encoder.Bytes()) - startIndex
+
+	encoder.Bytes()[startIndex+3] = uint8(length)
+
+	return nil
+}
+
+func DecodeEdPropNshMdType(parent *EdPropNsh, decoder *goloxi.Decoder) (*EdPropNshMdType, error) {
+	_edpropnshmdtype := &EdPropNshMdType{EdPropNsh: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("EdPropNshMdType packet too short: %d < 4", decoder.Length())
+	}
+	_edpropnshmdtype.MdType = uint8(decoder.ReadByte())
+	decoder.Skip(3)
+	return _edpropnshmdtype, nil
+}
+
+func NewEdPropNshMdType() *EdPropNshMdType {
+	obj := &EdPropNshMdType{
+		EdPropNsh: NewEdPropNsh(1),
+	}
+	return obj
+}
+
+type EdPropNshTlv struct {
+	*EdPropNsh
+	TlvClass uint16
+	TlvType  uint8
+	TlvLen   uint8
+	Value    []byte
+}
+
+type IEdPropNshTlv interface {
+	IEdPropNsh
+	GetTlvClass() uint16
+	GetTlvType() uint8
+	GetTlvLen() uint8
+	GetValue() []byte
+}
+
+func (self *EdPropNshTlv) GetTlvClass() uint16 {
+	return self.TlvClass
+}
+
+func (self *EdPropNshTlv) SetTlvClass(v uint16) {
+	self.TlvClass = v
+}
+
+func (self *EdPropNshTlv) GetTlvType() uint8 {
+	return self.TlvType
+}
+
+func (self *EdPropNshTlv) SetTlvType(v uint8) {
+	self.TlvType = v
+}
+
+func (self *EdPropNshTlv) GetTlvLen() uint8 {
+	return self.TlvLen
+}
+
+func (self *EdPropNshTlv) SetTlvLen(v uint8) {
+	self.TlvLen = v
+}
+
+func (self *EdPropNshTlv) GetValue() []byte {
+	return self.Value
+}
+
+func (self *EdPropNshTlv) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *EdPropNshTlv) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.EdPropNsh.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.TlvClass))
+	encoder.PutUint8(uint8(self.TlvType))
+	encoder.PutUint8(uint8(self.TlvLen))
+	encoder.Write(self.Value)
+	length := len(encoder.Bytes()) - startIndex
+
+	encoder.Bytes()[startIndex+3] = uint8(length)
+
+	return nil
+}
+
+func DecodeEdPropNshTlv(parent *EdPropNsh, decoder *goloxi.Decoder) (*EdPropNshTlv, error) {
+	_edpropnshtlv := &EdPropNshTlv{EdPropNsh: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("EdPropNshTlv packet too short: %d < 4", decoder.Length())
+	}
+	_edpropnshtlv.TlvClass = uint16(decoder.ReadUint16())
+	_edpropnshtlv.TlvType = uint8(decoder.ReadByte())
+	_edpropnshtlv.TlvLen = uint8(decoder.ReadByte())
+	_edpropnshtlv.Value = decoder.SliceDecoder(int(_edpropnshtlv.TlvLen), 0).Read(int(_edpropnshtlv.TlvLen))
+	return _edpropnshtlv, nil
+}
+
+func NewEdPropNshTlv() *EdPropNshTlv {
+	obj := &EdPropNshTlv{
+		EdPropNsh: NewEdPropNsh(2),
+	}
+	return obj
+}
+
+type FlowModSpec struct {
+	SrcDst uint8
+	NBits  uint8
+}
+
+type IFlowModSpec interface {
+	goloxi.Serializable
+	GetSrcDst() uint8
+	GetNBits() uint8
+}
+
+func (self *FlowModSpec) GetSrcDst() uint8 {
+	return self.SrcDst
+}
+
+func (self *FlowModSpec) SetSrcDst(v uint8) {
+	self.SrcDst = v
+}
+
+func (self *FlowModSpec) GetNBits() uint8 {
+	return self.NBits
+}
+
+func (self *FlowModSpec) SetNBits(v uint8) {
+	self.NBits = v
+}
+
+func (self *FlowModSpec) Serialize(encoder *goloxi.Encoder) error {
+
+	encoder.PutUint8(uint8(self.SrcDst))
+	encoder.PutUint8(uint8(self.NBits))
+
+	return nil
+}
+
+func DecodeFlowModSpec(decoder *goloxi.Decoder) (IFlowModSpec, error) {
+	_flowmodspec := &FlowModSpec{}
+	if decoder.Length() < 2 {
+		return nil, fmt.Errorf("FlowModSpec packet too short: %d < 2", decoder.Length())
+	}
+	_flowmodspec.SrcDst = uint8(decoder.ReadByte())
+	_flowmodspec.NBits = uint8(decoder.ReadByte())
+	if _flowmodspec.SrcDst == 0 && _flowmodspec.NBits == 0 {
+		return nil, nil
+	}
+
+	switch _flowmodspec.SrcDst {
+	case 0:
+		return DecodeFlowModSpecSrc0Dst0(_flowmodspec, decoder)
+	case 8:
+		return DecodeFlowModSpecSrc0Dst1(_flowmodspec, decoder)
+	case 40:
+		return DecodeFlowModSpecSrc1Dst1(_flowmodspec, decoder)
+	case 16:
+		return DecodeFlowModSpecSrc0Dst2(_flowmodspec, decoder)
+	case 32:
+		return DecodeFlowModSpecSrc1Dst0(_flowmodspec, decoder)
+	default:
+		return nil, fmt.Errorf("Invalid type '%d' for 'FlowModSpec'", _flowmodspec.SrcDst)
+	}
+}
+
+func NewFlowModSpec(_src_dst uint8) *FlowModSpec {
+	obj := &FlowModSpec{}
+	obj.SrcDst = _src_dst
+	return obj
+}
+
+type FlowModSpecSrc0Dst0 struct {
+	*FlowModSpec
+	Src    goloxi.IOxmId
+	SrcOfs uint16
+	Dst    goloxi.IOxmId
+	DstOfs uint16
+}
+
+type IFlowModSpecSrc0Dst0 interface {
+	IFlowModSpec
+	GetSrc() goloxi.IOxmId
+	GetSrcOfs() uint16
+	GetDst() goloxi.IOxmId
+	GetDstOfs() uint16
+}
+
+func (self *FlowModSpecSrc0Dst0) GetSrc() goloxi.IOxmId {
+	return self.Src
+}
+
+func (self *FlowModSpecSrc0Dst0) SetSrc(v goloxi.IOxmId) {
+	self.Src = v
+}
+
+func (self *FlowModSpecSrc0Dst0) GetSrcOfs() uint16 {
+	return self.SrcOfs
+}
+
+func (self *FlowModSpecSrc0Dst0) SetSrcOfs(v uint16) {
+	self.SrcOfs = v
+}
+
+func (self *FlowModSpecSrc0Dst0) GetDst() goloxi.IOxmId {
+	return self.Dst
+}
+
+func (self *FlowModSpecSrc0Dst0) SetDst(v goloxi.IOxmId) {
+	self.Dst = v
+}
+
+func (self *FlowModSpecSrc0Dst0) GetDstOfs() uint16 {
+	return self.DstOfs
+}
+
+func (self *FlowModSpecSrc0Dst0) SetDstOfs(v uint16) {
+	self.DstOfs = v
+}
+
+func (self *FlowModSpecSrc0Dst0) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.FlowModSpec.Serialize(encoder); err != nil {
+		return err
+	}
+
+	self.Src.Serialize(encoder)
+	encoder.PutUint16(uint16(self.SrcOfs))
+	self.Dst.Serialize(encoder)
+	encoder.PutUint16(uint16(self.DstOfs))
+
+	return nil
+}
+
+func DecodeFlowModSpecSrc0Dst0(parent *FlowModSpec, decoder *goloxi.Decoder) (IFlowModSpecSrc0Dst0, error) {
+	_flowmodspecsrc0dst0 := &FlowModSpecSrc0Dst0{FlowModSpec: parent}
+	if decoder.Length() < 12 {
+		return nil, fmt.Errorf("FlowModSpecSrc0Dst0 packet too short: %d < 12", decoder.Length())
+	}
+	if obj, err := DecodeOxmId(decoder); err != nil {
+		return nil, err
+	} else {
+		_flowmodspecsrc0dst0.Src = obj
+	}
+
+	_flowmodspecsrc0dst0.SrcOfs = uint16(decoder.ReadUint16())
+	if obj, err := DecodeOxmId(decoder); err != nil {
+		return nil, err
+	} else {
+		_flowmodspecsrc0dst0.Dst = obj
+	}
+
+	_flowmodspecsrc0dst0.DstOfs = uint16(decoder.ReadUint16())
+	return _flowmodspecsrc0dst0, nil
+}
+
+func NewFlowModSpecSrc0Dst0(_n_bits uint8) *FlowModSpecSrc0Dst0 {
+	obj := &FlowModSpecSrc0Dst0{
+		FlowModSpec: NewFlowModSpec(0),
+	}
+	obj.NBits = _n_bits
+	return obj
+}
+
+type FlowModSpecSrc0Dst1 struct {
+	*FlowModSpec
+	Src    goloxi.IOxmId
+	SrcOfs uint16
+	Dst    goloxi.IOxmId
+	DstOfs uint16
+}
+
+type IFlowModSpecSrc0Dst1 interface {
+	IFlowModSpec
+	GetSrc() goloxi.IOxmId
+	GetSrcOfs() uint16
+	GetDst() goloxi.IOxmId
+	GetDstOfs() uint16
+}
+
+func (self *FlowModSpecSrc0Dst1) GetSrc() goloxi.IOxmId {
+	return self.Src
+}
+
+func (self *FlowModSpecSrc0Dst1) SetSrc(v goloxi.IOxmId) {
+	self.Src = v
+}
+
+func (self *FlowModSpecSrc0Dst1) GetSrcOfs() uint16 {
+	return self.SrcOfs
+}
+
+func (self *FlowModSpecSrc0Dst1) SetSrcOfs(v uint16) {
+	self.SrcOfs = v
+}
+
+func (self *FlowModSpecSrc0Dst1) GetDst() goloxi.IOxmId {
+	return self.Dst
+}
+
+func (self *FlowModSpecSrc0Dst1) SetDst(v goloxi.IOxmId) {
+	self.Dst = v
+}
+
+func (self *FlowModSpecSrc0Dst1) GetDstOfs() uint16 {
+	return self.DstOfs
+}
+
+func (self *FlowModSpecSrc0Dst1) SetDstOfs(v uint16) {
+	self.DstOfs = v
+}
+
+func (self *FlowModSpecSrc0Dst1) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.FlowModSpec.Serialize(encoder); err != nil {
+		return err
+	}
+
+	self.Src.Serialize(encoder)
+	encoder.PutUint16(uint16(self.SrcOfs))
+	self.Dst.Serialize(encoder)
+	encoder.PutUint16(uint16(self.DstOfs))
+
+	return nil
+}
+
+func DecodeFlowModSpecSrc0Dst1(parent *FlowModSpec, decoder *goloxi.Decoder) (*FlowModSpecSrc0Dst1, error) {
+	_flowmodspecsrc0dst1 := &FlowModSpecSrc0Dst1{FlowModSpec: parent}
+	if decoder.Length() < 12 {
+		return nil, fmt.Errorf("FlowModSpecSrc0Dst1 packet too short: %d < 12", decoder.Length())
+	}
+	if obj, err := DecodeOxmId(decoder); err != nil {
+		return nil, err
+	} else {
+		_flowmodspecsrc0dst1.Src = obj
+	}
+
+	_flowmodspecsrc0dst1.SrcOfs = uint16(decoder.ReadUint16())
+	if obj, err := DecodeOxmId(decoder); err != nil {
+		return nil, err
+	} else {
+		_flowmodspecsrc0dst1.Dst = obj
+	}
+
+	_flowmodspecsrc0dst1.DstOfs = uint16(decoder.ReadUint16())
+	return _flowmodspecsrc0dst1, nil
+}
+
+func NewFlowModSpecSrc0Dst1() *FlowModSpecSrc0Dst1 {
+	obj := &FlowModSpecSrc0Dst1{
+		FlowModSpec: NewFlowModSpec(8),
+	}
+	return obj
+}
+
+type FlowModSpecSrc0Dst2 struct {
+	*FlowModSpec
+	Src    goloxi.IOxmId
+	SrcOfs uint16
+}
+
+type IFlowModSpecSrc0Dst2 interface {
+	IFlowModSpec
+	GetSrc() goloxi.IOxmId
+	GetSrcOfs() uint16
+}
+
+func (self *FlowModSpecSrc0Dst2) GetSrc() goloxi.IOxmId {
+	return self.Src
+}
+
+func (self *FlowModSpecSrc0Dst2) SetSrc(v goloxi.IOxmId) {
+	self.Src = v
+}
+
+func (self *FlowModSpecSrc0Dst2) GetSrcOfs() uint16 {
+	return self.SrcOfs
+}
+
+func (self *FlowModSpecSrc0Dst2) SetSrcOfs(v uint16) {
+	self.SrcOfs = v
+}
+
+func (self *FlowModSpecSrc0Dst2) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.FlowModSpec.Serialize(encoder); err != nil {
+		return err
+	}
+
+	self.Src.Serialize(encoder)
+	encoder.PutUint16(uint16(self.SrcOfs))
+
+	return nil
+}
+
+func DecodeFlowModSpecSrc0Dst2(parent *FlowModSpec, decoder *goloxi.Decoder) (*FlowModSpecSrc0Dst2, error) {
+	_flowmodspecsrc0dst2 := &FlowModSpecSrc0Dst2{FlowModSpec: parent}
+	if decoder.Length() < 6 {
+		return nil, fmt.Errorf("FlowModSpecSrc0Dst2 packet too short: %d < 6", decoder.Length())
+	}
+	if obj, err := DecodeOxmId(decoder); err != nil {
+		return nil, err
+	} else {
+		_flowmodspecsrc0dst2.Src = obj
+	}
+
+	_flowmodspecsrc0dst2.SrcOfs = uint16(decoder.ReadUint16())
+	return _flowmodspecsrc0dst2, nil
+}
+
+func NewFlowModSpecSrc0Dst2() *FlowModSpecSrc0Dst2 {
+	obj := &FlowModSpecSrc0Dst2{
+		FlowModSpec: NewFlowModSpec(16),
+	}
+	return obj
+}
+
+type FlowModSpecSrc1Dst0 struct {
+	*FlowModSpec
+	Src    []byte
+	Dst    goloxi.IOxmId
+	DstOfs uint16
+}
+
+type IFlowModSpecSrc1Dst0 interface {
+	IFlowModSpec
+	GetSrc() []byte
+	GetDst() goloxi.IOxmId
+	GetDstOfs() uint16
+}
+
+func (self *FlowModSpecSrc1Dst0) GetSrc() []byte {
+	return self.Src
+}
+
+func (self *FlowModSpecSrc1Dst0) SetSrc(v []byte) {
+	self.Src = v
+}
+
+func (self *FlowModSpecSrc1Dst0) GetDst() goloxi.IOxmId {
+	return self.Dst
+}
+
+func (self *FlowModSpecSrc1Dst0) SetDst(v goloxi.IOxmId) {
+	self.Dst = v
+}
+
+func (self *FlowModSpecSrc1Dst0) GetDstOfs() uint16 {
+	return self.DstOfs
+}
+
+func (self *FlowModSpecSrc1Dst0) SetDstOfs(v uint16) {
+	self.DstOfs = v
+}
+
+func (self *FlowModSpecSrc1Dst0) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.FlowModSpec.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Src)
+	self.Dst.Serialize(encoder)
+	encoder.PutUint16(uint16(self.DstOfs))
+
+	return nil
+}
+
+func DecodeFlowModSpecSrc1Dst0(parent *FlowModSpec, decoder *goloxi.Decoder) (*FlowModSpecSrc1Dst0, error) {
+	_flowmodspecsrc1dst0 := &FlowModSpecSrc1Dst0{FlowModSpec: parent}
+	if decoder.Length() < 6 {
+		return nil, fmt.Errorf("FlowModSpecSrc1Dst0 packet too short: %d < 6", decoder.Length())
+	}
+	_flowmodspecsrc1dst0.Src = decoder.SliceDecoder(int((_flowmodspecsrc1dst0.NBits+15)/16*2), 0).Read(int(_flowmodspecsrc1dst0.NBits))
+	if obj, err := DecodeOxmId(decoder); err != nil {
+		return nil, err
+	} else {
+		_flowmodspecsrc1dst0.Dst = obj
+	}
+
+	_flowmodspecsrc1dst0.DstOfs = uint16(decoder.ReadUint16())
+	return _flowmodspecsrc1dst0, nil
+}
+
+func NewFlowModSpecSrc1Dst0() *FlowModSpecSrc1Dst0 {
+	obj := &FlowModSpecSrc1Dst0{
+		FlowModSpec: NewFlowModSpec(32),
+	}
+	return obj
+}
+
+type FlowModSpecSrc1Dst1 struct {
+	*FlowModSpec
+	Src    []byte
+	Dst    goloxi.IOxmId
+	DstOfs uint16
+}
+
+type IFlowModSpecSrc1Dst1 interface {
+	IFlowModSpec
+	GetSrc() []byte
+	GetDst() goloxi.IOxmId
+	GetDstOfs() uint16
+}
+
+func (self *FlowModSpecSrc1Dst1) GetSrc() []byte {
+	return self.Src
+}
+
+func (self *FlowModSpecSrc1Dst1) SetSrc(v []byte) {
+	self.Src = v
+}
+
+func (self *FlowModSpecSrc1Dst1) GetDst() goloxi.IOxmId {
+	return self.Dst
+}
+
+func (self *FlowModSpecSrc1Dst1) SetDst(v goloxi.IOxmId) {
+	self.Dst = v
+}
+
+func (self *FlowModSpecSrc1Dst1) GetDstOfs() uint16 {
+	return self.DstOfs
+}
+
+func (self *FlowModSpecSrc1Dst1) SetDstOfs(v uint16) {
+	self.DstOfs = v
+}
+
+func (self *FlowModSpecSrc1Dst1) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.FlowModSpec.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Src)
+	self.Dst.Serialize(encoder)
+	encoder.PutUint16(uint16(self.DstOfs))
+
+	return nil
+}
+
+func DecodeFlowModSpecSrc1Dst1(parent *FlowModSpec, decoder *goloxi.Decoder) (*FlowModSpecSrc1Dst1, error) {
+	_flowmodspecsrc1dst1 := &FlowModSpecSrc1Dst1{FlowModSpec: parent}
+	if decoder.Length() < 6 {
+		return nil, fmt.Errorf("FlowModSpecSrc1Dst1 packet too short: %d < 6", decoder.Length())
+	}
+	_flowmodspecsrc1dst1.Src = decoder.SliceDecoder(int((_flowmodspecsrc1dst1.NBits+15)/16*2), 0).Read(int(_flowmodspecsrc1dst1.NBits))
+	if obj, err := DecodeOxmId(decoder); err != nil {
+		return nil, err
+	} else {
+		_flowmodspecsrc1dst1.Dst = obj
+	}
+
+	_flowmodspecsrc1dst1.DstOfs = uint16(decoder.ReadUint16())
+	return _flowmodspecsrc1dst1, nil
+}
+
+func NewFlowModSpecSrc1Dst1() *FlowModSpecSrc1Dst1 {
+	obj := &FlowModSpecSrc1Dst1{
+		FlowModSpec: NewFlowModSpec(40),
+	}
+	return obj
+}
+
+type FlowStatsEntry struct {
+	Length       uint16
+	TableId      uint8
+	Match        Match
+	DurationSec  uint32
+	DurationNsec uint32
+	Priority     uint16
+	IdleTimeout  uint16
+	HardTimeout  uint16
+	Cookie       uint64
+	PacketCount  uint64
+	ByteCount    uint64
+	Actions      []goloxi.IAction
+}
+
+type IFlowStatsEntry interface {
+	goloxi.Serializable
+	GetLength() uint16
+	GetTableId() uint8
+	GetMatch() Match
+	GetDurationSec() uint32
+	GetDurationNsec() uint32
+	GetPriority() uint16
+	GetIdleTimeout() uint16
+	GetHardTimeout() uint16
+	GetCookie() uint64
+	GetPacketCount() uint64
+	GetByteCount() uint64
+	GetActions() []goloxi.IAction
+}
+
+func (self *FlowStatsEntry) GetLength() uint16 {
+	return self.Length
+}
+
+func (self *FlowStatsEntry) SetLength(v uint16) {
+	self.Length = v
+}
+
+func (self *FlowStatsEntry) GetTableId() uint8 {
+	return self.TableId
+}
+
+func (self *FlowStatsEntry) SetTableId(v uint8) {
+	self.TableId = v
+}
+
+func (self *FlowStatsEntry) GetMatch() Match {
+	return self.Match
+}
+
+func (self *FlowStatsEntry) SetMatch(v Match) {
+	self.Match = v
+}
+
+func (self *FlowStatsEntry) GetDurationSec() uint32 {
+	return self.DurationSec
+}
+
+func (self *FlowStatsEntry) SetDurationSec(v uint32) {
+	self.DurationSec = v
+}
+
+func (self *FlowStatsEntry) GetDurationNsec() uint32 {
+	return self.DurationNsec
+}
+
+func (self *FlowStatsEntry) SetDurationNsec(v uint32) {
+	self.DurationNsec = v
+}
+
+func (self *FlowStatsEntry) GetPriority() uint16 {
+	return self.Priority
+}
+
+func (self *FlowStatsEntry) SetPriority(v uint16) {
+	self.Priority = v
+}
+
+func (self *FlowStatsEntry) GetIdleTimeout() uint16 {
+	return self.IdleTimeout
+}
+
+func (self *FlowStatsEntry) SetIdleTimeout(v uint16) {
+	self.IdleTimeout = v
+}
+
+func (self *FlowStatsEntry) GetHardTimeout() uint16 {
+	return self.HardTimeout
+}
+
+func (self *FlowStatsEntry) SetHardTimeout(v uint16) {
+	self.HardTimeout = v
+}
+
+func (self *FlowStatsEntry) GetCookie() uint64 {
+	return self.Cookie
+}
+
+func (self *FlowStatsEntry) SetCookie(v uint64) {
+	self.Cookie = v
+}
+
+func (self *FlowStatsEntry) GetPacketCount() uint64 {
+	return self.PacketCount
+}
+
+func (self *FlowStatsEntry) SetPacketCount(v uint64) {
+	self.PacketCount = v
+}
+
+func (self *FlowStatsEntry) GetByteCount() uint64 {
+	return self.ByteCount
+}
+
+func (self *FlowStatsEntry) SetByteCount(v uint64) {
+	self.ByteCount = v
+}
+
+func (self *FlowStatsEntry) GetActions() []goloxi.IAction {
+	return self.Actions
+}
+
+func (self *FlowStatsEntry) SetActions(v []goloxi.IAction) {
+	self.Actions = v
+}
+
+func (self *FlowStatsEntry) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+
+	encoder.PutUint16(uint16(self.Length))
+	encoder.PutUint8(uint8(self.TableId))
+	encoder.Write(bytes.Repeat([]byte{0}, 1))
+	if err := self.Match.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.DurationSec))
+	encoder.PutUint32(uint32(self.DurationNsec))
+	encoder.PutUint16(uint16(self.Priority))
+	encoder.PutUint16(uint16(self.IdleTimeout))
+	encoder.PutUint16(uint16(self.HardTimeout))
+	encoder.Write(bytes.Repeat([]byte{0}, 6))
+	encoder.PutUint64(uint64(self.Cookie))
+	encoder.PutUint64(uint64(self.PacketCount))
+	encoder.PutUint64(uint64(self.ByteCount))
+	for _, obj := range self.Actions {
+		if err := obj.Serialize(encoder); err != nil {
+			return err
+		}
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
+
+	return nil
+}
+
+func DecodeFlowStatsEntry(decoder *goloxi.Decoder) (*FlowStatsEntry, error) {
+	_flowstatsentry := &FlowStatsEntry{}
+	if decoder.Length() < 88 {
+		return nil, fmt.Errorf("FlowStatsEntry packet too short: %d < 88", decoder.Length())
+	}
+	_flowstatsentry.Length = uint16(decoder.ReadUint16())
+	oldDecoder := decoder
+	defer func() { decoder = oldDecoder }()
+	decoder = decoder.SliceDecoder(int(_flowstatsentry.Length), 2+0)
+	_flowstatsentry.TableId = uint8(decoder.ReadByte())
+	decoder.Skip(1)
+	if err := _flowstatsentry.Match.Decode(decoder); err != nil {
+		return nil, err
+	}
+
+	_flowstatsentry.DurationSec = uint32(decoder.ReadUint32())
+	_flowstatsentry.DurationNsec = uint32(decoder.ReadUint32())
+	_flowstatsentry.Priority = uint16(decoder.ReadUint16())
+	_flowstatsentry.IdleTimeout = uint16(decoder.ReadUint16())
+	_flowstatsentry.HardTimeout = uint16(decoder.ReadUint16())
+	decoder.Skip(6)
+	_flowstatsentry.Cookie = uint64(decoder.ReadUint64())
+	_flowstatsentry.PacketCount = uint64(decoder.ReadUint64())
+	_flowstatsentry.ByteCount = uint64(decoder.ReadUint64())
+
+	for decoder.Length() >= 8 {
+		item, err := DecodeAction(decoder)
+		if err != nil {
+			return nil, err
+		}
+		if item != nil {
+			_flowstatsentry.Actions = append(_flowstatsentry.Actions, item)
+		}
+	}
+	return _flowstatsentry, nil
+}
+
+func NewFlowStatsEntry() *FlowStatsEntry {
+	obj := &FlowStatsEntry{}
+	return obj
+}
+
+type MatchV1 struct {
+	Wildcards WcBmap
+	InPort    Port
+	EthSrc    net.HardwareAddr
+	EthDst    net.HardwareAddr
+	VlanVid   uint16
+	VlanPcp   uint8
+	EthType   uint16
+	IpDscp    uint8
+	IpProto   uint8
+	Ipv4Src   net.IP
+	Ipv4Dst   net.IP
+	TcpSrc    uint16
+	TcpDst    uint16
+}
+
+type IMatchV1 interface {
+	goloxi.Serializable
+	GetWildcards() WcBmap
+	GetInPort() Port
+	GetEthSrc() net.HardwareAddr
+	GetEthDst() net.HardwareAddr
+	GetVlanVid() uint16
+	GetVlanPcp() uint8
+	GetEthType() uint16
+	GetIpDscp() uint8
+	GetIpProto() uint8
+	GetIpv4Src() net.IP
+	GetIpv4Dst() net.IP
+	GetTcpSrc() uint16
+	GetTcpDst() uint16
+}
+
+func (self *MatchV1) GetWildcards() WcBmap {
+	return self.Wildcards
+}
+
+func (self *MatchV1) SetWildcards(v WcBmap) {
+	self.Wildcards = v
+}
+
+func (self *MatchV1) GetInPort() Port {
+	return self.InPort
+}
+
+func (self *MatchV1) SetInPort(v Port) {
+	self.InPort = v
+}
+
+func (self *MatchV1) GetEthSrc() net.HardwareAddr {
+	return self.EthSrc
+}
+
+func (self *MatchV1) SetEthSrc(v net.HardwareAddr) {
+	self.EthSrc = v
+}
+
+func (self *MatchV1) GetEthDst() net.HardwareAddr {
+	return self.EthDst
+}
+
+func (self *MatchV1) SetEthDst(v net.HardwareAddr) {
+	self.EthDst = v
+}
+
+func (self *MatchV1) GetVlanVid() uint16 {
+	return self.VlanVid
+}
+
+func (self *MatchV1) SetVlanVid(v uint16) {
+	self.VlanVid = v
+}
+
+func (self *MatchV1) GetVlanPcp() uint8 {
+	return self.VlanPcp
+}
+
+func (self *MatchV1) SetVlanPcp(v uint8) {
+	self.VlanPcp = v
+}
+
+func (self *MatchV1) GetEthType() uint16 {
+	return self.EthType
+}
+
+func (self *MatchV1) SetEthType(v uint16) {
+	self.EthType = v
+}
+
+func (self *MatchV1) GetIpDscp() uint8 {
+	return self.IpDscp
+}
+
+func (self *MatchV1) SetIpDscp(v uint8) {
+	self.IpDscp = v
+}
+
+func (self *MatchV1) GetIpProto() uint8 {
+	return self.IpProto
+}
+
+func (self *MatchV1) SetIpProto(v uint8) {
+	self.IpProto = v
+}
+
+func (self *MatchV1) GetIpv4Src() net.IP {
+	return self.Ipv4Src
+}
+
+func (self *MatchV1) SetIpv4Src(v net.IP) {
+	self.Ipv4Src = v
+}
+
+func (self *MatchV1) GetIpv4Dst() net.IP {
+	return self.Ipv4Dst
+}
+
+func (self *MatchV1) SetIpv4Dst(v net.IP) {
+	self.Ipv4Dst = v
+}
+
+func (self *MatchV1) GetTcpSrc() uint16 {
+	return self.TcpSrc
+}
+
+func (self *MatchV1) SetTcpSrc(v uint16) {
+	self.TcpSrc = v
+}
+
+func (self *MatchV1) GetTcpDst() uint16 {
+	return self.TcpDst
+}
+
+func (self *MatchV1) SetTcpDst(v uint16) {
+	self.TcpDst = v
+}
+
+func (self *MatchV1) Serialize(encoder *goloxi.Encoder) error {
+
+	self.Wildcards.Serialize(encoder)
+	self.InPort.Serialize(encoder)
+	encoder.Write(self.EthSrc)
+	encoder.Write(self.EthDst)
+	encoder.PutUint16(uint16(self.VlanVid))
+	encoder.PutUint8(uint8(self.VlanPcp))
+	encoder.Write(bytes.Repeat([]byte{0}, 1))
+	encoder.PutUint16(uint16(self.EthType))
+	encoder.PutUint8(uint8(self.IpDscp))
+	encoder.PutUint8(uint8(self.IpProto))
+	encoder.Write(bytes.Repeat([]byte{0}, 2))
+	encoder.Write(self.Ipv4Src.To4())
+	encoder.Write(self.Ipv4Dst.To4())
+	encoder.PutUint16(uint16(self.TcpSrc))
+	encoder.PutUint16(uint16(self.TcpDst))
+
+	return nil
+}
+func (self *MatchV1) Decode(decoder *goloxi.Decoder) error {
+	if decoder.Length() < 40 {
+		return fmt.Errorf("MatchV1 packet too short: %d < 40", decoder.Length())
+	}
+
+	self.Wildcards.Decode(decoder)
+	self.InPort.Decode(decoder)
+	self.EthSrc = net.HardwareAddr(decoder.Read(6))
+	self.EthDst = net.HardwareAddr(decoder.Read(6))
+	self.VlanVid = uint16(decoder.ReadUint16())
+	self.VlanPcp = uint8(decoder.ReadByte())
+	decoder.Skip(1)
+	self.EthType = uint16(decoder.ReadUint16())
+	self.IpDscp = uint8(decoder.ReadByte())
+	self.IpProto = uint8(decoder.ReadByte())
+	decoder.Skip(2)
+	self.Ipv4Src = net.IP(decoder.Read(4))
+	self.Ipv4Dst = net.IP(decoder.Read(4))
+	self.TcpSrc = uint16(decoder.ReadUint16())
+	self.TcpDst = uint16(decoder.ReadUint16())
+
+	return nil
+}
+
+func NewMatchV1() *MatchV1 {
+	obj := &MatchV1{}
+	return obj
+}
+
+type NiciraMatch struct {
+	NxmEntries []goloxi.IOxm
+}
+
+type INiciraMatch interface {
+	goloxi.Serializable
+	GetNxmEntries() []goloxi.IOxm
+}
+
+func (self *NiciraMatch) GetNxmEntries() []goloxi.IOxm {
+	return self.NxmEntries
+}
+
+func (self *NiciraMatch) SetNxmEntries(v []goloxi.IOxm) {
+	self.NxmEntries = v
+}
+
+func (self *NiciraMatch) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+
+	for _, obj := range self.NxmEntries {
+		if err := obj.Serialize(encoder); err != nil {
+			return err
+		}
+	}
+	length := len(encoder.Bytes()) - startIndex
+	alignedLength := ((length + 7) / 8 * 8)
+
+	encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
+
+	return nil
+}
+func (self *NiciraMatch) Decode(decoder *goloxi.Decoder) error {
+
+	defer decoder.SkipAlign()
+
+	for decoder.Length() >= 4 {
+		item, err := DecodeOxm(decoder)
+		if err != nil {
+			return err
+		}
+		if item != nil {
+			self.NxmEntries = append(self.NxmEntries, item)
+		}
+	}
+
+	return nil
+}
+
+func NewNiciraMatch() *NiciraMatch {
+	obj := &NiciraMatch{}
+	return obj
+}
+
+type NiciraFlowStats struct {
+	Length       uint16
+	TableId      uint8
+	DurationSec  uint32
+	DurationNsec uint32
+	Priority     uint16
+	IdleTimeout  uint16
+	HardTimeout  uint16
+	MatchLen     uint16
+	IdleAge      uint16
+	HardAge      uint16
+	Cookie       uint64
+	PacketCount  uint64
+	ByteCount    uint64
+	Match        NiciraMatch
+	Actions      []goloxi.IAction
+}
+
+type INiciraFlowStats interface {
+	goloxi.Serializable
+	GetLength() uint16
+	GetTableId() uint8
+	GetDurationSec() uint32
+	GetDurationNsec() uint32
+	GetPriority() uint16
+	GetIdleTimeout() uint16
+	GetHardTimeout() uint16
+	GetMatchLen() uint16
+	GetIdleAge() uint16
+	GetHardAge() uint16
+	GetCookie() uint64
+	GetPacketCount() uint64
+	GetByteCount() uint64
+	GetMatch() NiciraMatch
+	GetActions() []goloxi.IAction
+}
+
+func (self *NiciraFlowStats) GetLength() uint16 {
+	return self.Length
+}
+
+func (self *NiciraFlowStats) SetLength(v uint16) {
+	self.Length = v
+}
+
+func (self *NiciraFlowStats) GetTableId() uint8 {
+	return self.TableId
+}
+
+func (self *NiciraFlowStats) SetTableId(v uint8) {
+	self.TableId = v
+}
+
+func (self *NiciraFlowStats) GetDurationSec() uint32 {
+	return self.DurationSec
+}
+
+func (self *NiciraFlowStats) SetDurationSec(v uint32) {
+	self.DurationSec = v
+}
+
+func (self *NiciraFlowStats) GetDurationNsec() uint32 {
+	return self.DurationNsec
+}
+
+func (self *NiciraFlowStats) SetDurationNsec(v uint32) {
+	self.DurationNsec = v
+}
+
+func (self *NiciraFlowStats) GetPriority() uint16 {
+	return self.Priority
+}
+
+func (self *NiciraFlowStats) SetPriority(v uint16) {
+	self.Priority = v
+}
+
+func (self *NiciraFlowStats) GetIdleTimeout() uint16 {
+	return self.IdleTimeout
+}
+
+func (self *NiciraFlowStats) SetIdleTimeout(v uint16) {
+	self.IdleTimeout = v
+}
+
+func (self *NiciraFlowStats) GetHardTimeout() uint16 {
+	return self.HardTimeout
+}
+
+func (self *NiciraFlowStats) SetHardTimeout(v uint16) {
+	self.HardTimeout = v
+}
+
+func (self *NiciraFlowStats) GetMatchLen() uint16 {
+	return self.MatchLen
+}
+
+func (self *NiciraFlowStats) SetMatchLen(v uint16) {
+	self.MatchLen = v
+}
+
+func (self *NiciraFlowStats) GetIdleAge() uint16 {
+	return self.IdleAge
+}
+
+func (self *NiciraFlowStats) SetIdleAge(v uint16) {
+	self.IdleAge = v
+}
+
+func (self *NiciraFlowStats) GetHardAge() uint16 {
+	return self.HardAge
+}
+
+func (self *NiciraFlowStats) SetHardAge(v uint16) {
+	self.HardAge = v
+}
+
+func (self *NiciraFlowStats) GetCookie() uint64 {
+	return self.Cookie
+}
+
+func (self *NiciraFlowStats) SetCookie(v uint64) {
+	self.Cookie = v
+}
+
+func (self *NiciraFlowStats) GetPacketCount() uint64 {
+	return self.PacketCount
+}
+
+func (self *NiciraFlowStats) SetPacketCount(v uint64) {
+	self.PacketCount = v
+}
+
+func (self *NiciraFlowStats) GetByteCount() uint64 {
+	return self.ByteCount
+}
+
+func (self *NiciraFlowStats) SetByteCount(v uint64) {
+	self.ByteCount = v
+}
+
+func (self *NiciraFlowStats) GetMatch() NiciraMatch {
+	return self.Match
+}
+
+func (self *NiciraFlowStats) SetMatch(v NiciraMatch) {
+	self.Match = v
+}
+
+func (self *NiciraFlowStats) GetActions() []goloxi.IAction {
+	return self.Actions
+}
+
+func (self *NiciraFlowStats) SetActions(v []goloxi.IAction) {
+	self.Actions = v
+}
+
+func (self *NiciraFlowStats) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+
+	encoder.PutUint16(uint16(self.Length))
+	encoder.PutUint8(uint8(self.TableId))
+	encoder.Write(bytes.Repeat([]byte{0}, 1))
+	encoder.PutUint32(uint32(self.DurationSec))
+	encoder.PutUint32(uint32(self.DurationNsec))
+	encoder.PutUint16(uint16(self.Priority))
+	encoder.PutUint16(uint16(self.IdleTimeout))
+	encoder.PutUint16(uint16(self.HardTimeout))
+	encoder.PutUint16(uint16(self.MatchLen))
+	encoder.PutUint16(uint16(self.IdleAge))
+	encoder.PutUint16(uint16(self.HardAge))
+	encoder.PutUint64(uint64(self.Cookie))
+	encoder.PutUint64(uint64(self.PacketCount))
+	encoder.PutUint64(uint64(self.ByteCount))
+	if err := self.Match.Serialize(encoder); err != nil {
+		return err
+	}
+
+	for _, obj := range self.Actions {
+		if err := obj.Serialize(encoder); err != nil {
+			return err
+		}
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
+
+	return nil
+}
+
+func DecodeNiciraFlowStats(decoder *goloxi.Decoder) (*NiciraFlowStats, error) {
+	_niciraflowstats := &NiciraFlowStats{}
+	if decoder.Length() < 48 {
+		return nil, fmt.Errorf("NiciraFlowStats packet too short: %d < 48", decoder.Length())
+	}
+	_niciraflowstats.Length = uint16(decoder.ReadUint16())
+	oldDecoder := decoder
+	defer func() { decoder = oldDecoder }()
+	decoder = decoder.SliceDecoder(int(_niciraflowstats.Length), 2+0)
+	_niciraflowstats.TableId = uint8(decoder.ReadByte())
+	decoder.Skip(1)
+	_niciraflowstats.DurationSec = uint32(decoder.ReadUint32())
+	_niciraflowstats.DurationNsec = uint32(decoder.ReadUint32())
+	_niciraflowstats.Priority = uint16(decoder.ReadUint16())
+	_niciraflowstats.IdleTimeout = uint16(decoder.ReadUint16())
+	_niciraflowstats.HardTimeout = uint16(decoder.ReadUint16())
+	_niciraflowstats.MatchLen = uint16(decoder.ReadUint16())
+	_niciraflowstats.IdleAge = uint16(decoder.ReadUint16())
+	_niciraflowstats.HardAge = uint16(decoder.ReadUint16())
+	_niciraflowstats.Cookie = uint64(decoder.ReadUint64())
+	_niciraflowstats.PacketCount = uint64(decoder.ReadUint64())
+	_niciraflowstats.ByteCount = uint64(decoder.ReadUint64())
+	if err := _niciraflowstats.Match.Decode(decoder.SliceDecoder(int(_niciraflowstats.MatchLen), 0)); err != nil {
+		return nil, err
+	}
+
+	decoder.SkipAlign()
+
+	for decoder.Length() >= 8 {
+		item, err := DecodeAction(decoder)
+		if err != nil {
+			return nil, err
+		}
+		if item != nil {
+			_niciraflowstats.Actions = append(_niciraflowstats.Actions, item)
+		}
+	}
+	return _niciraflowstats, nil
+}
+
+func NewNiciraFlowStats() *NiciraFlowStats {
+	obj := &NiciraFlowStats{}
+	return obj
+}
+
+type NiciraFlowUpdateEvent struct {
+	Length uint16
+	Event  uint16
+}
+
+type INiciraFlowUpdateEvent interface {
+	goloxi.Serializable
+	GetLength() uint16
+	GetEvent() uint16
+}
+
+func (self *NiciraFlowUpdateEvent) GetLength() uint16 {
+	return self.Length
+}
+
+func (self *NiciraFlowUpdateEvent) SetLength(v uint16) {
+	self.Length = v
+}
+
+func (self *NiciraFlowUpdateEvent) GetEvent() uint16 {
+	return self.Event
+}
+
+func (self *NiciraFlowUpdateEvent) SetEvent(v uint16) {
+	self.Event = v
+}
+
+func (self *NiciraFlowUpdateEvent) Serialize(encoder *goloxi.Encoder) error {
+
+	encoder.PutUint16(uint16(self.Length))
+	encoder.PutUint16(uint16(self.Event))
+
+	return nil
+}
+
+func DecodeNiciraFlowUpdateEvent(decoder *goloxi.Decoder) (INiciraFlowUpdateEvent, error) {
+	_niciraflowupdateevent := &NiciraFlowUpdateEvent{}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("NiciraFlowUpdateEvent packet too short: %d < 4", decoder.Length())
+	}
+	_niciraflowupdateevent.Length = uint16(decoder.ReadUint16())
+	oldDecoder := decoder
+	defer func() { decoder = oldDecoder }()
+	decoder = decoder.SliceDecoder(int(_niciraflowupdateevent.Length), 2+0)
+	_niciraflowupdateevent.Event = uint16(decoder.ReadUint16())
+
+	switch _niciraflowupdateevent.Event {
+	case 0:
+		return DecodeNiciraFlowUpdateFullAdd(_niciraflowupdateevent, decoder)
+	case 1:
+		return DecodeNiciraFlowUpdateFullDeleted(_niciraflowupdateevent, decoder)
+	case 2:
+		return DecodeNiciraFlowUpdateFullModified(_niciraflowupdateevent, decoder)
+	default:
+		return nil, fmt.Errorf("Invalid type '%d' for 'NiciraFlowUpdateEvent'", _niciraflowupdateevent.Event)
+	}
+}
+
+func NewNiciraFlowUpdateEvent(_event uint16) *NiciraFlowUpdateEvent {
+	obj := &NiciraFlowUpdateEvent{}
+	obj.Event = _event
+	return obj
+}
+
+type NiciraFlowUpdateFullAdd struct {
+	*NiciraFlowUpdateEvent
+	Reason      uint16
+	Priority    uint16
+	IdleTimeout uint16
+	HardTimeout uint16
+	MatchLen    uint16
+	TableId     uint8
+	Cookie      uint64
+	Match       NiciraMatch
+	Actions     []goloxi.IAction
+}
+
+type INiciraFlowUpdateFullAdd interface {
+	INiciraFlowUpdateEvent
+	GetReason() uint16
+	GetPriority() uint16
+	GetIdleTimeout() uint16
+	GetHardTimeout() uint16
+	GetMatchLen() uint16
+	GetTableId() uint8
+	GetCookie() uint64
+	GetMatch() NiciraMatch
+	GetActions() []goloxi.IAction
+}
+
+func (self *NiciraFlowUpdateFullAdd) GetReason() uint16 {
+	return self.Reason
+}
+
+func (self *NiciraFlowUpdateFullAdd) SetReason(v uint16) {
+	self.Reason = v
+}
+
+func (self *NiciraFlowUpdateFullAdd) GetPriority() uint16 {
+	return self.Priority
+}
+
+func (self *NiciraFlowUpdateFullAdd) SetPriority(v uint16) {
+	self.Priority = v
+}
+
+func (self *NiciraFlowUpdateFullAdd) GetIdleTimeout() uint16 {
+	return self.IdleTimeout
+}
+
+func (self *NiciraFlowUpdateFullAdd) SetIdleTimeout(v uint16) {
+	self.IdleTimeout = v
+}
+
+func (self *NiciraFlowUpdateFullAdd) GetHardTimeout() uint16 {
+	return self.HardTimeout
+}
+
+func (self *NiciraFlowUpdateFullAdd) SetHardTimeout(v uint16) {
+	self.HardTimeout = v
+}
+
+func (self *NiciraFlowUpdateFullAdd) GetMatchLen() uint16 {
+	return self.MatchLen
+}
+
+func (self *NiciraFlowUpdateFullAdd) SetMatchLen(v uint16) {
+	self.MatchLen = v
+}
+
+func (self *NiciraFlowUpdateFullAdd) GetTableId() uint8 {
+	return self.TableId
+}
+
+func (self *NiciraFlowUpdateFullAdd) SetTableId(v uint8) {
+	self.TableId = v
+}
+
+func (self *NiciraFlowUpdateFullAdd) GetCookie() uint64 {
+	return self.Cookie
+}
+
+func (self *NiciraFlowUpdateFullAdd) SetCookie(v uint64) {
+	self.Cookie = v
+}
+
+func (self *NiciraFlowUpdateFullAdd) GetMatch() NiciraMatch {
+	return self.Match
+}
+
+func (self *NiciraFlowUpdateFullAdd) SetMatch(v NiciraMatch) {
+	self.Match = v
+}
+
+func (self *NiciraFlowUpdateFullAdd) GetActions() []goloxi.IAction {
+	return self.Actions
+}
+
+func (self *NiciraFlowUpdateFullAdd) SetActions(v []goloxi.IAction) {
+	self.Actions = v
+}
+
+func (self *NiciraFlowUpdateFullAdd) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.NiciraFlowUpdateEvent.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Reason))
+	encoder.PutUint16(uint16(self.Priority))
+	encoder.PutUint16(uint16(self.IdleTimeout))
+	encoder.PutUint16(uint16(self.HardTimeout))
+	encoder.PutUint16(uint16(self.MatchLen))
+	encoder.PutUint8(uint8(self.TableId))
+	encoder.Write(bytes.Repeat([]byte{0}, 1))
+	encoder.PutUint64(uint64(self.Cookie))
+	if err := self.Match.Serialize(encoder); err != nil {
+		return err
+	}
+
+	for _, obj := range self.Actions {
+		if err := obj.Serialize(encoder); err != nil {
+			return err
+		}
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
+
+	return nil
+}
+
+func DecodeNiciraFlowUpdateFullAdd(parent *NiciraFlowUpdateEvent, decoder *goloxi.Decoder) (*NiciraFlowUpdateFullAdd, error) {
+	_niciraflowupdatefulladd := &NiciraFlowUpdateFullAdd{NiciraFlowUpdateEvent: parent}
+	if decoder.Length() < 20 {
+		return nil, fmt.Errorf("NiciraFlowUpdateFullAdd packet too short: %d < 20", decoder.Length())
+	}
+	_niciraflowupdatefulladd.Reason = uint16(decoder.ReadUint16())
+	_niciraflowupdatefulladd.Priority = uint16(decoder.ReadUint16())
+	_niciraflowupdatefulladd.IdleTimeout = uint16(decoder.ReadUint16())
+	_niciraflowupdatefulladd.HardTimeout = uint16(decoder.ReadUint16())
+	_niciraflowupdatefulladd.MatchLen = uint16(decoder.ReadUint16())
+	_niciraflowupdatefulladd.TableId = uint8(decoder.ReadByte())
+	decoder.Skip(1)
+	_niciraflowupdatefulladd.Cookie = uint64(decoder.ReadUint64())
+	if err := _niciraflowupdatefulladd.Match.Decode(decoder.SliceDecoder(int(_niciraflowupdatefulladd.MatchLen), 0)); err != nil {
+		return nil, err
+	}
+
+	decoder.SkipAlign()
+
+	for decoder.Length() >= 8 {
+		item, err := DecodeAction(decoder)
+		if err != nil {
+			return nil, err
+		}
+		if item != nil {
+			_niciraflowupdatefulladd.Actions = append(_niciraflowupdatefulladd.Actions, item)
+		}
+	}
+	return _niciraflowupdatefulladd, nil
+}
+
+func NewNiciraFlowUpdateFullAdd() *NiciraFlowUpdateFullAdd {
+	obj := &NiciraFlowUpdateFullAdd{
+		NiciraFlowUpdateEvent: NewNiciraFlowUpdateEvent(0),
+	}
+	return obj
+}
+
+type NiciraFlowUpdateFullDeleted struct {
+	*NiciraFlowUpdateEvent
+	Reason      uint16
+	Priority    uint16
+	IdleTimeout uint16
+	HardTimeout uint16
+	MatchLen    uint16
+	TableId     uint8
+	Cookie      uint64
+	Match       NiciraMatch
+	Actions     []goloxi.IAction
+}
+
+type INiciraFlowUpdateFullDeleted interface {
+	INiciraFlowUpdateEvent
+	GetReason() uint16
+	GetPriority() uint16
+	GetIdleTimeout() uint16
+	GetHardTimeout() uint16
+	GetMatchLen() uint16
+	GetTableId() uint8
+	GetCookie() uint64
+	GetMatch() NiciraMatch
+	GetActions() []goloxi.IAction
+}
+
+func (self *NiciraFlowUpdateFullDeleted) GetReason() uint16 {
+	return self.Reason
+}
+
+func (self *NiciraFlowUpdateFullDeleted) SetReason(v uint16) {
+	self.Reason = v
+}
+
+func (self *NiciraFlowUpdateFullDeleted) GetPriority() uint16 {
+	return self.Priority
+}
+
+func (self *NiciraFlowUpdateFullDeleted) SetPriority(v uint16) {
+	self.Priority = v
+}
+
+func (self *NiciraFlowUpdateFullDeleted) GetIdleTimeout() uint16 {
+	return self.IdleTimeout
+}
+
+func (self *NiciraFlowUpdateFullDeleted) SetIdleTimeout(v uint16) {
+	self.IdleTimeout = v
+}
+
+func (self *NiciraFlowUpdateFullDeleted) GetHardTimeout() uint16 {
+	return self.HardTimeout
+}
+
+func (self *NiciraFlowUpdateFullDeleted) SetHardTimeout(v uint16) {
+	self.HardTimeout = v
+}
+
+func (self *NiciraFlowUpdateFullDeleted) GetMatchLen() uint16 {
+	return self.MatchLen
+}
+
+func (self *NiciraFlowUpdateFullDeleted) SetMatchLen(v uint16) {
+	self.MatchLen = v
+}
+
+func (self *NiciraFlowUpdateFullDeleted) GetTableId() uint8 {
+	return self.TableId
+}
+
+func (self *NiciraFlowUpdateFullDeleted) SetTableId(v uint8) {
+	self.TableId = v
+}
+
+func (self *NiciraFlowUpdateFullDeleted) GetCookie() uint64 {
+	return self.Cookie
+}
+
+func (self *NiciraFlowUpdateFullDeleted) SetCookie(v uint64) {
+	self.Cookie = v
+}
+
+func (self *NiciraFlowUpdateFullDeleted) GetMatch() NiciraMatch {
+	return self.Match
+}
+
+func (self *NiciraFlowUpdateFullDeleted) SetMatch(v NiciraMatch) {
+	self.Match = v
+}
+
+func (self *NiciraFlowUpdateFullDeleted) GetActions() []goloxi.IAction {
+	return self.Actions
+}
+
+func (self *NiciraFlowUpdateFullDeleted) SetActions(v []goloxi.IAction) {
+	self.Actions = v
+}
+
+func (self *NiciraFlowUpdateFullDeleted) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.NiciraFlowUpdateEvent.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Reason))
+	encoder.PutUint16(uint16(self.Priority))
+	encoder.PutUint16(uint16(self.IdleTimeout))
+	encoder.PutUint16(uint16(self.HardTimeout))
+	encoder.PutUint16(uint16(self.MatchLen))
+	encoder.PutUint8(uint8(self.TableId))
+	encoder.Write(bytes.Repeat([]byte{0}, 1))
+	encoder.PutUint64(uint64(self.Cookie))
+	if err := self.Match.Serialize(encoder); err != nil {
+		return err
+	}
+
+	for _, obj := range self.Actions {
+		if err := obj.Serialize(encoder); err != nil {
+			return err
+		}
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
+
+	return nil
+}
+
+func DecodeNiciraFlowUpdateFullDeleted(parent *NiciraFlowUpdateEvent, decoder *goloxi.Decoder) (*NiciraFlowUpdateFullDeleted, error) {
+	_niciraflowupdatefulldeleted := &NiciraFlowUpdateFullDeleted{NiciraFlowUpdateEvent: parent}
+	if decoder.Length() < 20 {
+		return nil, fmt.Errorf("NiciraFlowUpdateFullDeleted packet too short: %d < 20", decoder.Length())
+	}
+	_niciraflowupdatefulldeleted.Reason = uint16(decoder.ReadUint16())
+	_niciraflowupdatefulldeleted.Priority = uint16(decoder.ReadUint16())
+	_niciraflowupdatefulldeleted.IdleTimeout = uint16(decoder.ReadUint16())
+	_niciraflowupdatefulldeleted.HardTimeout = uint16(decoder.ReadUint16())
+	_niciraflowupdatefulldeleted.MatchLen = uint16(decoder.ReadUint16())
+	_niciraflowupdatefulldeleted.TableId = uint8(decoder.ReadByte())
+	decoder.Skip(1)
+	_niciraflowupdatefulldeleted.Cookie = uint64(decoder.ReadUint64())
+	if err := _niciraflowupdatefulldeleted.Match.Decode(decoder.SliceDecoder(int(_niciraflowupdatefulldeleted.MatchLen), 0)); err != nil {
+		return nil, err
+	}
+
+	decoder.SkipAlign()
+
+	for decoder.Length() >= 8 {
+		item, err := DecodeAction(decoder)
+		if err != nil {
+			return nil, err
+		}
+		if item != nil {
+			_niciraflowupdatefulldeleted.Actions = append(_niciraflowupdatefulldeleted.Actions, item)
+		}
+	}
+	return _niciraflowupdatefulldeleted, nil
+}
+
+func NewNiciraFlowUpdateFullDeleted() *NiciraFlowUpdateFullDeleted {
+	obj := &NiciraFlowUpdateFullDeleted{
+		NiciraFlowUpdateEvent: NewNiciraFlowUpdateEvent(1),
+	}
+	return obj
+}
+
+type NiciraFlowUpdateFullModified struct {
+	*NiciraFlowUpdateEvent
+	Reason      uint16
+	Priority    uint16
+	IdleTimeout uint16
+	HardTimeout uint16
+	MatchLen    uint16
+	TableId     uint8
+	Cookie      uint64
+	Match       NiciraMatch
+	Actions     []goloxi.IAction
+}
+
+type INiciraFlowUpdateFullModified interface {
+	INiciraFlowUpdateEvent
+	GetReason() uint16
+	GetPriority() uint16
+	GetIdleTimeout() uint16
+	GetHardTimeout() uint16
+	GetMatchLen() uint16
+	GetTableId() uint8
+	GetCookie() uint64
+	GetMatch() NiciraMatch
+	GetActions() []goloxi.IAction
+}
+
+func (self *NiciraFlowUpdateFullModified) GetReason() uint16 {
+	return self.Reason
+}
+
+func (self *NiciraFlowUpdateFullModified) SetReason(v uint16) {
+	self.Reason = v
+}
+
+func (self *NiciraFlowUpdateFullModified) GetPriority() uint16 {
+	return self.Priority
+}
+
+func (self *NiciraFlowUpdateFullModified) SetPriority(v uint16) {
+	self.Priority = v
+}
+
+func (self *NiciraFlowUpdateFullModified) GetIdleTimeout() uint16 {
+	return self.IdleTimeout
+}
+
+func (self *NiciraFlowUpdateFullModified) SetIdleTimeout(v uint16) {
+	self.IdleTimeout = v
+}
+
+func (self *NiciraFlowUpdateFullModified) GetHardTimeout() uint16 {
+	return self.HardTimeout
+}
+
+func (self *NiciraFlowUpdateFullModified) SetHardTimeout(v uint16) {
+	self.HardTimeout = v
+}
+
+func (self *NiciraFlowUpdateFullModified) GetMatchLen() uint16 {
+	return self.MatchLen
+}
+
+func (self *NiciraFlowUpdateFullModified) SetMatchLen(v uint16) {
+	self.MatchLen = v
+}
+
+func (self *NiciraFlowUpdateFullModified) GetTableId() uint8 {
+	return self.TableId
+}
+
+func (self *NiciraFlowUpdateFullModified) SetTableId(v uint8) {
+	self.TableId = v
+}
+
+func (self *NiciraFlowUpdateFullModified) GetCookie() uint64 {
+	return self.Cookie
+}
+
+func (self *NiciraFlowUpdateFullModified) SetCookie(v uint64) {
+	self.Cookie = v
+}
+
+func (self *NiciraFlowUpdateFullModified) GetMatch() NiciraMatch {
+	return self.Match
+}
+
+func (self *NiciraFlowUpdateFullModified) SetMatch(v NiciraMatch) {
+	self.Match = v
+}
+
+func (self *NiciraFlowUpdateFullModified) GetActions() []goloxi.IAction {
+	return self.Actions
+}
+
+func (self *NiciraFlowUpdateFullModified) SetActions(v []goloxi.IAction) {
+	self.Actions = v
+}
+
+func (self *NiciraFlowUpdateFullModified) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.NiciraFlowUpdateEvent.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Reason))
+	encoder.PutUint16(uint16(self.Priority))
+	encoder.PutUint16(uint16(self.IdleTimeout))
+	encoder.PutUint16(uint16(self.HardTimeout))
+	encoder.PutUint16(uint16(self.MatchLen))
+	encoder.PutUint8(uint8(self.TableId))
+	encoder.Write(bytes.Repeat([]byte{0}, 1))
+	encoder.PutUint64(uint64(self.Cookie))
+	if err := self.Match.Serialize(encoder); err != nil {
+		return err
+	}
+
+	for _, obj := range self.Actions {
+		if err := obj.Serialize(encoder); err != nil {
+			return err
+		}
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
+
+	return nil
+}
+
+func DecodeNiciraFlowUpdateFullModified(parent *NiciraFlowUpdateEvent, decoder *goloxi.Decoder) (*NiciraFlowUpdateFullModified, error) {
+	_niciraflowupdatefullmodified := &NiciraFlowUpdateFullModified{NiciraFlowUpdateEvent: parent}
+	if decoder.Length() < 20 {
+		return nil, fmt.Errorf("NiciraFlowUpdateFullModified packet too short: %d < 20", decoder.Length())
+	}
+	_niciraflowupdatefullmodified.Reason = uint16(decoder.ReadUint16())
+	_niciraflowupdatefullmodified.Priority = uint16(decoder.ReadUint16())
+	_niciraflowupdatefullmodified.IdleTimeout = uint16(decoder.ReadUint16())
+	_niciraflowupdatefullmodified.HardTimeout = uint16(decoder.ReadUint16())
+	_niciraflowupdatefullmodified.MatchLen = uint16(decoder.ReadUint16())
+	_niciraflowupdatefullmodified.TableId = uint8(decoder.ReadByte())
+	decoder.Skip(1)
+	_niciraflowupdatefullmodified.Cookie = uint64(decoder.ReadUint64())
+	if err := _niciraflowupdatefullmodified.Match.Decode(decoder.SliceDecoder(int(_niciraflowupdatefullmodified.MatchLen), 0)); err != nil {
+		return nil, err
+	}
+
+	decoder.SkipAlign()
+
+	for decoder.Length() >= 8 {
+		item, err := DecodeAction(decoder)
+		if err != nil {
+			return nil, err
+		}
+		if item != nil {
+			_niciraflowupdatefullmodified.Actions = append(_niciraflowupdatefullmodified.Actions, item)
+		}
+	}
+	return _niciraflowupdatefullmodified, nil
+}
+
+func NewNiciraFlowUpdateFullModified() *NiciraFlowUpdateFullModified {
+	obj := &NiciraFlowUpdateFullModified{
+		NiciraFlowUpdateEvent: NewNiciraFlowUpdateEvent(2),
+	}
+	return obj
+}
+
+type OxmIdArpOp struct {
+	*OxmId
+}
+
+type IOxmIdArpOp interface {
+	IOxmId
+}
+
+func (self *OxmIdArpOp) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdArpOp(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpOp, error) {
+	_oxmidarpop := &OxmIdArpOp{OxmId: parent}
+	return _oxmidarpop, nil
+}
+
+func NewOxmIdArpOp() *OxmIdArpOp {
+	obj := &OxmIdArpOp{
+		OxmId: NewOxmId(7682),
+	}
+	return obj
+}
+func (self *OxmIdArpOp) GetOXMName() string {
+	return "arp_op"
+}
+
+func (self *OxmIdArpOp) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdArpSha struct {
+	*OxmId
+}
+
+type IOxmIdArpSha interface {
+	IOxmId
+}
+
+func (self *OxmIdArpSha) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdArpSha(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpSha, error) {
+	_oxmidarpsha := &OxmIdArpSha{OxmId: parent}
+	return _oxmidarpsha, nil
+}
+
+func NewOxmIdArpSha() *OxmIdArpSha {
+	obj := &OxmIdArpSha{
+		OxmId: NewOxmId(74246),
+	}
+	return obj
+}
+func (self *OxmIdArpSha) GetOXMName() string {
+	return "arp_sha"
+}
+
+func (self *OxmIdArpSha) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdArpShaMasked struct {
+	*OxmId
+}
+
+type IOxmIdArpShaMasked interface {
+	IOxmId
+}
+
+func (self *OxmIdArpShaMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdArpShaMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpShaMasked, error) {
+	_oxmidarpshamasked := &OxmIdArpShaMasked{OxmId: parent}
+	return _oxmidarpshamasked, nil
+}
+
+func NewOxmIdArpShaMasked() *OxmIdArpShaMasked {
+	obj := &OxmIdArpShaMasked{
+		OxmId: NewOxmId(74507),
+	}
+	return obj
+}
+func (self *OxmIdArpShaMasked) GetOXMName() string {
+	return "arp_sha_masked"
+}
+
+func (self *OxmIdArpShaMasked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdArpSpa struct {
+	*OxmId
+}
+
+type IOxmIdArpSpa interface {
+	IOxmId
+}
+
+func (self *OxmIdArpSpa) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdArpSpa(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpSpa, error) {
+	_oxmidarpspa := &OxmIdArpSpa{OxmId: parent}
+	return _oxmidarpspa, nil
+}
+
+func NewOxmIdArpSpa() *OxmIdArpSpa {
+	obj := &OxmIdArpSpa{
+		OxmId: NewOxmId(8196),
+	}
+	return obj
+}
+func (self *OxmIdArpSpa) GetOXMName() string {
+	return "arp_spa"
+}
+
+func (self *OxmIdArpSpa) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdArpSpaMasked struct {
+	*OxmId
+}
+
+type IOxmIdArpSpaMasked interface {
+	IOxmId
+}
+
+func (self *OxmIdArpSpaMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdArpSpaMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpSpaMasked, error) {
+	_oxmidarpspamasked := &OxmIdArpSpaMasked{OxmId: parent}
+	return _oxmidarpspamasked, nil
+}
+
+func NewOxmIdArpSpaMasked() *OxmIdArpSpaMasked {
+	obj := &OxmIdArpSpaMasked{
+		OxmId: NewOxmId(8452),
+	}
+	return obj
+}
+func (self *OxmIdArpSpaMasked) GetOXMName() string {
+	return "arp_spa_masked"
+}
+
+func (self *OxmIdArpSpaMasked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdArpTha struct {
+	*OxmId
+}
+
+type IOxmIdArpTha interface {
+	IOxmId
+}
+
+func (self *OxmIdArpTha) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdArpTha(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpTha, error) {
+	_oxmidarptha := &OxmIdArpTha{OxmId: parent}
+	return _oxmidarptha, nil
+}
+
+func NewOxmIdArpTha() *OxmIdArpTha {
+	obj := &OxmIdArpTha{
+		OxmId: NewOxmId(74758),
+	}
+	return obj
+}
+func (self *OxmIdArpTha) GetOXMName() string {
+	return "arp_tha"
+}
+
+func (self *OxmIdArpTha) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdArpThaMasked struct {
+	*OxmId
+}
+
+type IOxmIdArpThaMasked interface {
+	IOxmId
+}
+
+func (self *OxmIdArpThaMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdArpThaMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpThaMasked, error) {
+	_oxmidarpthamasked := &OxmIdArpThaMasked{OxmId: parent}
+	return _oxmidarpthamasked, nil
+}
+
+func NewOxmIdArpThaMasked() *OxmIdArpThaMasked {
+	obj := &OxmIdArpThaMasked{
+		OxmId: NewOxmId(75019),
+	}
+	return obj
+}
+func (self *OxmIdArpThaMasked) GetOXMName() string {
+	return "arp_tha_masked"
+}
+
+func (self *OxmIdArpThaMasked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdArpTpa struct {
+	*OxmId
+}
+
+type IOxmIdArpTpa interface {
+	IOxmId
+}
+
+func (self *OxmIdArpTpa) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdArpTpa(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpTpa, error) {
+	_oxmidarptpa := &OxmIdArpTpa{OxmId: parent}
+	return _oxmidarptpa, nil
+}
+
+func NewOxmIdArpTpa() *OxmIdArpTpa {
+	obj := &OxmIdArpTpa{
+		OxmId: NewOxmId(8708),
+	}
+	return obj
+}
+func (self *OxmIdArpTpa) GetOXMName() string {
+	return "arp_tpa"
+}
+
+func (self *OxmIdArpTpa) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdArpTpaMasked struct {
+	*OxmId
+}
+
+type IOxmIdArpTpaMasked interface {
+	IOxmId
+}
+
+func (self *OxmIdArpTpaMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdArpTpaMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpTpaMasked, error) {
+	_oxmidarptpamasked := &OxmIdArpTpaMasked{OxmId: parent}
+	return _oxmidarptpamasked, nil
+}
+
+func NewOxmIdArpTpaMasked() *OxmIdArpTpaMasked {
+	obj := &OxmIdArpTpaMasked{
+		OxmId: NewOxmId(8968),
+	}
+	return obj
+}
+func (self *OxmIdArpTpaMasked) GetOXMName() string {
+	return "arp_tpa_masked"
+}
+
+func (self *OxmIdArpTpaMasked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdConjId struct {
+	*OxmId
+}
+
+type IOxmIdConjId interface {
+	IOxmId
+}
+
+func (self *OxmIdConjId) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdConjId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConjId, error) {
+	_oxmidconjid := &OxmIdConjId{OxmId: parent}
+	return _oxmidconjid, nil
+}
+
+func NewOxmIdConjId() *OxmIdConjId {
+	obj := &OxmIdConjId{
+		OxmId: NewOxmId(84484),
+	}
+	return obj
+}
+func (self *OxmIdConjId) GetOXMName() string {
+	return "conj_id"
+}
+
+func (self *OxmIdConjId) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdCtIpv6Dst struct {
+	*OxmId
+}
+
+type IOxmIdCtIpv6Dst interface {
+	IOxmId
+}
+
+func (self *OxmIdCtIpv6Dst) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdCtIpv6Dst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtIpv6Dst, error) {
+	_oxmidctipv6dst := &OxmIdCtIpv6Dst{OxmId: parent}
+	return _oxmidctipv6dst, nil
+}
+
+func NewOxmIdCtIpv6Dst() *OxmIdCtIpv6Dst {
+	obj := &OxmIdCtIpv6Dst{
+		OxmId: NewOxmId(128528),
+	}
+	return obj
+}
+func (self *OxmIdCtIpv6Dst) GetOXMName() string {
+	return "ct_ipv6_dst"
+}
+
+func (self *OxmIdCtIpv6Dst) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdCtIpv6DstMasked struct {
+	*OxmId
+}
+
+type IOxmIdCtIpv6DstMasked interface {
+	IOxmId
+}
+
+func (self *OxmIdCtIpv6DstMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdCtIpv6DstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtIpv6DstMasked, error) {
+	_oxmidctipv6dstmasked := &OxmIdCtIpv6DstMasked{OxmId: parent}
+	return _oxmidctipv6dstmasked, nil
+}
+
+func NewOxmIdCtIpv6DstMasked() *OxmIdCtIpv6DstMasked {
+	obj := &OxmIdCtIpv6DstMasked{
+		OxmId: NewOxmId(128800),
+	}
+	return obj
+}
+func (self *OxmIdCtIpv6DstMasked) GetOXMName() string {
+	return "ct_ipv6_dst_masked"
+}
+
+func (self *OxmIdCtIpv6DstMasked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdCtIpv6Src struct {
+	*OxmId
+}
+
+type IOxmIdCtIpv6Src interface {
+	IOxmId
+}
+
+func (self *OxmIdCtIpv6Src) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdCtIpv6Src(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtIpv6Src, error) {
+	_oxmidctipv6src := &OxmIdCtIpv6Src{OxmId: parent}
+	return _oxmidctipv6src, nil
+}
+
+func NewOxmIdCtIpv6Src() *OxmIdCtIpv6Src {
+	obj := &OxmIdCtIpv6Src{
+		OxmId: NewOxmId(128016),
+	}
+	return obj
+}
+func (self *OxmIdCtIpv6Src) GetOXMName() string {
+	return "ct_ipv6_src"
+}
+
+func (self *OxmIdCtIpv6Src) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdCtIpv6SrcMasked struct {
+	*OxmId
+}
+
+type IOxmIdCtIpv6SrcMasked interface {
+	IOxmId
+}
+
+func (self *OxmIdCtIpv6SrcMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdCtIpv6SrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtIpv6SrcMasked, error) {
+	_oxmidctipv6srcmasked := &OxmIdCtIpv6SrcMasked{OxmId: parent}
+	return _oxmidctipv6srcmasked, nil
+}
+
+func NewOxmIdCtIpv6SrcMasked() *OxmIdCtIpv6SrcMasked {
+	obj := &OxmIdCtIpv6SrcMasked{
+		OxmId: NewOxmId(128288),
+	}
+	return obj
+}
+func (self *OxmIdCtIpv6SrcMasked) GetOXMName() string {
+	return "ct_ipv6_src_masked"
+}
+
+func (self *OxmIdCtIpv6SrcMasked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdCtLabel struct {
+	*OxmId
+}
+
+type IOxmIdCtLabel interface {
+	IOxmId
+}
+
+func (self *OxmIdCtLabel) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdCtLabel(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtLabel, error) {
+	_oxmidctlabel := &OxmIdCtLabel{OxmId: parent}
+	return _oxmidctlabel, nil
+}
+
+func NewOxmIdCtLabel() *OxmIdCtLabel {
+	obj := &OxmIdCtLabel{
+		OxmId: NewOxmId(120848),
+	}
+	return obj
+}
+func (self *OxmIdCtLabel) GetOXMName() string {
+	return "ct_label"
+}
+
+func (self *OxmIdCtLabel) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdCtLabelMasked struct {
+	*OxmId
+}
+
+type IOxmIdCtLabelMasked interface {
+	IOxmId
+}
+
+func (self *OxmIdCtLabelMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdCtLabelMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtLabelMasked, error) {
+	_oxmidctlabelmasked := &OxmIdCtLabelMasked{OxmId: parent}
+	return _oxmidctlabelmasked, nil
+}
+
+func NewOxmIdCtLabelMasked() *OxmIdCtLabelMasked {
+	obj := &OxmIdCtLabelMasked{
+		OxmId: NewOxmId(121120),
+	}
+	return obj
+}
+func (self *OxmIdCtLabelMasked) GetOXMName() string {
+	return "ct_label_masked"
+}
+
+func (self *OxmIdCtLabelMasked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdCtMark struct {
+	*OxmId
+}
+
+type IOxmIdCtMark interface {
+	IOxmId
+}
+
+func (self *OxmIdCtMark) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdCtMark(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtMark, error) {
+	_oxmidctmark := &OxmIdCtMark{OxmId: parent}
+	return _oxmidctmark, nil
+}
+
+func NewOxmIdCtMark() *OxmIdCtMark {
+	obj := &OxmIdCtMark{
+		OxmId: NewOxmId(120324),
+	}
+	return obj
+}
+func (self *OxmIdCtMark) GetOXMName() string {
+	return "ct_mark"
+}
+
+func (self *OxmIdCtMark) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdCtMarkMasked struct {
+	*OxmId
+}
+
+type IOxmIdCtMarkMasked interface {
+	IOxmId
+}
+
+func (self *OxmIdCtMarkMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdCtMarkMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtMarkMasked, error) {
+	_oxmidctmarkmasked := &OxmIdCtMarkMasked{OxmId: parent}
+	return _oxmidctmarkmasked, nil
+}
+
+func NewOxmIdCtMarkMasked() *OxmIdCtMarkMasked {
+	obj := &OxmIdCtMarkMasked{
+		OxmId: NewOxmId(120584),
+	}
+	return obj
+}
+func (self *OxmIdCtMarkMasked) GetOXMName() string {
+	return "ct_mark_masked"
+}
+
+func (self *OxmIdCtMarkMasked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdCtNwDst struct {
+	*OxmId
+}
+
+type IOxmIdCtNwDst interface {
+	IOxmId
+}
+
+func (self *OxmIdCtNwDst) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdCtNwDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtNwDst, error) {
+	_oxmidctnwdst := &OxmIdCtNwDst{OxmId: parent}
+	return _oxmidctnwdst, nil
+}
+
+func NewOxmIdCtNwDst() *OxmIdCtNwDst {
+	obj := &OxmIdCtNwDst{
+		OxmId: NewOxmId(127492),
+	}
+	return obj
+}
+func (self *OxmIdCtNwDst) GetOXMName() string {
+	return "ct_nw_dst"
+}
+
+func (self *OxmIdCtNwDst) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdCtNwDstMasked struct {
+	*OxmId
+}
+
+type IOxmIdCtNwDstMasked interface {
+	IOxmId
+}
+
+func (self *OxmIdCtNwDstMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdCtNwDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtNwDstMasked, error) {
+	_oxmidctnwdstmasked := &OxmIdCtNwDstMasked{OxmId: parent}
+	return _oxmidctnwdstmasked, nil
+}
+
+func NewOxmIdCtNwDstMasked() *OxmIdCtNwDstMasked {
+	obj := &OxmIdCtNwDstMasked{
+		OxmId: NewOxmId(127752),
+	}
+	return obj
+}
+func (self *OxmIdCtNwDstMasked) GetOXMName() string {
+	return "ct_nw_dst_masked"
+}
+
+func (self *OxmIdCtNwDstMasked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdCtNwProto struct {
+	*OxmId
+}
+
+type IOxmIdCtNwProto interface {
+	IOxmId
+}
+
+func (self *OxmIdCtNwProto) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdCtNwProto(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtNwProto, error) {
+	_oxmidctnwproto := &OxmIdCtNwProto{OxmId: parent}
+	return _oxmidctnwproto, nil
+}
+
+func NewOxmIdCtNwProto() *OxmIdCtNwProto {
+	obj := &OxmIdCtNwProto{
+		OxmId: NewOxmId(126465),
+	}
+	return obj
+}
+func (self *OxmIdCtNwProto) GetOXMName() string {
+	return "ct_nw_proto"
+}
+
+func (self *OxmIdCtNwProto) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdCtNwSrc struct {
+	*OxmId
+}
+
+type IOxmIdCtNwSrc interface {
+	IOxmId
+}
+
+func (self *OxmIdCtNwSrc) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdCtNwSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtNwSrc, error) {
+	_oxmidctnwsrc := &OxmIdCtNwSrc{OxmId: parent}
+	return _oxmidctnwsrc, nil
+}
+
+func NewOxmIdCtNwSrc() *OxmIdCtNwSrc {
+	obj := &OxmIdCtNwSrc{
+		OxmId: NewOxmId(126980),
+	}
+	return obj
+}
+func (self *OxmIdCtNwSrc) GetOXMName() string {
+	return "ct_nw_src"
+}
+
+func (self *OxmIdCtNwSrc) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdCtNwSrcMasked struct {
+	*OxmId
+}
+
+type IOxmIdCtNwSrcMasked interface {
+	IOxmId
+}
+
+func (self *OxmIdCtNwSrcMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdCtNwSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtNwSrcMasked, error) {
+	_oxmidctnwsrcmasked := &OxmIdCtNwSrcMasked{OxmId: parent}
+	return _oxmidctnwsrcmasked, nil
+}
+
+func NewOxmIdCtNwSrcMasked() *OxmIdCtNwSrcMasked {
+	obj := &OxmIdCtNwSrcMasked{
+		OxmId: NewOxmId(127240),
+	}
+	return obj
+}
+func (self *OxmIdCtNwSrcMasked) GetOXMName() string {
+	return "ct_nw_src_masked"
+}
+
+func (self *OxmIdCtNwSrcMasked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdCtState struct {
+	*OxmId
+}
+
+type IOxmIdCtState interface {
+	IOxmId
+}
+
+func (self *OxmIdCtState) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdCtState(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtState, error) {
+	_oxmidctstate := &OxmIdCtState{OxmId: parent}
+	return _oxmidctstate, nil
+}
+
+func NewOxmIdCtState() *OxmIdCtState {
+	obj := &OxmIdCtState{
+		OxmId: NewOxmId(119300),
+	}
+	return obj
+}
+func (self *OxmIdCtState) GetOXMName() string {
+	return "ct_state"
+}
+
+func (self *OxmIdCtState) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdCtStateMasked struct {
+	*OxmId
+}
+
+type IOxmIdCtStateMasked interface {
+	IOxmId
+}
+
+func (self *OxmIdCtStateMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdCtStateMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtStateMasked, error) {
+	_oxmidctstatemasked := &OxmIdCtStateMasked{OxmId: parent}
+	return _oxmidctstatemasked, nil
+}
+
+func NewOxmIdCtStateMasked() *OxmIdCtStateMasked {
+	obj := &OxmIdCtStateMasked{
+		OxmId: NewOxmId(119560),
+	}
+	return obj
+}
+func (self *OxmIdCtStateMasked) GetOXMName() string {
+	return "ct_state_masked"
+}
+
+func (self *OxmIdCtStateMasked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdCtTpDst struct {
+	*OxmId
+}
+
+type IOxmIdCtTpDst interface {
+	IOxmId
+}
+
+func (self *OxmIdCtTpDst) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdCtTpDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtTpDst, error) {
+	_oxmidcttpdst := &OxmIdCtTpDst{OxmId: parent}
+	return _oxmidcttpdst, nil
+}
+
+func NewOxmIdCtTpDst() *OxmIdCtTpDst {
+	obj := &OxmIdCtTpDst{
+		OxmId: NewOxmId(129538),
+	}
+	return obj
+}
+func (self *OxmIdCtTpDst) GetOXMName() string {
+	return "ct_tp_dst"
+}
+
+func (self *OxmIdCtTpDst) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdCtTpDstMasked struct {
+	*OxmId
+}
+
+type IOxmIdCtTpDstMasked interface {
+	IOxmId
+}
+
+func (self *OxmIdCtTpDstMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdCtTpDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtTpDstMasked, error) {
+	_oxmidcttpdstmasked := &OxmIdCtTpDstMasked{OxmId: parent}
+	return _oxmidcttpdstmasked, nil
+}
+
+func NewOxmIdCtTpDstMasked() *OxmIdCtTpDstMasked {
+	obj := &OxmIdCtTpDstMasked{
+		OxmId: NewOxmId(129796),
+	}
+	return obj
+}
+func (self *OxmIdCtTpDstMasked) GetOXMName() string {
+	return "ct_tp_dst_masked"
+}
+
+func (self *OxmIdCtTpDstMasked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdCtTpSrc struct {
+	*OxmId
+}
+
+type IOxmIdCtTpSrc interface {
+	IOxmId
+}
+
+func (self *OxmIdCtTpSrc) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdCtTpSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtTpSrc, error) {
+	_oxmidcttpsrc := &OxmIdCtTpSrc{OxmId: parent}
+	return _oxmidcttpsrc, nil
+}
+
+func NewOxmIdCtTpSrc() *OxmIdCtTpSrc {
+	obj := &OxmIdCtTpSrc{
+		OxmId: NewOxmId(129026),
+	}
+	return obj
+}
+func (self *OxmIdCtTpSrc) GetOXMName() string {
+	return "ct_tp_src"
+}
+
+func (self *OxmIdCtTpSrc) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdCtTpSrcMasked struct {
+	*OxmId
+}
+
+type IOxmIdCtTpSrcMasked interface {
+	IOxmId
+}
+
+func (self *OxmIdCtTpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdCtTpSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtTpSrcMasked, error) {
+	_oxmidcttpsrcmasked := &OxmIdCtTpSrcMasked{OxmId: parent}
+	return _oxmidcttpsrcmasked, nil
+}
+
+func NewOxmIdCtTpSrcMasked() *OxmIdCtTpSrcMasked {
+	obj := &OxmIdCtTpSrcMasked{
+		OxmId: NewOxmId(129284),
+	}
+	return obj
+}
+func (self *OxmIdCtTpSrcMasked) GetOXMName() string {
+	return "ct_tp_src_masked"
+}
+
+func (self *OxmIdCtTpSrcMasked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdCtZone struct {
+	*OxmId
+}
+
+type IOxmIdCtZone interface {
+	IOxmId
+}
+
+func (self *OxmIdCtZone) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdCtZone(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtZone, error) {
+	_oxmidctzone := &OxmIdCtZone{OxmId: parent}
+	return _oxmidctzone, nil
+}
+
+func NewOxmIdCtZone() *OxmIdCtZone {
+	obj := &OxmIdCtZone{
+		OxmId: NewOxmId(119810),
+	}
+	return obj
+}
+func (self *OxmIdCtZone) GetOXMName() string {
+	return "ct_zone"
+}
+
+func (self *OxmIdCtZone) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdDpHash struct {
+	*OxmId
+}
+
+type IOxmIdDpHash interface {
+	IOxmId
+}
+
+func (self *OxmIdDpHash) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdDpHash(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdDpHash, error) {
+	_oxmiddphash := &OxmIdDpHash{OxmId: parent}
+	return _oxmiddphash, nil
+}
+
+func NewOxmIdDpHash() *OxmIdDpHash {
+	obj := &OxmIdDpHash{
+		OxmId: NewOxmId(83460),
+	}
+	return obj
+}
+func (self *OxmIdDpHash) GetOXMName() string {
+	return "dp_hash"
+}
+
+func (self *OxmIdDpHash) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdDpHashMasked struct {
+	*OxmId
+}
+
+type IOxmIdDpHashMasked interface {
+	IOxmId
+}
+
+func (self *OxmIdDpHashMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdDpHashMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdDpHashMasked, error) {
+	_oxmiddphashmasked := &OxmIdDpHashMasked{OxmId: parent}
+	return _oxmiddphashmasked, nil
+}
+
+func NewOxmIdDpHashMasked() *OxmIdDpHashMasked {
+	obj := &OxmIdDpHashMasked{
+		OxmId: NewOxmId(83720),
+	}
+	return obj
+}
+func (self *OxmIdDpHashMasked) GetOXMName() string {
+	return "dp_hash_masked"
+}
+
+func (self *OxmIdDpHashMasked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdEthDst struct {
+	*OxmId
+}
+
+type IOxmIdEthDst interface {
+	IOxmId
+}
+
+func (self *OxmIdEthDst) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdEthDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdEthDst, error) {
+	_oxmidethdst := &OxmIdEthDst{OxmId: parent}
+	return _oxmidethdst, nil
+}
+
+func NewOxmIdEthDst() *OxmIdEthDst {
+	obj := &OxmIdEthDst{
+		OxmId: NewOxmId(518),
+	}
+	return obj
+}
+func (self *OxmIdEthDst) GetOXMName() string {
+	return "eth_dst"
+}
+
+func (self *OxmIdEthDst) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdEthDstMasked struct {
+	*OxmId
+}
+
+type IOxmIdEthDstMasked interface {
+	IOxmId
+}
+
+func (self *OxmIdEthDstMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdEthDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdEthDstMasked, error) {
+	_oxmidethdstmasked := &OxmIdEthDstMasked{OxmId: parent}
+	return _oxmidethdstmasked, nil
+}
+
+func NewOxmIdEthDstMasked() *OxmIdEthDstMasked {
+	obj := &OxmIdEthDstMasked{
+		OxmId: NewOxmId(779),
+	}
+	return obj
+}
+func (self *OxmIdEthDstMasked) GetOXMName() string {
+	return "eth_dst_masked"
+}
+
+func (self *OxmIdEthDstMasked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdEthSrc struct {
+	*OxmId
+}
+
+type IOxmIdEthSrc interface {
+	IOxmId
+}
+
+func (self *OxmIdEthSrc) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdEthSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdEthSrc, error) {
+	_oxmidethsrc := &OxmIdEthSrc{OxmId: parent}
+	return _oxmidethsrc, nil
+}
+
+func NewOxmIdEthSrc() *OxmIdEthSrc {
+	obj := &OxmIdEthSrc{
+		OxmId: NewOxmId(1030),
+	}
+	return obj
+}
+func (self *OxmIdEthSrc) GetOXMName() string {
+	return "eth_src"
+}
+
+func (self *OxmIdEthSrc) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdEthSrcMasked struct {
+	*OxmId
+}
+
+type IOxmIdEthSrcMasked interface {
+	IOxmId
+}
+
+func (self *OxmIdEthSrcMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdEthSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdEthSrcMasked, error) {
+	_oxmidethsrcmasked := &OxmIdEthSrcMasked{OxmId: parent}
+	return _oxmidethsrcmasked, nil
+}
+
+func NewOxmIdEthSrcMasked() *OxmIdEthSrcMasked {
+	obj := &OxmIdEthSrcMasked{
+		OxmId: NewOxmId(1286),
+	}
+	return obj
+}
+func (self *OxmIdEthSrcMasked) GetOXMName() string {
+	return "eth_src_masked"
+}
+
+func (self *OxmIdEthSrcMasked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdEthType struct {
+	*OxmId
+}
+
+type IOxmIdEthType interface {
+	IOxmId
+}
+
+func (self *OxmIdEthType) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdEthType(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdEthType, error) {
+	_oxmidethtype := &OxmIdEthType{OxmId: parent}
+	return _oxmidethtype, nil
+}
+
+func NewOxmIdEthType() *OxmIdEthType {
+	obj := &OxmIdEthType{
+		OxmId: NewOxmId(1538),
+	}
+	return obj
+}
+func (self *OxmIdEthType) GetOXMName() string {
+	return "eth_type"
+}
+
+func (self *OxmIdEthType) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdIcmpCode struct {
+	*OxmId
+}
+
+type IOxmIdIcmpCode interface {
+	IOxmId
+}
+
+func (self *OxmIdIcmpCode) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdIcmpCode(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpCode, error) {
+	_oxmidicmpcode := &OxmIdIcmpCode{OxmId: parent}
+	return _oxmidicmpcode, nil
+}
+
+func NewOxmIdIcmpCode() *OxmIdIcmpCode {
+	obj := &OxmIdIcmpCode{
+		OxmId: NewOxmId(7169),
+	}
+	return obj
+}
+func (self *OxmIdIcmpCode) GetOXMName() string {
+	return "icmp_code"
+}
+
+func (self *OxmIdIcmpCode) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdIcmpType struct {
+	*OxmId
+}
+
+type IOxmIdIcmpType interface {
+	IOxmId
+}
+
+func (self *OxmIdIcmpType) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdIcmpType(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpType, error) {
+	_oxmidicmptype := &OxmIdIcmpType{OxmId: parent}
+	return _oxmidicmptype, nil
+}
+
+func NewOxmIdIcmpType() *OxmIdIcmpType {
+	obj := &OxmIdIcmpType{
+		OxmId: NewOxmId(6657),
+	}
+	return obj
+}
+func (self *OxmIdIcmpType) GetOXMName() string {
+	return "icmp_type"
+}
+
+func (self *OxmIdIcmpType) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdIcmpv6Code struct {
+	*OxmId
+}
+
+type IOxmIdIcmpv6Code interface {
+	IOxmId
+}
+
+func (self *OxmIdIcmpv6Code) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdIcmpv6Code(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv6Code, error) {
+	_oxmidicmpv6code := &OxmIdIcmpv6Code{OxmId: parent}
+	return _oxmidicmpv6code, nil
+}
+
+func NewOxmIdIcmpv6Code() *OxmIdIcmpv6Code {
+	obj := &OxmIdIcmpv6Code{
+		OxmId: NewOxmId(76801),
+	}
+	return obj
+}
+func (self *OxmIdIcmpv6Code) GetOXMName() string {
+	return "icmpv6_code"
+}
+
+func (self *OxmIdIcmpv6Code) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdIcmpv6Type struct {
+	*OxmId
+}
+
+type IOxmIdIcmpv6Type interface {
+	IOxmId
+}
+
+func (self *OxmIdIcmpv6Type) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdIcmpv6Type(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv6Type, error) {
+	_oxmidicmpv6type := &OxmIdIcmpv6Type{OxmId: parent}
+	return _oxmidicmpv6type, nil
+}
+
+func NewOxmIdIcmpv6Type() *OxmIdIcmpv6Type {
+	obj := &OxmIdIcmpv6Type{
+		OxmId: NewOxmId(76289),
+	}
+	return obj
+}
+func (self *OxmIdIcmpv6Type) GetOXMName() string {
+	return "icmpv6_type"
+}
+
+func (self *OxmIdIcmpv6Type) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdInPort struct {
+	*OxmId
+}
+
+type IOxmIdInPort interface {
+	IOxmId
+}
+
+func (self *OxmIdInPort) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdInPort(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdInPort, error) {
+	_oxmidinport := &OxmIdInPort{OxmId: parent}
+	return _oxmidinport, nil
+}
+
+func NewOxmIdInPort() *OxmIdInPort {
+	obj := &OxmIdInPort{
+		OxmId: NewOxmId(2),
+	}
+	return obj
+}
+func (self *OxmIdInPort) GetOXMName() string {
+	return "in_port"
+}
+
+func (self *OxmIdInPort) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdIpDst struct {
+	*OxmId
+}
+
+type IOxmIdIpDst interface {
+	IOxmId
+}
+
+func (self *OxmIdIpDst) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdIpDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpDst, error) {
+	_oxmidipdst := &OxmIdIpDst{OxmId: parent}
+	return _oxmidipdst, nil
+}
+
+func NewOxmIdIpDst() *OxmIdIpDst {
+	obj := &OxmIdIpDst{
+		OxmId: NewOxmId(4100),
+	}
+	return obj
+}
+func (self *OxmIdIpDst) GetOXMName() string {
+	return "ip_dst"
+}
+
+func (self *OxmIdIpDst) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdIpDstMasked struct {
+	*OxmId
+}
+
+type IOxmIdIpDstMasked interface {
+	IOxmId
+}
+
+func (self *OxmIdIpDstMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdIpDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpDstMasked, error) {
+	_oxmidipdstmasked := &OxmIdIpDstMasked{OxmId: parent}
+	return _oxmidipdstmasked, nil
+}
+
+func NewOxmIdIpDstMasked() *OxmIdIpDstMasked {
+	obj := &OxmIdIpDstMasked{
+		OxmId: NewOxmId(4360),
+	}
+	return obj
+}
+func (self *OxmIdIpDstMasked) GetOXMName() string {
+	return "ip_dst_masked"
+}
+
+func (self *OxmIdIpDstMasked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdIpFrag struct {
+	*OxmId
+}
+
+type IOxmIdIpFrag interface {
+	IOxmId
+}
+
+func (self *OxmIdIpFrag) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdIpFrag(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpFrag, error) {
+	_oxmidipfrag := &OxmIdIpFrag{OxmId: parent}
+	return _oxmidipfrag, nil
+}
+
+func NewOxmIdIpFrag() *OxmIdIpFrag {
+	obj := &OxmIdIpFrag{
+		OxmId: NewOxmId(78849),
+	}
+	return obj
+}
+func (self *OxmIdIpFrag) GetOXMName() string {
+	return "ip_frag"
+}
+
+func (self *OxmIdIpFrag) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdIpFragMasked struct {
+	*OxmId
+}
+
+type IOxmIdIpFragMasked interface {
+	IOxmId
+}
+
+func (self *OxmIdIpFragMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdIpFragMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpFragMasked, error) {
+	_oxmidipfragmasked := &OxmIdIpFragMasked{OxmId: parent}
+	return _oxmidipfragmasked, nil
+}
+
+func NewOxmIdIpFragMasked() *OxmIdIpFragMasked {
+	obj := &OxmIdIpFragMasked{
+		OxmId: NewOxmId(79106),
+	}
+	return obj
+}
+func (self *OxmIdIpFragMasked) GetOXMName() string {
+	return "ip_frag_masked"
+}
+
+func (self *OxmIdIpFragMasked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdIpSrc struct {
+	*OxmId
+}
+
+type IOxmIdIpSrc interface {
+	IOxmId
+}
+
+func (self *OxmIdIpSrc) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdIpSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpSrc, error) {
+	_oxmidipsrc := &OxmIdIpSrc{OxmId: parent}
+	return _oxmidipsrc, nil
+}
+
+func NewOxmIdIpSrc() *OxmIdIpSrc {
+	obj := &OxmIdIpSrc{
+		OxmId: NewOxmId(3588),
+	}
+	return obj
+}
+func (self *OxmIdIpSrc) GetOXMName() string {
+	return "ip_src"
+}
+
+func (self *OxmIdIpSrc) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdIpSrcMasked struct {
+	*OxmId
+}
+
+type IOxmIdIpSrcMasked interface {
+	IOxmId
+}
+
+func (self *OxmIdIpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdIpSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpSrcMasked, error) {
+	_oxmidipsrcmasked := &OxmIdIpSrcMasked{OxmId: parent}
+	return _oxmidipsrcmasked, nil
+}
+
+func NewOxmIdIpSrcMasked() *OxmIdIpSrcMasked {
+	obj := &OxmIdIpSrcMasked{
+		OxmId: NewOxmId(3848),
+	}
+	return obj
+}
+func (self *OxmIdIpSrcMasked) GetOXMName() string {
+	return "ip_src_masked"
+}
+
+func (self *OxmIdIpSrcMasked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdIpv6Dst struct {
+	*OxmId
+}
+
+type IOxmIdIpv6Dst interface {
+	IOxmId
+}
+
+func (self *OxmIdIpv6Dst) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdIpv6Dst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6Dst, error) {
+	_oxmidipv6dst := &OxmIdIpv6Dst{OxmId: parent}
+	return _oxmidipv6dst, nil
+}
+
+func NewOxmIdIpv6Dst() *OxmIdIpv6Dst {
+	obj := &OxmIdIpv6Dst{
+		OxmId: NewOxmId(75792),
+	}
+	return obj
+}
+func (self *OxmIdIpv6Dst) GetOXMName() string {
+	return "ipv6_dst"
+}
+
+func (self *OxmIdIpv6Dst) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdIpv6DstMasked struct {
+	*OxmId
+}
+
+type IOxmIdIpv6DstMasked interface {
+	IOxmId
+}
+
+func (self *OxmIdIpv6DstMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdIpv6DstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6DstMasked, error) {
+	_oxmidipv6dstmasked := &OxmIdIpv6DstMasked{OxmId: parent}
+	return _oxmidipv6dstmasked, nil
+}
+
+func NewOxmIdIpv6DstMasked() *OxmIdIpv6DstMasked {
+	obj := &OxmIdIpv6DstMasked{
+		OxmId: NewOxmId(76064),
+	}
+	return obj
+}
+func (self *OxmIdIpv6DstMasked) GetOXMName() string {
+	return "ipv6_dst_masked"
+}
+
+func (self *OxmIdIpv6DstMasked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdIpv6Label struct {
+	*OxmId
+}
+
+type IOxmIdIpv6Label interface {
+	IOxmId
+}
+
+func (self *OxmIdIpv6Label) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdIpv6Label(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6Label, error) {
+	_oxmidipv6label := &OxmIdIpv6Label{OxmId: parent}
+	return _oxmidipv6label, nil
+}
+
+func NewOxmIdIpv6Label() *OxmIdIpv6Label {
+	obj := &OxmIdIpv6Label{
+		OxmId: NewOxmId(79364),
+	}
+	return obj
+}
+func (self *OxmIdIpv6Label) GetOXMName() string {
+	return "ipv6_label"
+}
+
+func (self *OxmIdIpv6Label) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdIpv6LabelMasked struct {
+	*OxmId
+}
+
+type IOxmIdIpv6LabelMasked interface {
+	IOxmId
+}
+
+func (self *OxmIdIpv6LabelMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdIpv6LabelMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6LabelMasked, error) {
+	_oxmidipv6labelmasked := &OxmIdIpv6LabelMasked{OxmId: parent}
+	return _oxmidipv6labelmasked, nil
+}
+
+func NewOxmIdIpv6LabelMasked() *OxmIdIpv6LabelMasked {
+	obj := &OxmIdIpv6LabelMasked{
+		OxmId: NewOxmId(79624),
+	}
+	return obj
+}
+func (self *OxmIdIpv6LabelMasked) GetOXMName() string {
+	return "ipv6_label_masked"
+}
+
+func (self *OxmIdIpv6LabelMasked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdIpv6Src struct {
+	*OxmId
+}
+
+type IOxmIdIpv6Src interface {
+	IOxmId
+}
+
+func (self *OxmIdIpv6Src) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdIpv6Src(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6Src, error) {
+	_oxmidipv6src := &OxmIdIpv6Src{OxmId: parent}
+	return _oxmidipv6src, nil
+}
+
+func NewOxmIdIpv6Src() *OxmIdIpv6Src {
+	obj := &OxmIdIpv6Src{
+		OxmId: NewOxmId(75280),
+	}
+	return obj
+}
+func (self *OxmIdIpv6Src) GetOXMName() string {
+	return "ipv6_src"
+}
+
+func (self *OxmIdIpv6Src) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdIpv6SrcMasked struct {
+	*OxmId
+}
+
+type IOxmIdIpv6SrcMasked interface {
+	IOxmId
+}
+
+func (self *OxmIdIpv6SrcMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdIpv6SrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6SrcMasked, error) {
+	_oxmidipv6srcmasked := &OxmIdIpv6SrcMasked{OxmId: parent}
+	return _oxmidipv6srcmasked, nil
+}
+
+func NewOxmIdIpv6SrcMasked() *OxmIdIpv6SrcMasked {
+	obj := &OxmIdIpv6SrcMasked{
+		OxmId: NewOxmId(75552),
+	}
+	return obj
+}
+func (self *OxmIdIpv6SrcMasked) GetOXMName() string {
+	return "ipv6_src_masked"
+}
+
+func (self *OxmIdIpv6SrcMasked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdMplsTtl struct {
+	*OxmId
+}
+
+type IOxmIdMplsTtl interface {
+	IOxmId
+}
+
+func (self *OxmIdMplsTtl) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdMplsTtl(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMplsTtl, error) {
+	_oxmidmplsttl := &OxmIdMplsTtl{OxmId: parent}
+	return _oxmidmplsttl, nil
+}
+
+func NewOxmIdMplsTtl() *OxmIdMplsTtl {
+	obj := &OxmIdMplsTtl{
+		OxmId: NewOxmId(80897),
+	}
+	return obj
+}
+func (self *OxmIdMplsTtl) GetOXMName() string {
+	return "mpls_ttl"
+}
+
+func (self *OxmIdMplsTtl) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdNdSll struct {
+	*OxmId
+}
+
+type IOxmIdNdSll interface {
+	IOxmId
+}
+
+func (self *OxmIdNdSll) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdNdSll(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNdSll, error) {
+	_oxmidndsll := &OxmIdNdSll{OxmId: parent}
+	return _oxmidndsll, nil
+}
+
+func NewOxmIdNdSll() *OxmIdNdSll {
+	obj := &OxmIdNdSll{
+		OxmId: NewOxmId(77830),
+	}
+	return obj
+}
+func (self *OxmIdNdSll) GetOXMName() string {
+	return "nd_sll"
+}
+
+func (self *OxmIdNdSll) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdNdSllMasked struct {
+	*OxmId
+}
+
+type IOxmIdNdSllMasked interface {
+	IOxmId
+}
+
+func (self *OxmIdNdSllMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdNdSllMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNdSllMasked, error) {
+	_oxmidndsllmasked := &OxmIdNdSllMasked{OxmId: parent}
+	return _oxmidndsllmasked, nil
+}
+
+func NewOxmIdNdSllMasked() *OxmIdNdSllMasked {
+	obj := &OxmIdNdSllMasked{
+		OxmId: NewOxmId(78091),
+	}
+	return obj
+}
+func (self *OxmIdNdSllMasked) GetOXMName() string {
+	return "nd_sll_masked"
+}
+
+func (self *OxmIdNdSllMasked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdNdTarget struct {
+	*OxmId
+}
+
+type IOxmIdNdTarget interface {
+	IOxmId
+}
+
+func (self *OxmIdNdTarget) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdNdTarget(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNdTarget, error) {
+	_oxmidndtarget := &OxmIdNdTarget{OxmId: parent}
+	return _oxmidndtarget, nil
+}
+
+func NewOxmIdNdTarget() *OxmIdNdTarget {
+	obj := &OxmIdNdTarget{
+		OxmId: NewOxmId(77328),
+	}
+	return obj
+}
+func (self *OxmIdNdTarget) GetOXMName() string {
+	return "nd_target"
+}
+
+func (self *OxmIdNdTarget) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdNdTargetMasked struct {
+	*OxmId
+}
+
+type IOxmIdNdTargetMasked interface {
+	IOxmId
+}
+
+func (self *OxmIdNdTargetMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdNdTargetMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNdTargetMasked, error) {
+	_oxmidndtargetmasked := &OxmIdNdTargetMasked{OxmId: parent}
+	return _oxmidndtargetmasked, nil
+}
+
+func NewOxmIdNdTargetMasked() *OxmIdNdTargetMasked {
+	obj := &OxmIdNdTargetMasked{
+		OxmId: NewOxmId(77600),
+	}
+	return obj
+}
+func (self *OxmIdNdTargetMasked) GetOXMName() string {
+	return "nd_target_masked"
+}
+
+func (self *OxmIdNdTargetMasked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdNdTll struct {
+	*OxmId
+}
+
+type IOxmIdNdTll interface {
+	IOxmId
+}
+
+func (self *OxmIdNdTll) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdNdTll(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNdTll, error) {
+	_oxmidndtll := &OxmIdNdTll{OxmId: parent}
+	return _oxmidndtll, nil
+}
+
+func NewOxmIdNdTll() *OxmIdNdTll {
+	obj := &OxmIdNdTll{
+		OxmId: NewOxmId(78342),
+	}
+	return obj
+}
+func (self *OxmIdNdTll) GetOXMName() string {
+	return "nd_tll"
+}
+
+func (self *OxmIdNdTll) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdNdTllMasked struct {
+	*OxmId
+}
+
+type IOxmIdNdTllMasked interface {
+	IOxmId
+}
+
+func (self *OxmIdNdTllMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdNdTllMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNdTllMasked, error) {
+	_oxmidndtllmasked := &OxmIdNdTllMasked{OxmId: parent}
+	return _oxmidndtllmasked, nil
+}
+
+func NewOxmIdNdTllMasked() *OxmIdNdTllMasked {
+	obj := &OxmIdNdTllMasked{
+		OxmId: NewOxmId(78603),
+	}
+	return obj
+}
+func (self *OxmIdNdTllMasked) GetOXMName() string {
+	return "nd_tll_masked"
+}
+
+func (self *OxmIdNdTllMasked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdNwEcn struct {
+	*OxmId
+}
+
+type IOxmIdNwEcn interface {
+	IOxmId
+}
+
+func (self *OxmIdNwEcn) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdNwEcn(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNwEcn, error) {
+	_oxmidnwecn := &OxmIdNwEcn{OxmId: parent}
+	return _oxmidnwecn, nil
+}
+
+func NewOxmIdNwEcn() *OxmIdNwEcn {
+	obj := &OxmIdNwEcn{
+		OxmId: NewOxmId(79873),
+	}
+	return obj
+}
+func (self *OxmIdNwEcn) GetOXMName() string {
+	return "nw_ecn"
+}
+
+func (self *OxmIdNwEcn) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdNwProto struct {
+	*OxmId
+}
+
+type IOxmIdNwProto interface {
+	IOxmId
+}
+
+func (self *OxmIdNwProto) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdNwProto(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNwProto, error) {
+	_oxmidnwproto := &OxmIdNwProto{OxmId: parent}
+	return _oxmidnwproto, nil
+}
+
+func NewOxmIdNwProto() *OxmIdNwProto {
+	obj := &OxmIdNwProto{
+		OxmId: NewOxmId(3073),
+	}
+	return obj
+}
+func (self *OxmIdNwProto) GetOXMName() string {
+	return "nw_proto"
+}
+
+func (self *OxmIdNwProto) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdNwTos struct {
+	*OxmId
+}
+
+type IOxmIdNwTos interface {
+	IOxmId
+}
+
+func (self *OxmIdNwTos) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdNwTos(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNwTos, error) {
+	_oxmidnwtos := &OxmIdNwTos{OxmId: parent}
+	return _oxmidnwtos, nil
+}
+
+func NewOxmIdNwTos() *OxmIdNwTos {
+	obj := &OxmIdNwTos{
+		OxmId: NewOxmId(2561),
+	}
+	return obj
+}
+func (self *OxmIdNwTos) GetOXMName() string {
+	return "nw_tos"
+}
+
+func (self *OxmIdNwTos) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdNwTtl struct {
+	*OxmId
+}
+
+type IOxmIdNwTtl interface {
+	IOxmId
+}
+
+func (self *OxmIdNwTtl) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdNwTtl(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNwTtl, error) {
+	_oxmidnwttl := &OxmIdNwTtl{OxmId: parent}
+	return _oxmidnwttl, nil
+}
+
+func NewOxmIdNwTtl() *OxmIdNwTtl {
+	obj := &OxmIdNwTtl{
+		OxmId: NewOxmId(80385),
+	}
+	return obj
+}
+func (self *OxmIdNwTtl) GetOXMName() string {
+	return "nw_ttl"
+}
+
+func (self *OxmIdNwTtl) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdPktMark struct {
+	*OxmId
+}
+
+type IOxmIdPktMark interface {
+	IOxmId
+}
+
+func (self *OxmIdPktMark) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdPktMark(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdPktMark, error) {
+	_oxmidpktmark := &OxmIdPktMark{OxmId: parent}
+	return _oxmidpktmark, nil
+}
+
+func NewOxmIdPktMark() *OxmIdPktMark {
+	obj := &OxmIdPktMark{
+		OxmId: NewOxmId(82436),
+	}
+	return obj
+}
+func (self *OxmIdPktMark) GetOXMName() string {
+	return "pkt_mark"
+}
+
+func (self *OxmIdPktMark) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdPktMarkMasked struct {
+	*OxmId
+}
+
+type IOxmIdPktMarkMasked interface {
+	IOxmId
+}
+
+func (self *OxmIdPktMarkMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdPktMarkMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdPktMarkMasked, error) {
+	_oxmidpktmarkmasked := &OxmIdPktMarkMasked{OxmId: parent}
+	return _oxmidpktmarkmasked, nil
+}
+
+func NewOxmIdPktMarkMasked() *OxmIdPktMarkMasked {
+	obj := &OxmIdPktMarkMasked{
+		OxmId: NewOxmId(82696),
+	}
+	return obj
+}
+func (self *OxmIdPktMarkMasked) GetOXMName() string {
+	return "pkt_mark_masked"
+}
+
+func (self *OxmIdPktMarkMasked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdRecircId struct {
+	*OxmId
+}
+
+type IOxmIdRecircId interface {
+	IOxmId
+}
+
+func (self *OxmIdRecircId) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdRecircId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdRecircId, error) {
+	_oxmidrecircid := &OxmIdRecircId{OxmId: parent}
+	return _oxmidrecircid, nil
+}
+
+func NewOxmIdRecircId() *OxmIdRecircId {
+	obj := &OxmIdRecircId{
+		OxmId: NewOxmId(83972),
+	}
+	return obj
+}
+func (self *OxmIdRecircId) GetOXMName() string {
+	return "recirc_id"
+}
+
+func (self *OxmIdRecircId) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdReg0 struct {
+	*OxmId
+}
+
+type IOxmIdReg0 interface {
+	IOxmId
+}
+
+func (self *OxmIdReg0) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdReg0(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg0, error) {
+	_oxmidreg0 := &OxmIdReg0{OxmId: parent}
+	return _oxmidreg0, nil
+}
+
+func NewOxmIdReg0() *OxmIdReg0 {
+	obj := &OxmIdReg0{
+		OxmId: NewOxmId(65540),
+	}
+	return obj
+}
+func (self *OxmIdReg0) GetOXMName() string {
+	return "reg0"
+}
+
+func (self *OxmIdReg0) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdReg0Masked struct {
+	*OxmId
+}
+
+type IOxmIdReg0Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdReg0Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdReg0Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg0Masked, error) {
+	_oxmidreg0masked := &OxmIdReg0Masked{OxmId: parent}
+	return _oxmidreg0masked, nil
+}
+
+func NewOxmIdReg0Masked() *OxmIdReg0Masked {
+	obj := &OxmIdReg0Masked{
+		OxmId: NewOxmId(65800),
+	}
+	return obj
+}
+func (self *OxmIdReg0Masked) GetOXMName() string {
+	return "reg0_masked"
+}
+
+func (self *OxmIdReg0Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdReg1 struct {
+	*OxmId
+}
+
+type IOxmIdReg1 interface {
+	IOxmId
+}
+
+func (self *OxmIdReg1) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdReg1(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg1, error) {
+	_oxmidreg1 := &OxmIdReg1{OxmId: parent}
+	return _oxmidreg1, nil
+}
+
+func NewOxmIdReg1() *OxmIdReg1 {
+	obj := &OxmIdReg1{
+		OxmId: NewOxmId(66052),
+	}
+	return obj
+}
+func (self *OxmIdReg1) GetOXMName() string {
+	return "reg1"
+}
+
+func (self *OxmIdReg1) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdReg10 struct {
+	*OxmId
+}
+
+type IOxmIdReg10 interface {
+	IOxmId
+}
+
+func (self *OxmIdReg10) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdReg10(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg10, error) {
+	_oxmidreg10 := &OxmIdReg10{OxmId: parent}
+	return _oxmidreg10, nil
+}
+
+func NewOxmIdReg10() *OxmIdReg10 {
+	obj := &OxmIdReg10{
+		OxmId: NewOxmId(70660),
+	}
+	return obj
+}
+func (self *OxmIdReg10) GetOXMName() string {
+	return "reg10"
+}
+
+func (self *OxmIdReg10) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdReg10Masked struct {
+	*OxmId
+}
+
+type IOxmIdReg10Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdReg10Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdReg10Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg10Masked, error) {
+	_oxmidreg10masked := &OxmIdReg10Masked{OxmId: parent}
+	return _oxmidreg10masked, nil
+}
+
+func NewOxmIdReg10Masked() *OxmIdReg10Masked {
+	obj := &OxmIdReg10Masked{
+		OxmId: NewOxmId(70920),
+	}
+	return obj
+}
+func (self *OxmIdReg10Masked) GetOXMName() string {
+	return "reg10_masked"
+}
+
+func (self *OxmIdReg10Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdReg11 struct {
+	*OxmId
+}
+
+type IOxmIdReg11 interface {
+	IOxmId
+}
+
+func (self *OxmIdReg11) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdReg11(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg11, error) {
+	_oxmidreg11 := &OxmIdReg11{OxmId: parent}
+	return _oxmidreg11, nil
+}
+
+func NewOxmIdReg11() *OxmIdReg11 {
+	obj := &OxmIdReg11{
+		OxmId: NewOxmId(71172),
+	}
+	return obj
+}
+func (self *OxmIdReg11) GetOXMName() string {
+	return "reg11"
+}
+
+func (self *OxmIdReg11) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdReg11Masked struct {
+	*OxmId
+}
+
+type IOxmIdReg11Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdReg11Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdReg11Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg11Masked, error) {
+	_oxmidreg11masked := &OxmIdReg11Masked{OxmId: parent}
+	return _oxmidreg11masked, nil
+}
+
+func NewOxmIdReg11Masked() *OxmIdReg11Masked {
+	obj := &OxmIdReg11Masked{
+		OxmId: NewOxmId(71432),
+	}
+	return obj
+}
+func (self *OxmIdReg11Masked) GetOXMName() string {
+	return "reg11_masked"
+}
+
+func (self *OxmIdReg11Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdReg12 struct {
+	*OxmId
+}
+
+type IOxmIdReg12 interface {
+	IOxmId
+}
+
+func (self *OxmIdReg12) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdReg12(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg12, error) {
+	_oxmidreg12 := &OxmIdReg12{OxmId: parent}
+	return _oxmidreg12, nil
+}
+
+func NewOxmIdReg12() *OxmIdReg12 {
+	obj := &OxmIdReg12{
+		OxmId: NewOxmId(71684),
+	}
+	return obj
+}
+func (self *OxmIdReg12) GetOXMName() string {
+	return "reg12"
+}
+
+func (self *OxmIdReg12) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdReg12Masked struct {
+	*OxmId
+}
+
+type IOxmIdReg12Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdReg12Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdReg12Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg12Masked, error) {
+	_oxmidreg12masked := &OxmIdReg12Masked{OxmId: parent}
+	return _oxmidreg12masked, nil
+}
+
+func NewOxmIdReg12Masked() *OxmIdReg12Masked {
+	obj := &OxmIdReg12Masked{
+		OxmId: NewOxmId(71944),
+	}
+	return obj
+}
+func (self *OxmIdReg12Masked) GetOXMName() string {
+	return "reg12_masked"
+}
+
+func (self *OxmIdReg12Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdReg13 struct {
+	*OxmId
+}
+
+type IOxmIdReg13 interface {
+	IOxmId
+}
+
+func (self *OxmIdReg13) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdReg13(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg13, error) {
+	_oxmidreg13 := &OxmIdReg13{OxmId: parent}
+	return _oxmidreg13, nil
+}
+
+func NewOxmIdReg13() *OxmIdReg13 {
+	obj := &OxmIdReg13{
+		OxmId: NewOxmId(72196),
+	}
+	return obj
+}
+func (self *OxmIdReg13) GetOXMName() string {
+	return "reg13"
+}
+
+func (self *OxmIdReg13) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdReg13Masked struct {
+	*OxmId
+}
+
+type IOxmIdReg13Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdReg13Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdReg13Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg13Masked, error) {
+	_oxmidreg13masked := &OxmIdReg13Masked{OxmId: parent}
+	return _oxmidreg13masked, nil
+}
+
+func NewOxmIdReg13Masked() *OxmIdReg13Masked {
+	obj := &OxmIdReg13Masked{
+		OxmId: NewOxmId(72456),
+	}
+	return obj
+}
+func (self *OxmIdReg13Masked) GetOXMName() string {
+	return "reg13_masked"
+}
+
+func (self *OxmIdReg13Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdReg14 struct {
+	*OxmId
+}
+
+type IOxmIdReg14 interface {
+	IOxmId
+}
+
+func (self *OxmIdReg14) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdReg14(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg14, error) {
+	_oxmidreg14 := &OxmIdReg14{OxmId: parent}
+	return _oxmidreg14, nil
+}
+
+func NewOxmIdReg14() *OxmIdReg14 {
+	obj := &OxmIdReg14{
+		OxmId: NewOxmId(72708),
+	}
+	return obj
+}
+func (self *OxmIdReg14) GetOXMName() string {
+	return "reg14"
+}
+
+func (self *OxmIdReg14) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdReg14Masked struct {
+	*OxmId
+}
+
+type IOxmIdReg14Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdReg14Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdReg14Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg14Masked, error) {
+	_oxmidreg14masked := &OxmIdReg14Masked{OxmId: parent}
+	return _oxmidreg14masked, nil
+}
+
+func NewOxmIdReg14Masked() *OxmIdReg14Masked {
+	obj := &OxmIdReg14Masked{
+		OxmId: NewOxmId(72968),
+	}
+	return obj
+}
+func (self *OxmIdReg14Masked) GetOXMName() string {
+	return "reg14_masked"
+}
+
+func (self *OxmIdReg14Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdReg15 struct {
+	*OxmId
+}
+
+type IOxmIdReg15 interface {
+	IOxmId
+}
+
+func (self *OxmIdReg15) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdReg15(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg15, error) {
+	_oxmidreg15 := &OxmIdReg15{OxmId: parent}
+	return _oxmidreg15, nil
+}
+
+func NewOxmIdReg15() *OxmIdReg15 {
+	obj := &OxmIdReg15{
+		OxmId: NewOxmId(73220),
+	}
+	return obj
+}
+func (self *OxmIdReg15) GetOXMName() string {
+	return "reg15"
+}
+
+func (self *OxmIdReg15) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdReg15Masked struct {
+	*OxmId
+}
+
+type IOxmIdReg15Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdReg15Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdReg15Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg15Masked, error) {
+	_oxmidreg15masked := &OxmIdReg15Masked{OxmId: parent}
+	return _oxmidreg15masked, nil
+}
+
+func NewOxmIdReg15Masked() *OxmIdReg15Masked {
+	obj := &OxmIdReg15Masked{
+		OxmId: NewOxmId(73480),
+	}
+	return obj
+}
+func (self *OxmIdReg15Masked) GetOXMName() string {
+	return "reg15_masked"
+}
+
+func (self *OxmIdReg15Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdReg1Masked struct {
+	*OxmId
+}
+
+type IOxmIdReg1Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdReg1Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdReg1Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg1Masked, error) {
+	_oxmidreg1masked := &OxmIdReg1Masked{OxmId: parent}
+	return _oxmidreg1masked, nil
+}
+
+func NewOxmIdReg1Masked() *OxmIdReg1Masked {
+	obj := &OxmIdReg1Masked{
+		OxmId: NewOxmId(66312),
+	}
+	return obj
+}
+func (self *OxmIdReg1Masked) GetOXMName() string {
+	return "reg1_masked"
+}
+
+func (self *OxmIdReg1Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdReg2 struct {
+	*OxmId
+}
+
+type IOxmIdReg2 interface {
+	IOxmId
+}
+
+func (self *OxmIdReg2) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdReg2(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg2, error) {
+	_oxmidreg2 := &OxmIdReg2{OxmId: parent}
+	return _oxmidreg2, nil
+}
+
+func NewOxmIdReg2() *OxmIdReg2 {
+	obj := &OxmIdReg2{
+		OxmId: NewOxmId(66564),
+	}
+	return obj
+}
+func (self *OxmIdReg2) GetOXMName() string {
+	return "reg2"
+}
+
+func (self *OxmIdReg2) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdReg2Masked struct {
+	*OxmId
+}
+
+type IOxmIdReg2Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdReg2Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdReg2Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg2Masked, error) {
+	_oxmidreg2masked := &OxmIdReg2Masked{OxmId: parent}
+	return _oxmidreg2masked, nil
+}
+
+func NewOxmIdReg2Masked() *OxmIdReg2Masked {
+	obj := &OxmIdReg2Masked{
+		OxmId: NewOxmId(66824),
+	}
+	return obj
+}
+func (self *OxmIdReg2Masked) GetOXMName() string {
+	return "reg2_masked"
+}
+
+func (self *OxmIdReg2Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdReg3 struct {
+	*OxmId
+}
+
+type IOxmIdReg3 interface {
+	IOxmId
+}
+
+func (self *OxmIdReg3) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdReg3(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg3, error) {
+	_oxmidreg3 := &OxmIdReg3{OxmId: parent}
+	return _oxmidreg3, nil
+}
+
+func NewOxmIdReg3() *OxmIdReg3 {
+	obj := &OxmIdReg3{
+		OxmId: NewOxmId(67076),
+	}
+	return obj
+}
+func (self *OxmIdReg3) GetOXMName() string {
+	return "reg3"
+}
+
+func (self *OxmIdReg3) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdReg3Masked struct {
+	*OxmId
+}
+
+type IOxmIdReg3Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdReg3Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdReg3Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg3Masked, error) {
+	_oxmidreg3masked := &OxmIdReg3Masked{OxmId: parent}
+	return _oxmidreg3masked, nil
+}
+
+func NewOxmIdReg3Masked() *OxmIdReg3Masked {
+	obj := &OxmIdReg3Masked{
+		OxmId: NewOxmId(67336),
+	}
+	return obj
+}
+func (self *OxmIdReg3Masked) GetOXMName() string {
+	return "reg3_masked"
+}
+
+func (self *OxmIdReg3Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdReg4 struct {
+	*OxmId
+}
+
+type IOxmIdReg4 interface {
+	IOxmId
+}
+
+func (self *OxmIdReg4) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdReg4(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg4, error) {
+	_oxmidreg4 := &OxmIdReg4{OxmId: parent}
+	return _oxmidreg4, nil
+}
+
+func NewOxmIdReg4() *OxmIdReg4 {
+	obj := &OxmIdReg4{
+		OxmId: NewOxmId(67588),
+	}
+	return obj
+}
+func (self *OxmIdReg4) GetOXMName() string {
+	return "reg4"
+}
+
+func (self *OxmIdReg4) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdReg4Masked struct {
+	*OxmId
+}
+
+type IOxmIdReg4Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdReg4Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdReg4Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg4Masked, error) {
+	_oxmidreg4masked := &OxmIdReg4Masked{OxmId: parent}
+	return _oxmidreg4masked, nil
+}
+
+func NewOxmIdReg4Masked() *OxmIdReg4Masked {
+	obj := &OxmIdReg4Masked{
+		OxmId: NewOxmId(67848),
+	}
+	return obj
+}
+func (self *OxmIdReg4Masked) GetOXMName() string {
+	return "reg4_masked"
+}
+
+func (self *OxmIdReg4Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdReg5 struct {
+	*OxmId
+}
+
+type IOxmIdReg5 interface {
+	IOxmId
+}
+
+func (self *OxmIdReg5) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdReg5(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg5, error) {
+	_oxmidreg5 := &OxmIdReg5{OxmId: parent}
+	return _oxmidreg5, nil
+}
+
+func NewOxmIdReg5() *OxmIdReg5 {
+	obj := &OxmIdReg5{
+		OxmId: NewOxmId(68100),
+	}
+	return obj
+}
+func (self *OxmIdReg5) GetOXMName() string {
+	return "reg5"
+}
+
+func (self *OxmIdReg5) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdReg5Masked struct {
+	*OxmId
+}
+
+type IOxmIdReg5Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdReg5Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdReg5Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg5Masked, error) {
+	_oxmidreg5masked := &OxmIdReg5Masked{OxmId: parent}
+	return _oxmidreg5masked, nil
+}
+
+func NewOxmIdReg5Masked() *OxmIdReg5Masked {
+	obj := &OxmIdReg5Masked{
+		OxmId: NewOxmId(68360),
+	}
+	return obj
+}
+func (self *OxmIdReg5Masked) GetOXMName() string {
+	return "reg5_masked"
+}
+
+func (self *OxmIdReg5Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdReg6 struct {
+	*OxmId
+}
+
+type IOxmIdReg6 interface {
+	IOxmId
+}
+
+func (self *OxmIdReg6) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdReg6(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg6, error) {
+	_oxmidreg6 := &OxmIdReg6{OxmId: parent}
+	return _oxmidreg6, nil
+}
+
+func NewOxmIdReg6() *OxmIdReg6 {
+	obj := &OxmIdReg6{
+		OxmId: NewOxmId(68612),
+	}
+	return obj
+}
+func (self *OxmIdReg6) GetOXMName() string {
+	return "reg6"
+}
+
+func (self *OxmIdReg6) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdReg6Masked struct {
+	*OxmId
+}
+
+type IOxmIdReg6Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdReg6Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdReg6Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg6Masked, error) {
+	_oxmidreg6masked := &OxmIdReg6Masked{OxmId: parent}
+	return _oxmidreg6masked, nil
+}
+
+func NewOxmIdReg6Masked() *OxmIdReg6Masked {
+	obj := &OxmIdReg6Masked{
+		OxmId: NewOxmId(68872),
+	}
+	return obj
+}
+func (self *OxmIdReg6Masked) GetOXMName() string {
+	return "reg6_masked"
+}
+
+func (self *OxmIdReg6Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdReg7 struct {
+	*OxmId
+}
+
+type IOxmIdReg7 interface {
+	IOxmId
+}
+
+func (self *OxmIdReg7) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdReg7(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg7, error) {
+	_oxmidreg7 := &OxmIdReg7{OxmId: parent}
+	return _oxmidreg7, nil
+}
+
+func NewOxmIdReg7() *OxmIdReg7 {
+	obj := &OxmIdReg7{
+		OxmId: NewOxmId(69124),
+	}
+	return obj
+}
+func (self *OxmIdReg7) GetOXMName() string {
+	return "reg7"
+}
+
+func (self *OxmIdReg7) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdReg7Masked struct {
+	*OxmId
+}
+
+type IOxmIdReg7Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdReg7Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdReg7Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg7Masked, error) {
+	_oxmidreg7masked := &OxmIdReg7Masked{OxmId: parent}
+	return _oxmidreg7masked, nil
+}
+
+func NewOxmIdReg7Masked() *OxmIdReg7Masked {
+	obj := &OxmIdReg7Masked{
+		OxmId: NewOxmId(69384),
+	}
+	return obj
+}
+func (self *OxmIdReg7Masked) GetOXMName() string {
+	return "reg7_masked"
+}
+
+func (self *OxmIdReg7Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdReg8 struct {
+	*OxmId
+}
+
+type IOxmIdReg8 interface {
+	IOxmId
+}
+
+func (self *OxmIdReg8) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdReg8(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg8, error) {
+	_oxmidreg8 := &OxmIdReg8{OxmId: parent}
+	return _oxmidreg8, nil
+}
+
+func NewOxmIdReg8() *OxmIdReg8 {
+	obj := &OxmIdReg8{
+		OxmId: NewOxmId(69636),
+	}
+	return obj
+}
+func (self *OxmIdReg8) GetOXMName() string {
+	return "reg8"
+}
+
+func (self *OxmIdReg8) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdReg8Masked struct {
+	*OxmId
+}
+
+type IOxmIdReg8Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdReg8Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdReg8Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg8Masked, error) {
+	_oxmidreg8masked := &OxmIdReg8Masked{OxmId: parent}
+	return _oxmidreg8masked, nil
+}
+
+func NewOxmIdReg8Masked() *OxmIdReg8Masked {
+	obj := &OxmIdReg8Masked{
+		OxmId: NewOxmId(69896),
+	}
+	return obj
+}
+func (self *OxmIdReg8Masked) GetOXMName() string {
+	return "reg8_masked"
+}
+
+func (self *OxmIdReg8Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdReg9 struct {
+	*OxmId
+}
+
+type IOxmIdReg9 interface {
+	IOxmId
+}
+
+func (self *OxmIdReg9) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdReg9(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg9, error) {
+	_oxmidreg9 := &OxmIdReg9{OxmId: parent}
+	return _oxmidreg9, nil
+}
+
+func NewOxmIdReg9() *OxmIdReg9 {
+	obj := &OxmIdReg9{
+		OxmId: NewOxmId(70148),
+	}
+	return obj
+}
+func (self *OxmIdReg9) GetOXMName() string {
+	return "reg9"
+}
+
+func (self *OxmIdReg9) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdReg9Masked struct {
+	*OxmId
+}
+
+type IOxmIdReg9Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdReg9Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdReg9Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg9Masked, error) {
+	_oxmidreg9masked := &OxmIdReg9Masked{OxmId: parent}
+	return _oxmidreg9masked, nil
+}
+
+func NewOxmIdReg9Masked() *OxmIdReg9Masked {
+	obj := &OxmIdReg9Masked{
+		OxmId: NewOxmId(70408),
+	}
+	return obj
+}
+func (self *OxmIdReg9Masked) GetOXMName() string {
+	return "reg9_masked"
+}
+
+func (self *OxmIdReg9Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTcpDst struct {
+	*OxmId
+}
+
+type IOxmIdTcpDst interface {
+	IOxmId
+}
+
+func (self *OxmIdTcpDst) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTcpDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTcpDst, error) {
+	_oxmidtcpdst := &OxmIdTcpDst{OxmId: parent}
+	return _oxmidtcpdst, nil
+}
+
+func NewOxmIdTcpDst() *OxmIdTcpDst {
+	obj := &OxmIdTcpDst{
+		OxmId: NewOxmId(5122),
+	}
+	return obj
+}
+func (self *OxmIdTcpDst) GetOXMName() string {
+	return "tcp_dst"
+}
+
+func (self *OxmIdTcpDst) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTcpDstMasked struct {
+	*OxmId
+}
+
+type IOxmIdTcpDstMasked interface {
+	IOxmId
+}
+
+func (self *OxmIdTcpDstMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTcpDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTcpDstMasked, error) {
+	_oxmidtcpdstmasked := &OxmIdTcpDstMasked{OxmId: parent}
+	return _oxmidtcpdstmasked, nil
+}
+
+func NewOxmIdTcpDstMasked() *OxmIdTcpDstMasked {
+	obj := &OxmIdTcpDstMasked{
+		OxmId: NewOxmId(5378),
+	}
+	return obj
+}
+func (self *OxmIdTcpDstMasked) GetOXMName() string {
+	return "tcp_dst_masked"
+}
+
+func (self *OxmIdTcpDstMasked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTcpFlags struct {
+	*OxmId
+}
+
+type IOxmIdTcpFlags interface {
+	IOxmId
+}
+
+func (self *OxmIdTcpFlags) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTcpFlags(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTcpFlags, error) {
+	_oxmidtcpflags := &OxmIdTcpFlags{OxmId: parent}
+	return _oxmidtcpflags, nil
+}
+
+func NewOxmIdTcpFlags() *OxmIdTcpFlags {
+	obj := &OxmIdTcpFlags{
+		OxmId: NewOxmId(82946),
+	}
+	return obj
+}
+func (self *OxmIdTcpFlags) GetOXMName() string {
+	return "tcp_flags"
+}
+
+func (self *OxmIdTcpFlags) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTcpFlagsMasked struct {
+	*OxmId
+}
+
+type IOxmIdTcpFlagsMasked interface {
+	IOxmId
+}
+
+func (self *OxmIdTcpFlagsMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTcpFlagsMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTcpFlagsMasked, error) {
+	_oxmidtcpflagsmasked := &OxmIdTcpFlagsMasked{OxmId: parent}
+	return _oxmidtcpflagsmasked, nil
+}
+
+func NewOxmIdTcpFlagsMasked() *OxmIdTcpFlagsMasked {
+	obj := &OxmIdTcpFlagsMasked{
+		OxmId: NewOxmId(83204),
+	}
+	return obj
+}
+func (self *OxmIdTcpFlagsMasked) GetOXMName() string {
+	return "tcp_flags_masked"
+}
+
+func (self *OxmIdTcpFlagsMasked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTcpSrc struct {
+	*OxmId
+}
+
+type IOxmIdTcpSrc interface {
+	IOxmId
+}
+
+func (self *OxmIdTcpSrc) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTcpSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTcpSrc, error) {
+	_oxmidtcpsrc := &OxmIdTcpSrc{OxmId: parent}
+	return _oxmidtcpsrc, nil
+}
+
+func NewOxmIdTcpSrc() *OxmIdTcpSrc {
+	obj := &OxmIdTcpSrc{
+		OxmId: NewOxmId(4610),
+	}
+	return obj
+}
+func (self *OxmIdTcpSrc) GetOXMName() string {
+	return "tcp_src"
+}
+
+func (self *OxmIdTcpSrc) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTcpSrcMasked struct {
+	*OxmId
+}
+
+type IOxmIdTcpSrcMasked interface {
+	IOxmId
+}
+
+func (self *OxmIdTcpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTcpSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTcpSrcMasked, error) {
+	_oxmidtcpsrcmasked := &OxmIdTcpSrcMasked{OxmId: parent}
+	return _oxmidtcpsrcmasked, nil
+}
+
+func NewOxmIdTcpSrcMasked() *OxmIdTcpSrcMasked {
+	obj := &OxmIdTcpSrcMasked{
+		OxmId: NewOxmId(4868),
+	}
+	return obj
+}
+func (self *OxmIdTcpSrcMasked) GetOXMName() string {
+	return "tcp_src_masked"
+}
+
+func (self *OxmIdTcpSrcMasked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunDst struct {
+	*OxmId
+}
+
+type IOxmIdTunDst interface {
+	IOxmId
+}
+
+func (self *OxmIdTunDst) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunDst, error) {
+	_oxmidtundst := &OxmIdTunDst{OxmId: parent}
+	return _oxmidtundst, nil
+}
+
+func NewOxmIdTunDst() *OxmIdTunDst {
+	obj := &OxmIdTunDst{
+		OxmId: NewOxmId(81924),
+	}
+	return obj
+}
+func (self *OxmIdTunDst) GetOXMName() string {
+	return "tun_dst"
+}
+
+func (self *OxmIdTunDst) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunDstMasked struct {
+	*OxmId
+}
+
+type IOxmIdTunDstMasked interface {
+	IOxmId
+}
+
+func (self *OxmIdTunDstMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunDstMasked, error) {
+	_oxmidtundstmasked := &OxmIdTunDstMasked{OxmId: parent}
+	return _oxmidtundstmasked, nil
+}
+
+func NewOxmIdTunDstMasked() *OxmIdTunDstMasked {
+	obj := &OxmIdTunDstMasked{
+		OxmId: NewOxmId(82184),
+	}
+	return obj
+}
+func (self *OxmIdTunDstMasked) GetOXMName() string {
+	return "tun_dst_masked"
+}
+
+func (self *OxmIdTunDstMasked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunFlags struct {
+	*OxmId
+}
+
+type IOxmIdTunFlags interface {
+	IOxmId
+}
+
+func (self *OxmIdTunFlags) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunFlags(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunFlags, error) {
+	_oxmidtunflags := &OxmIdTunFlags{OxmId: parent}
+	return _oxmidtunflags, nil
+}
+
+func NewOxmIdTunFlags() *OxmIdTunFlags {
+	obj := &OxmIdTunFlags{
+		OxmId: NewOxmId(118786),
+	}
+	return obj
+}
+func (self *OxmIdTunFlags) GetOXMName() string {
+	return "tun_flags"
+}
+
+func (self *OxmIdTunFlags) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunFlagsMasked struct {
+	*OxmId
+}
+
+type IOxmIdTunFlagsMasked interface {
+	IOxmId
+}
+
+func (self *OxmIdTunFlagsMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunFlagsMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunFlagsMasked, error) {
+	_oxmidtunflagsmasked := &OxmIdTunFlagsMasked{OxmId: parent}
+	return _oxmidtunflagsmasked, nil
+}
+
+func NewOxmIdTunFlagsMasked() *OxmIdTunFlagsMasked {
+	obj := &OxmIdTunFlagsMasked{
+		OxmId: NewOxmId(119044),
+	}
+	return obj
+}
+func (self *OxmIdTunFlagsMasked) GetOXMName() string {
+	return "tun_flags_masked"
+}
+
+func (self *OxmIdTunFlagsMasked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunGbpFlags struct {
+	*OxmId
+}
+
+type IOxmIdTunGbpFlags interface {
+	IOxmId
+}
+
+func (self *OxmIdTunGbpFlags) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunGbpFlags(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunGbpFlags, error) {
+	_oxmidtungbpflags := &OxmIdTunGbpFlags{OxmId: parent}
+	return _oxmidtungbpflags, nil
+}
+
+func NewOxmIdTunGbpFlags() *OxmIdTunGbpFlags {
+	obj := &OxmIdTunGbpFlags{
+		OxmId: NewOxmId(85505),
+	}
+	return obj
+}
+func (self *OxmIdTunGbpFlags) GetOXMName() string {
+	return "tun_gbp_flags"
+}
+
+func (self *OxmIdTunGbpFlags) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunGbpFlagsMasked struct {
+	*OxmId
+}
+
+type IOxmIdTunGbpFlagsMasked interface {
+	IOxmId
+}
+
+func (self *OxmIdTunGbpFlagsMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunGbpFlagsMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunGbpFlagsMasked, error) {
+	_oxmidtungbpflagsmasked := &OxmIdTunGbpFlagsMasked{OxmId: parent}
+	return _oxmidtungbpflagsmasked, nil
+}
+
+func NewOxmIdTunGbpFlagsMasked() *OxmIdTunGbpFlagsMasked {
+	obj := &OxmIdTunGbpFlagsMasked{
+		OxmId: NewOxmId(85762),
+	}
+	return obj
+}
+func (self *OxmIdTunGbpFlagsMasked) GetOXMName() string {
+	return "tun_gbp_flags_masked"
+}
+
+func (self *OxmIdTunGbpFlagsMasked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunGbpId struct {
+	*OxmId
+}
+
+type IOxmIdTunGbpId interface {
+	IOxmId
+}
+
+func (self *OxmIdTunGbpId) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunGbpId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunGbpId, error) {
+	_oxmidtungbpid := &OxmIdTunGbpId{OxmId: parent}
+	return _oxmidtungbpid, nil
+}
+
+func NewOxmIdTunGbpId() *OxmIdTunGbpId {
+	obj := &OxmIdTunGbpId{
+		OxmId: NewOxmId(84994),
+	}
+	return obj
+}
+func (self *OxmIdTunGbpId) GetOXMName() string {
+	return "tun_gbp_id"
+}
+
+func (self *OxmIdTunGbpId) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunGbpIdMasked struct {
+	*OxmId
+}
+
+type IOxmIdTunGbpIdMasked interface {
+	IOxmId
+}
+
+func (self *OxmIdTunGbpIdMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunGbpIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunGbpIdMasked, error) {
+	_oxmidtungbpidmasked := &OxmIdTunGbpIdMasked{OxmId: parent}
+	return _oxmidtungbpidmasked, nil
+}
+
+func NewOxmIdTunGbpIdMasked() *OxmIdTunGbpIdMasked {
+	obj := &OxmIdTunGbpIdMasked{
+		OxmId: NewOxmId(85252),
+	}
+	return obj
+}
+func (self *OxmIdTunGbpIdMasked) GetOXMName() string {
+	return "tun_gbp_id_masked"
+}
+
+func (self *OxmIdTunGbpIdMasked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunId struct {
+	*OxmId
+}
+
+type IOxmIdTunId interface {
+	IOxmId
+}
+
+func (self *OxmIdTunId) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunId, error) {
+	_oxmidtunid := &OxmIdTunId{OxmId: parent}
+	return _oxmidtunid, nil
+}
+
+func NewOxmIdTunId() *OxmIdTunId {
+	obj := &OxmIdTunId{
+		OxmId: NewOxmId(73736),
+	}
+	return obj
+}
+func (self *OxmIdTunId) GetOXMName() string {
+	return "tun_id"
+}
+
+func (self *OxmIdTunId) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunIdMasked struct {
+	*OxmId
+}
+
+type IOxmIdTunIdMasked interface {
+	IOxmId
+}
+
+func (self *OxmIdTunIdMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunIdMasked, error) {
+	_oxmidtunidmasked := &OxmIdTunIdMasked{OxmId: parent}
+	return _oxmidtunidmasked, nil
+}
+
+func NewOxmIdTunIdMasked() *OxmIdTunIdMasked {
+	obj := &OxmIdTunIdMasked{
+		OxmId: NewOxmId(74000),
+	}
+	return obj
+}
+func (self *OxmIdTunIdMasked) GetOXMName() string {
+	return "tun_id_masked"
+}
+
+func (self *OxmIdTunIdMasked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunIpv6Dst struct {
+	*OxmId
+}
+
+type IOxmIdTunIpv6Dst interface {
+	IOxmId
+}
+
+func (self *OxmIdTunIpv6Dst) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunIpv6Dst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunIpv6Dst, error) {
+	_oxmidtunipv6dst := &OxmIdTunIpv6Dst{OxmId: parent}
+	return _oxmidtunipv6dst, nil
+}
+
+func NewOxmIdTunIpv6Dst() *OxmIdTunIpv6Dst {
+	obj := &OxmIdTunIpv6Dst{
+		OxmId: NewOxmId(121872),
+	}
+	return obj
+}
+func (self *OxmIdTunIpv6Dst) GetOXMName() string {
+	return "tun_ipv6_dst"
+}
+
+func (self *OxmIdTunIpv6Dst) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunIpv6DstMasked struct {
+	*OxmId
+}
+
+type IOxmIdTunIpv6DstMasked interface {
+	IOxmId
+}
+
+func (self *OxmIdTunIpv6DstMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunIpv6DstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunIpv6DstMasked, error) {
+	_oxmidtunipv6dstmasked := &OxmIdTunIpv6DstMasked{OxmId: parent}
+	return _oxmidtunipv6dstmasked, nil
+}
+
+func NewOxmIdTunIpv6DstMasked() *OxmIdTunIpv6DstMasked {
+	obj := &OxmIdTunIpv6DstMasked{
+		OxmId: NewOxmId(122144),
+	}
+	return obj
+}
+func (self *OxmIdTunIpv6DstMasked) GetOXMName() string {
+	return "tun_ipv6_dst_masked"
+}
+
+func (self *OxmIdTunIpv6DstMasked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunIpv6Src struct {
+	*OxmId
+}
+
+type IOxmIdTunIpv6Src interface {
+	IOxmId
+}
+
+func (self *OxmIdTunIpv6Src) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunIpv6Src(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunIpv6Src, error) {
+	_oxmidtunipv6src := &OxmIdTunIpv6Src{OxmId: parent}
+	return _oxmidtunipv6src, nil
+}
+
+func NewOxmIdTunIpv6Src() *OxmIdTunIpv6Src {
+	obj := &OxmIdTunIpv6Src{
+		OxmId: NewOxmId(121360),
+	}
+	return obj
+}
+func (self *OxmIdTunIpv6Src) GetOXMName() string {
+	return "tun_ipv6_src"
+}
+
+func (self *OxmIdTunIpv6Src) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunIpv6SrcMasked struct {
+	*OxmId
+}
+
+type IOxmIdTunIpv6SrcMasked interface {
+	IOxmId
+}
+
+func (self *OxmIdTunIpv6SrcMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunIpv6SrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunIpv6SrcMasked, error) {
+	_oxmidtunipv6srcmasked := &OxmIdTunIpv6SrcMasked{OxmId: parent}
+	return _oxmidtunipv6srcmasked, nil
+}
+
+func NewOxmIdTunIpv6SrcMasked() *OxmIdTunIpv6SrcMasked {
+	obj := &OxmIdTunIpv6SrcMasked{
+		OxmId: NewOxmId(121632),
+	}
+	return obj
+}
+func (self *OxmIdTunIpv6SrcMasked) GetOXMName() string {
+	return "tun_ipv6_src_masked"
+}
+
+func (self *OxmIdTunIpv6SrcMasked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata0 struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata0 interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata0) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata0(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata0, error) {
+	_oxmidtunmetadata0 := &OxmIdTunMetadata0{OxmId: parent}
+	return _oxmidtunmetadata0, nil
+}
+
+func NewOxmIdTunMetadata0() *OxmIdTunMetadata0 {
+	obj := &OxmIdTunMetadata0{
+		OxmId: NewOxmId(86140),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata0) GetOXMName() string {
+	return "tun_metadata0"
+}
+
+func (self *OxmIdTunMetadata0) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata0Masked struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata0Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata0Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata0Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata0Masked, error) {
+	_oxmidtunmetadata0masked := &OxmIdTunMetadata0Masked{OxmId: parent}
+	return _oxmidtunmetadata0masked, nil
+}
+
+func NewOxmIdTunMetadata0Masked() *OxmIdTunMetadata0Masked {
+	obj := &OxmIdTunMetadata0Masked{
+		OxmId: NewOxmId(86520),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata0Masked) GetOXMName() string {
+	return "tun_metadata0_masked"
+}
+
+func (self *OxmIdTunMetadata0Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata1 struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata1 interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata1) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata1(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata1, error) {
+	_oxmidtunmetadata1 := &OxmIdTunMetadata1{OxmId: parent}
+	return _oxmidtunmetadata1, nil
+}
+
+func NewOxmIdTunMetadata1() *OxmIdTunMetadata1 {
+	obj := &OxmIdTunMetadata1{
+		OxmId: NewOxmId(86652),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata1) GetOXMName() string {
+	return "tun_metadata1"
+}
+
+func (self *OxmIdTunMetadata1) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata10 struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata10 interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata10) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata10(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata10, error) {
+	_oxmidtunmetadata10 := &OxmIdTunMetadata10{OxmId: parent}
+	return _oxmidtunmetadata10, nil
+}
+
+func NewOxmIdTunMetadata10() *OxmIdTunMetadata10 {
+	obj := &OxmIdTunMetadata10{
+		OxmId: NewOxmId(91260),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata10) GetOXMName() string {
+	return "tun_metadata10"
+}
+
+func (self *OxmIdTunMetadata10) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata10Masked struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata10Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata10Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata10Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata10Masked, error) {
+	_oxmidtunmetadata10masked := &OxmIdTunMetadata10Masked{OxmId: parent}
+	return _oxmidtunmetadata10masked, nil
+}
+
+func NewOxmIdTunMetadata10Masked() *OxmIdTunMetadata10Masked {
+	obj := &OxmIdTunMetadata10Masked{
+		OxmId: NewOxmId(91640),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata10Masked) GetOXMName() string {
+	return "tun_metadata10_masked"
+}
+
+func (self *OxmIdTunMetadata10Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata11 struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata11 interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata11) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata11(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata11, error) {
+	_oxmidtunmetadata11 := &OxmIdTunMetadata11{OxmId: parent}
+	return _oxmidtunmetadata11, nil
+}
+
+func NewOxmIdTunMetadata11() *OxmIdTunMetadata11 {
+	obj := &OxmIdTunMetadata11{
+		OxmId: NewOxmId(91772),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata11) GetOXMName() string {
+	return "tun_metadata11"
+}
+
+func (self *OxmIdTunMetadata11) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata11Masked struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata11Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata11Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata11Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata11Masked, error) {
+	_oxmidtunmetadata11masked := &OxmIdTunMetadata11Masked{OxmId: parent}
+	return _oxmidtunmetadata11masked, nil
+}
+
+func NewOxmIdTunMetadata11Masked() *OxmIdTunMetadata11Masked {
+	obj := &OxmIdTunMetadata11Masked{
+		OxmId: NewOxmId(92152),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata11Masked) GetOXMName() string {
+	return "tun_metadata11_masked"
+}
+
+func (self *OxmIdTunMetadata11Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata12 struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata12 interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata12) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata12(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata12, error) {
+	_oxmidtunmetadata12 := &OxmIdTunMetadata12{OxmId: parent}
+	return _oxmidtunmetadata12, nil
+}
+
+func NewOxmIdTunMetadata12() *OxmIdTunMetadata12 {
+	obj := &OxmIdTunMetadata12{
+		OxmId: NewOxmId(92284),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata12) GetOXMName() string {
+	return "tun_metadata12"
+}
+
+func (self *OxmIdTunMetadata12) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata12Masked struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata12Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata12Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata12Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata12Masked, error) {
+	_oxmidtunmetadata12masked := &OxmIdTunMetadata12Masked{OxmId: parent}
+	return _oxmidtunmetadata12masked, nil
+}
+
+func NewOxmIdTunMetadata12Masked() *OxmIdTunMetadata12Masked {
+	obj := &OxmIdTunMetadata12Masked{
+		OxmId: NewOxmId(92664),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata12Masked) GetOXMName() string {
+	return "tun_metadata12_masked"
+}
+
+func (self *OxmIdTunMetadata12Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata13 struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata13 interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata13) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata13(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata13, error) {
+	_oxmidtunmetadata13 := &OxmIdTunMetadata13{OxmId: parent}
+	return _oxmidtunmetadata13, nil
+}
+
+func NewOxmIdTunMetadata13() *OxmIdTunMetadata13 {
+	obj := &OxmIdTunMetadata13{
+		OxmId: NewOxmId(92796),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata13) GetOXMName() string {
+	return "tun_metadata13"
+}
+
+func (self *OxmIdTunMetadata13) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata13Masked struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata13Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata13Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata13Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata13Masked, error) {
+	_oxmidtunmetadata13masked := &OxmIdTunMetadata13Masked{OxmId: parent}
+	return _oxmidtunmetadata13masked, nil
+}
+
+func NewOxmIdTunMetadata13Masked() *OxmIdTunMetadata13Masked {
+	obj := &OxmIdTunMetadata13Masked{
+		OxmId: NewOxmId(93176),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata13Masked) GetOXMName() string {
+	return "tun_metadata13_masked"
+}
+
+func (self *OxmIdTunMetadata13Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata14 struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata14 interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata14) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata14(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata14, error) {
+	_oxmidtunmetadata14 := &OxmIdTunMetadata14{OxmId: parent}
+	return _oxmidtunmetadata14, nil
+}
+
+func NewOxmIdTunMetadata14() *OxmIdTunMetadata14 {
+	obj := &OxmIdTunMetadata14{
+		OxmId: NewOxmId(93308),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata14) GetOXMName() string {
+	return "tun_metadata14"
+}
+
+func (self *OxmIdTunMetadata14) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata14Masked struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata14Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata14Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata14Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata14Masked, error) {
+	_oxmidtunmetadata14masked := &OxmIdTunMetadata14Masked{OxmId: parent}
+	return _oxmidtunmetadata14masked, nil
+}
+
+func NewOxmIdTunMetadata14Masked() *OxmIdTunMetadata14Masked {
+	obj := &OxmIdTunMetadata14Masked{
+		OxmId: NewOxmId(93688),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata14Masked) GetOXMName() string {
+	return "tun_metadata14_masked"
+}
+
+func (self *OxmIdTunMetadata14Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata15 struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata15 interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata15) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata15(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata15, error) {
+	_oxmidtunmetadata15 := &OxmIdTunMetadata15{OxmId: parent}
+	return _oxmidtunmetadata15, nil
+}
+
+func NewOxmIdTunMetadata15() *OxmIdTunMetadata15 {
+	obj := &OxmIdTunMetadata15{
+		OxmId: NewOxmId(93820),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata15) GetOXMName() string {
+	return "tun_metadata15"
+}
+
+func (self *OxmIdTunMetadata15) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata15Masked struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata15Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata15Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata15Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata15Masked, error) {
+	_oxmidtunmetadata15masked := &OxmIdTunMetadata15Masked{OxmId: parent}
+	return _oxmidtunmetadata15masked, nil
+}
+
+func NewOxmIdTunMetadata15Masked() *OxmIdTunMetadata15Masked {
+	obj := &OxmIdTunMetadata15Masked{
+		OxmId: NewOxmId(94200),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata15Masked) GetOXMName() string {
+	return "tun_metadata15_masked"
+}
+
+func (self *OxmIdTunMetadata15Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata16 struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata16 interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata16) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata16(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata16, error) {
+	_oxmidtunmetadata16 := &OxmIdTunMetadata16{OxmId: parent}
+	return _oxmidtunmetadata16, nil
+}
+
+func NewOxmIdTunMetadata16() *OxmIdTunMetadata16 {
+	obj := &OxmIdTunMetadata16{
+		OxmId: NewOxmId(94332),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata16) GetOXMName() string {
+	return "tun_metadata16"
+}
+
+func (self *OxmIdTunMetadata16) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata16Masked struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata16Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata16Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata16Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata16Masked, error) {
+	_oxmidtunmetadata16masked := &OxmIdTunMetadata16Masked{OxmId: parent}
+	return _oxmidtunmetadata16masked, nil
+}
+
+func NewOxmIdTunMetadata16Masked() *OxmIdTunMetadata16Masked {
+	obj := &OxmIdTunMetadata16Masked{
+		OxmId: NewOxmId(94712),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata16Masked) GetOXMName() string {
+	return "tun_metadata16_masked"
+}
+
+func (self *OxmIdTunMetadata16Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata17 struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata17 interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata17) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata17(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata17, error) {
+	_oxmidtunmetadata17 := &OxmIdTunMetadata17{OxmId: parent}
+	return _oxmidtunmetadata17, nil
+}
+
+func NewOxmIdTunMetadata17() *OxmIdTunMetadata17 {
+	obj := &OxmIdTunMetadata17{
+		OxmId: NewOxmId(94844),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata17) GetOXMName() string {
+	return "tun_metadata17"
+}
+
+func (self *OxmIdTunMetadata17) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata17Masked struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata17Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata17Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata17Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata17Masked, error) {
+	_oxmidtunmetadata17masked := &OxmIdTunMetadata17Masked{OxmId: parent}
+	return _oxmidtunmetadata17masked, nil
+}
+
+func NewOxmIdTunMetadata17Masked() *OxmIdTunMetadata17Masked {
+	obj := &OxmIdTunMetadata17Masked{
+		OxmId: NewOxmId(95224),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata17Masked) GetOXMName() string {
+	return "tun_metadata17_masked"
+}
+
+func (self *OxmIdTunMetadata17Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata18 struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata18 interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata18) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata18(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata18, error) {
+	_oxmidtunmetadata18 := &OxmIdTunMetadata18{OxmId: parent}
+	return _oxmidtunmetadata18, nil
+}
+
+func NewOxmIdTunMetadata18() *OxmIdTunMetadata18 {
+	obj := &OxmIdTunMetadata18{
+		OxmId: NewOxmId(95356),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata18) GetOXMName() string {
+	return "tun_metadata18"
+}
+
+func (self *OxmIdTunMetadata18) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata18Masked struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata18Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata18Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata18Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata18Masked, error) {
+	_oxmidtunmetadata18masked := &OxmIdTunMetadata18Masked{OxmId: parent}
+	return _oxmidtunmetadata18masked, nil
+}
+
+func NewOxmIdTunMetadata18Masked() *OxmIdTunMetadata18Masked {
+	obj := &OxmIdTunMetadata18Masked{
+		OxmId: NewOxmId(95736),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata18Masked) GetOXMName() string {
+	return "tun_metadata18_masked"
+}
+
+func (self *OxmIdTunMetadata18Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata19 struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata19 interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata19) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata19(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata19, error) {
+	_oxmidtunmetadata19 := &OxmIdTunMetadata19{OxmId: parent}
+	return _oxmidtunmetadata19, nil
+}
+
+func NewOxmIdTunMetadata19() *OxmIdTunMetadata19 {
+	obj := &OxmIdTunMetadata19{
+		OxmId: NewOxmId(95868),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata19) GetOXMName() string {
+	return "tun_metadata19"
+}
+
+func (self *OxmIdTunMetadata19) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata19Masked struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata19Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata19Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata19Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata19Masked, error) {
+	_oxmidtunmetadata19masked := &OxmIdTunMetadata19Masked{OxmId: parent}
+	return _oxmidtunmetadata19masked, nil
+}
+
+func NewOxmIdTunMetadata19Masked() *OxmIdTunMetadata19Masked {
+	obj := &OxmIdTunMetadata19Masked{
+		OxmId: NewOxmId(96248),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata19Masked) GetOXMName() string {
+	return "tun_metadata19_masked"
+}
+
+func (self *OxmIdTunMetadata19Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata1Masked struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata1Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata1Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata1Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata1Masked, error) {
+	_oxmidtunmetadata1masked := &OxmIdTunMetadata1Masked{OxmId: parent}
+	return _oxmidtunmetadata1masked, nil
+}
+
+func NewOxmIdTunMetadata1Masked() *OxmIdTunMetadata1Masked {
+	obj := &OxmIdTunMetadata1Masked{
+		OxmId: NewOxmId(87032),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata1Masked) GetOXMName() string {
+	return "tun_metadata1_masked"
+}
+
+func (self *OxmIdTunMetadata1Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata2 struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata2 interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata2) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata2(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata2, error) {
+	_oxmidtunmetadata2 := &OxmIdTunMetadata2{OxmId: parent}
+	return _oxmidtunmetadata2, nil
+}
+
+func NewOxmIdTunMetadata2() *OxmIdTunMetadata2 {
+	obj := &OxmIdTunMetadata2{
+		OxmId: NewOxmId(87164),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata2) GetOXMName() string {
+	return "tun_metadata2"
+}
+
+func (self *OxmIdTunMetadata2) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata20 struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata20 interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata20) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata20(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata20, error) {
+	_oxmidtunmetadata20 := &OxmIdTunMetadata20{OxmId: parent}
+	return _oxmidtunmetadata20, nil
+}
+
+func NewOxmIdTunMetadata20() *OxmIdTunMetadata20 {
+	obj := &OxmIdTunMetadata20{
+		OxmId: NewOxmId(96380),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata20) GetOXMName() string {
+	return "tun_metadata20"
+}
+
+func (self *OxmIdTunMetadata20) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata20Masked struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata20Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata20Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata20Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata20Masked, error) {
+	_oxmidtunmetadata20masked := &OxmIdTunMetadata20Masked{OxmId: parent}
+	return _oxmidtunmetadata20masked, nil
+}
+
+func NewOxmIdTunMetadata20Masked() *OxmIdTunMetadata20Masked {
+	obj := &OxmIdTunMetadata20Masked{
+		OxmId: NewOxmId(96760),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata20Masked) GetOXMName() string {
+	return "tun_metadata20_masked"
+}
+
+func (self *OxmIdTunMetadata20Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata21 struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata21 interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata21) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata21(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata21, error) {
+	_oxmidtunmetadata21 := &OxmIdTunMetadata21{OxmId: parent}
+	return _oxmidtunmetadata21, nil
+}
+
+func NewOxmIdTunMetadata21() *OxmIdTunMetadata21 {
+	obj := &OxmIdTunMetadata21{
+		OxmId: NewOxmId(96892),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata21) GetOXMName() string {
+	return "tun_metadata21"
+}
+
+func (self *OxmIdTunMetadata21) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata21Masked struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata21Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata21Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata21Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata21Masked, error) {
+	_oxmidtunmetadata21masked := &OxmIdTunMetadata21Masked{OxmId: parent}
+	return _oxmidtunmetadata21masked, nil
+}
+
+func NewOxmIdTunMetadata21Masked() *OxmIdTunMetadata21Masked {
+	obj := &OxmIdTunMetadata21Masked{
+		OxmId: NewOxmId(97272),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata21Masked) GetOXMName() string {
+	return "tun_metadata21_masked"
+}
+
+func (self *OxmIdTunMetadata21Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata22 struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata22 interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata22) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata22(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata22, error) {
+	_oxmidtunmetadata22 := &OxmIdTunMetadata22{OxmId: parent}
+	return _oxmidtunmetadata22, nil
+}
+
+func NewOxmIdTunMetadata22() *OxmIdTunMetadata22 {
+	obj := &OxmIdTunMetadata22{
+		OxmId: NewOxmId(97404),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata22) GetOXMName() string {
+	return "tun_metadata22"
+}
+
+func (self *OxmIdTunMetadata22) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata22Masked struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata22Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata22Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata22Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata22Masked, error) {
+	_oxmidtunmetadata22masked := &OxmIdTunMetadata22Masked{OxmId: parent}
+	return _oxmidtunmetadata22masked, nil
+}
+
+func NewOxmIdTunMetadata22Masked() *OxmIdTunMetadata22Masked {
+	obj := &OxmIdTunMetadata22Masked{
+		OxmId: NewOxmId(97784),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata22Masked) GetOXMName() string {
+	return "tun_metadata22_masked"
+}
+
+func (self *OxmIdTunMetadata22Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata23 struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata23 interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata23) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata23(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata23, error) {
+	_oxmidtunmetadata23 := &OxmIdTunMetadata23{OxmId: parent}
+	return _oxmidtunmetadata23, nil
+}
+
+func NewOxmIdTunMetadata23() *OxmIdTunMetadata23 {
+	obj := &OxmIdTunMetadata23{
+		OxmId: NewOxmId(97916),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata23) GetOXMName() string {
+	return "tun_metadata23"
+}
+
+func (self *OxmIdTunMetadata23) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata23Masked struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata23Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata23Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata23Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata23Masked, error) {
+	_oxmidtunmetadata23masked := &OxmIdTunMetadata23Masked{OxmId: parent}
+	return _oxmidtunmetadata23masked, nil
+}
+
+func NewOxmIdTunMetadata23Masked() *OxmIdTunMetadata23Masked {
+	obj := &OxmIdTunMetadata23Masked{
+		OxmId: NewOxmId(98296),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata23Masked) GetOXMName() string {
+	return "tun_metadata23_masked"
+}
+
+func (self *OxmIdTunMetadata23Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata24 struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata24 interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata24) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata24(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata24, error) {
+	_oxmidtunmetadata24 := &OxmIdTunMetadata24{OxmId: parent}
+	return _oxmidtunmetadata24, nil
+}
+
+func NewOxmIdTunMetadata24() *OxmIdTunMetadata24 {
+	obj := &OxmIdTunMetadata24{
+		OxmId: NewOxmId(98428),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata24) GetOXMName() string {
+	return "tun_metadata24"
+}
+
+func (self *OxmIdTunMetadata24) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata24Masked struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata24Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata24Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata24Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata24Masked, error) {
+	_oxmidtunmetadata24masked := &OxmIdTunMetadata24Masked{OxmId: parent}
+	return _oxmidtunmetadata24masked, nil
+}
+
+func NewOxmIdTunMetadata24Masked() *OxmIdTunMetadata24Masked {
+	obj := &OxmIdTunMetadata24Masked{
+		OxmId: NewOxmId(98808),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata24Masked) GetOXMName() string {
+	return "tun_metadata24_masked"
+}
+
+func (self *OxmIdTunMetadata24Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata25 struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata25 interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata25) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata25(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata25, error) {
+	_oxmidtunmetadata25 := &OxmIdTunMetadata25{OxmId: parent}
+	return _oxmidtunmetadata25, nil
+}
+
+func NewOxmIdTunMetadata25() *OxmIdTunMetadata25 {
+	obj := &OxmIdTunMetadata25{
+		OxmId: NewOxmId(98940),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata25) GetOXMName() string {
+	return "tun_metadata25"
+}
+
+func (self *OxmIdTunMetadata25) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata25Masked struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata25Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata25Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata25Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata25Masked, error) {
+	_oxmidtunmetadata25masked := &OxmIdTunMetadata25Masked{OxmId: parent}
+	return _oxmidtunmetadata25masked, nil
+}
+
+func NewOxmIdTunMetadata25Masked() *OxmIdTunMetadata25Masked {
+	obj := &OxmIdTunMetadata25Masked{
+		OxmId: NewOxmId(99320),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata25Masked) GetOXMName() string {
+	return "tun_metadata25_masked"
+}
+
+func (self *OxmIdTunMetadata25Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata26 struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata26 interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata26) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata26(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata26, error) {
+	_oxmidtunmetadata26 := &OxmIdTunMetadata26{OxmId: parent}
+	return _oxmidtunmetadata26, nil
+}
+
+func NewOxmIdTunMetadata26() *OxmIdTunMetadata26 {
+	obj := &OxmIdTunMetadata26{
+		OxmId: NewOxmId(99452),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata26) GetOXMName() string {
+	return "tun_metadata26"
+}
+
+func (self *OxmIdTunMetadata26) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata26Masked struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata26Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata26Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata26Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata26Masked, error) {
+	_oxmidtunmetadata26masked := &OxmIdTunMetadata26Masked{OxmId: parent}
+	return _oxmidtunmetadata26masked, nil
+}
+
+func NewOxmIdTunMetadata26Masked() *OxmIdTunMetadata26Masked {
+	obj := &OxmIdTunMetadata26Masked{
+		OxmId: NewOxmId(99832),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata26Masked) GetOXMName() string {
+	return "tun_metadata26_masked"
+}
+
+func (self *OxmIdTunMetadata26Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata27 struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata27 interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata27) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata27(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata27, error) {
+	_oxmidtunmetadata27 := &OxmIdTunMetadata27{OxmId: parent}
+	return _oxmidtunmetadata27, nil
+}
+
+func NewOxmIdTunMetadata27() *OxmIdTunMetadata27 {
+	obj := &OxmIdTunMetadata27{
+		OxmId: NewOxmId(99964),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata27) GetOXMName() string {
+	return "tun_metadata27"
+}
+
+func (self *OxmIdTunMetadata27) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata27Masked struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata27Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata27Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata27Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata27Masked, error) {
+	_oxmidtunmetadata27masked := &OxmIdTunMetadata27Masked{OxmId: parent}
+	return _oxmidtunmetadata27masked, nil
+}
+
+func NewOxmIdTunMetadata27Masked() *OxmIdTunMetadata27Masked {
+	obj := &OxmIdTunMetadata27Masked{
+		OxmId: NewOxmId(100344),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata27Masked) GetOXMName() string {
+	return "tun_metadata27_masked"
+}
+
+func (self *OxmIdTunMetadata27Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata28 struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata28 interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata28) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata28(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata28, error) {
+	_oxmidtunmetadata28 := &OxmIdTunMetadata28{OxmId: parent}
+	return _oxmidtunmetadata28, nil
+}
+
+func NewOxmIdTunMetadata28() *OxmIdTunMetadata28 {
+	obj := &OxmIdTunMetadata28{
+		OxmId: NewOxmId(100476),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata28) GetOXMName() string {
+	return "tun_metadata28"
+}
+
+func (self *OxmIdTunMetadata28) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata28Masked struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata28Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata28Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata28Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata28Masked, error) {
+	_oxmidtunmetadata28masked := &OxmIdTunMetadata28Masked{OxmId: parent}
+	return _oxmidtunmetadata28masked, nil
+}
+
+func NewOxmIdTunMetadata28Masked() *OxmIdTunMetadata28Masked {
+	obj := &OxmIdTunMetadata28Masked{
+		OxmId: NewOxmId(100856),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata28Masked) GetOXMName() string {
+	return "tun_metadata28_masked"
+}
+
+func (self *OxmIdTunMetadata28Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata29 struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata29 interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata29) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata29(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata29, error) {
+	_oxmidtunmetadata29 := &OxmIdTunMetadata29{OxmId: parent}
+	return _oxmidtunmetadata29, nil
+}
+
+func NewOxmIdTunMetadata29() *OxmIdTunMetadata29 {
+	obj := &OxmIdTunMetadata29{
+		OxmId: NewOxmId(100988),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata29) GetOXMName() string {
+	return "tun_metadata29"
+}
+
+func (self *OxmIdTunMetadata29) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata29Masked struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata29Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata29Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata29Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata29Masked, error) {
+	_oxmidtunmetadata29masked := &OxmIdTunMetadata29Masked{OxmId: parent}
+	return _oxmidtunmetadata29masked, nil
+}
+
+func NewOxmIdTunMetadata29Masked() *OxmIdTunMetadata29Masked {
+	obj := &OxmIdTunMetadata29Masked{
+		OxmId: NewOxmId(101368),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata29Masked) GetOXMName() string {
+	return "tun_metadata29_masked"
+}
+
+func (self *OxmIdTunMetadata29Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata2Masked struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata2Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata2Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata2Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata2Masked, error) {
+	_oxmidtunmetadata2masked := &OxmIdTunMetadata2Masked{OxmId: parent}
+	return _oxmidtunmetadata2masked, nil
+}
+
+func NewOxmIdTunMetadata2Masked() *OxmIdTunMetadata2Masked {
+	obj := &OxmIdTunMetadata2Masked{
+		OxmId: NewOxmId(87544),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata2Masked) GetOXMName() string {
+	return "tun_metadata2_masked"
+}
+
+func (self *OxmIdTunMetadata2Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata3 struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata3 interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata3) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata3(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata3, error) {
+	_oxmidtunmetadata3 := &OxmIdTunMetadata3{OxmId: parent}
+	return _oxmidtunmetadata3, nil
+}
+
+func NewOxmIdTunMetadata3() *OxmIdTunMetadata3 {
+	obj := &OxmIdTunMetadata3{
+		OxmId: NewOxmId(87676),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata3) GetOXMName() string {
+	return "tun_metadata3"
+}
+
+func (self *OxmIdTunMetadata3) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata30 struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata30 interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata30) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata30(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata30, error) {
+	_oxmidtunmetadata30 := &OxmIdTunMetadata30{OxmId: parent}
+	return _oxmidtunmetadata30, nil
+}
+
+func NewOxmIdTunMetadata30() *OxmIdTunMetadata30 {
+	obj := &OxmIdTunMetadata30{
+		OxmId: NewOxmId(101500),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata30) GetOXMName() string {
+	return "tun_metadata30"
+}
+
+func (self *OxmIdTunMetadata30) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata30Masked struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata30Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata30Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata30Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata30Masked, error) {
+	_oxmidtunmetadata30masked := &OxmIdTunMetadata30Masked{OxmId: parent}
+	return _oxmidtunmetadata30masked, nil
+}
+
+func NewOxmIdTunMetadata30Masked() *OxmIdTunMetadata30Masked {
+	obj := &OxmIdTunMetadata30Masked{
+		OxmId: NewOxmId(101880),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata30Masked) GetOXMName() string {
+	return "tun_metadata30_masked"
+}
+
+func (self *OxmIdTunMetadata30Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata31 struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata31 interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata31) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata31(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata31, error) {
+	_oxmidtunmetadata31 := &OxmIdTunMetadata31{OxmId: parent}
+	return _oxmidtunmetadata31, nil
+}
+
+func NewOxmIdTunMetadata31() *OxmIdTunMetadata31 {
+	obj := &OxmIdTunMetadata31{
+		OxmId: NewOxmId(102012),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata31) GetOXMName() string {
+	return "tun_metadata31"
+}
+
+func (self *OxmIdTunMetadata31) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata31Masked struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata31Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata31Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata31Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata31Masked, error) {
+	_oxmidtunmetadata31masked := &OxmIdTunMetadata31Masked{OxmId: parent}
+	return _oxmidtunmetadata31masked, nil
+}
+
+func NewOxmIdTunMetadata31Masked() *OxmIdTunMetadata31Masked {
+	obj := &OxmIdTunMetadata31Masked{
+		OxmId: NewOxmId(102392),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata31Masked) GetOXMName() string {
+	return "tun_metadata31_masked"
+}
+
+func (self *OxmIdTunMetadata31Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata32 struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata32 interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata32) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata32(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata32, error) {
+	_oxmidtunmetadata32 := &OxmIdTunMetadata32{OxmId: parent}
+	return _oxmidtunmetadata32, nil
+}
+
+func NewOxmIdTunMetadata32() *OxmIdTunMetadata32 {
+	obj := &OxmIdTunMetadata32{
+		OxmId: NewOxmId(102524),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata32) GetOXMName() string {
+	return "tun_metadata32"
+}
+
+func (self *OxmIdTunMetadata32) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata32Masked struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata32Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata32Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata32Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata32Masked, error) {
+	_oxmidtunmetadata32masked := &OxmIdTunMetadata32Masked{OxmId: parent}
+	return _oxmidtunmetadata32masked, nil
+}
+
+func NewOxmIdTunMetadata32Masked() *OxmIdTunMetadata32Masked {
+	obj := &OxmIdTunMetadata32Masked{
+		OxmId: NewOxmId(102904),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata32Masked) GetOXMName() string {
+	return "tun_metadata32_masked"
+}
+
+func (self *OxmIdTunMetadata32Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata33 struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata33 interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata33) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata33(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata33, error) {
+	_oxmidtunmetadata33 := &OxmIdTunMetadata33{OxmId: parent}
+	return _oxmidtunmetadata33, nil
+}
+
+func NewOxmIdTunMetadata33() *OxmIdTunMetadata33 {
+	obj := &OxmIdTunMetadata33{
+		OxmId: NewOxmId(103036),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata33) GetOXMName() string {
+	return "tun_metadata33"
+}
+
+func (self *OxmIdTunMetadata33) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata33Masked struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata33Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata33Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata33Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata33Masked, error) {
+	_oxmidtunmetadata33masked := &OxmIdTunMetadata33Masked{OxmId: parent}
+	return _oxmidtunmetadata33masked, nil
+}
+
+func NewOxmIdTunMetadata33Masked() *OxmIdTunMetadata33Masked {
+	obj := &OxmIdTunMetadata33Masked{
+		OxmId: NewOxmId(103416),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata33Masked) GetOXMName() string {
+	return "tun_metadata33_masked"
+}
+
+func (self *OxmIdTunMetadata33Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata34 struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata34 interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata34) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata34(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata34, error) {
+	_oxmidtunmetadata34 := &OxmIdTunMetadata34{OxmId: parent}
+	return _oxmidtunmetadata34, nil
+}
+
+func NewOxmIdTunMetadata34() *OxmIdTunMetadata34 {
+	obj := &OxmIdTunMetadata34{
+		OxmId: NewOxmId(103548),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata34) GetOXMName() string {
+	return "tun_metadata34"
+}
+
+func (self *OxmIdTunMetadata34) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata34Masked struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata34Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata34Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata34Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata34Masked, error) {
+	_oxmidtunmetadata34masked := &OxmIdTunMetadata34Masked{OxmId: parent}
+	return _oxmidtunmetadata34masked, nil
+}
+
+func NewOxmIdTunMetadata34Masked() *OxmIdTunMetadata34Masked {
+	obj := &OxmIdTunMetadata34Masked{
+		OxmId: NewOxmId(103928),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata34Masked) GetOXMName() string {
+	return "tun_metadata34_masked"
+}
+
+func (self *OxmIdTunMetadata34Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata35 struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata35 interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata35) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata35(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata35, error) {
+	_oxmidtunmetadata35 := &OxmIdTunMetadata35{OxmId: parent}
+	return _oxmidtunmetadata35, nil
+}
+
+func NewOxmIdTunMetadata35() *OxmIdTunMetadata35 {
+	obj := &OxmIdTunMetadata35{
+		OxmId: NewOxmId(104060),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata35) GetOXMName() string {
+	return "tun_metadata35"
+}
+
+func (self *OxmIdTunMetadata35) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata35Masked struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata35Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata35Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata35Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata35Masked, error) {
+	_oxmidtunmetadata35masked := &OxmIdTunMetadata35Masked{OxmId: parent}
+	return _oxmidtunmetadata35masked, nil
+}
+
+func NewOxmIdTunMetadata35Masked() *OxmIdTunMetadata35Masked {
+	obj := &OxmIdTunMetadata35Masked{
+		OxmId: NewOxmId(104440),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata35Masked) GetOXMName() string {
+	return "tun_metadata35_masked"
+}
+
+func (self *OxmIdTunMetadata35Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata36 struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata36 interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata36) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata36(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata36, error) {
+	_oxmidtunmetadata36 := &OxmIdTunMetadata36{OxmId: parent}
+	return _oxmidtunmetadata36, nil
+}
+
+func NewOxmIdTunMetadata36() *OxmIdTunMetadata36 {
+	obj := &OxmIdTunMetadata36{
+		OxmId: NewOxmId(104572),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata36) GetOXMName() string {
+	return "tun_metadata36"
+}
+
+func (self *OxmIdTunMetadata36) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata36Masked struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata36Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata36Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata36Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata36Masked, error) {
+	_oxmidtunmetadata36masked := &OxmIdTunMetadata36Masked{OxmId: parent}
+	return _oxmidtunmetadata36masked, nil
+}
+
+func NewOxmIdTunMetadata36Masked() *OxmIdTunMetadata36Masked {
+	obj := &OxmIdTunMetadata36Masked{
+		OxmId: NewOxmId(104952),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata36Masked) GetOXMName() string {
+	return "tun_metadata36_masked"
+}
+
+func (self *OxmIdTunMetadata36Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata37 struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata37 interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata37) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata37(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata37, error) {
+	_oxmidtunmetadata37 := &OxmIdTunMetadata37{OxmId: parent}
+	return _oxmidtunmetadata37, nil
+}
+
+func NewOxmIdTunMetadata37() *OxmIdTunMetadata37 {
+	obj := &OxmIdTunMetadata37{
+		OxmId: NewOxmId(105084),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata37) GetOXMName() string {
+	return "tun_metadata37"
+}
+
+func (self *OxmIdTunMetadata37) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata37Masked struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata37Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata37Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata37Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata37Masked, error) {
+	_oxmidtunmetadata37masked := &OxmIdTunMetadata37Masked{OxmId: parent}
+	return _oxmidtunmetadata37masked, nil
+}
+
+func NewOxmIdTunMetadata37Masked() *OxmIdTunMetadata37Masked {
+	obj := &OxmIdTunMetadata37Masked{
+		OxmId: NewOxmId(105464),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata37Masked) GetOXMName() string {
+	return "tun_metadata37_masked"
+}
+
+func (self *OxmIdTunMetadata37Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata38 struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata38 interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata38) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata38(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata38, error) {
+	_oxmidtunmetadata38 := &OxmIdTunMetadata38{OxmId: parent}
+	return _oxmidtunmetadata38, nil
+}
+
+func NewOxmIdTunMetadata38() *OxmIdTunMetadata38 {
+	obj := &OxmIdTunMetadata38{
+		OxmId: NewOxmId(105596),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata38) GetOXMName() string {
+	return "tun_metadata38"
+}
+
+func (self *OxmIdTunMetadata38) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata38Masked struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata38Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata38Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata38Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata38Masked, error) {
+	_oxmidtunmetadata38masked := &OxmIdTunMetadata38Masked{OxmId: parent}
+	return _oxmidtunmetadata38masked, nil
+}
+
+func NewOxmIdTunMetadata38Masked() *OxmIdTunMetadata38Masked {
+	obj := &OxmIdTunMetadata38Masked{
+		OxmId: NewOxmId(105976),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata38Masked) GetOXMName() string {
+	return "tun_metadata38_masked"
+}
+
+func (self *OxmIdTunMetadata38Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata39 struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata39 interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata39) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata39(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata39, error) {
+	_oxmidtunmetadata39 := &OxmIdTunMetadata39{OxmId: parent}
+	return _oxmidtunmetadata39, nil
+}
+
+func NewOxmIdTunMetadata39() *OxmIdTunMetadata39 {
+	obj := &OxmIdTunMetadata39{
+		OxmId: NewOxmId(106108),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata39) GetOXMName() string {
+	return "tun_metadata39"
+}
+
+func (self *OxmIdTunMetadata39) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata39Masked struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata39Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata39Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata39Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata39Masked, error) {
+	_oxmidtunmetadata39masked := &OxmIdTunMetadata39Masked{OxmId: parent}
+	return _oxmidtunmetadata39masked, nil
+}
+
+func NewOxmIdTunMetadata39Masked() *OxmIdTunMetadata39Masked {
+	obj := &OxmIdTunMetadata39Masked{
+		OxmId: NewOxmId(106488),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata39Masked) GetOXMName() string {
+	return "tun_metadata39_masked"
+}
+
+func (self *OxmIdTunMetadata39Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata3Masked struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata3Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata3Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata3Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata3Masked, error) {
+	_oxmidtunmetadata3masked := &OxmIdTunMetadata3Masked{OxmId: parent}
+	return _oxmidtunmetadata3masked, nil
+}
+
+func NewOxmIdTunMetadata3Masked() *OxmIdTunMetadata3Masked {
+	obj := &OxmIdTunMetadata3Masked{
+		OxmId: NewOxmId(88056),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata3Masked) GetOXMName() string {
+	return "tun_metadata3_masked"
+}
+
+func (self *OxmIdTunMetadata3Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata4 struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata4 interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata4) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata4(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata4, error) {
+	_oxmidtunmetadata4 := &OxmIdTunMetadata4{OxmId: parent}
+	return _oxmidtunmetadata4, nil
+}
+
+func NewOxmIdTunMetadata4() *OxmIdTunMetadata4 {
+	obj := &OxmIdTunMetadata4{
+		OxmId: NewOxmId(88188),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata4) GetOXMName() string {
+	return "tun_metadata4"
+}
+
+func (self *OxmIdTunMetadata4) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata40 struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata40 interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata40) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata40(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata40, error) {
+	_oxmidtunmetadata40 := &OxmIdTunMetadata40{OxmId: parent}
+	return _oxmidtunmetadata40, nil
+}
+
+func NewOxmIdTunMetadata40() *OxmIdTunMetadata40 {
+	obj := &OxmIdTunMetadata40{
+		OxmId: NewOxmId(106620),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata40) GetOXMName() string {
+	return "tun_metadata40"
+}
+
+func (self *OxmIdTunMetadata40) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata40Masked struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata40Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata40Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata40Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata40Masked, error) {
+	_oxmidtunmetadata40masked := &OxmIdTunMetadata40Masked{OxmId: parent}
+	return _oxmidtunmetadata40masked, nil
+}
+
+func NewOxmIdTunMetadata40Masked() *OxmIdTunMetadata40Masked {
+	obj := &OxmIdTunMetadata40Masked{
+		OxmId: NewOxmId(107000),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata40Masked) GetOXMName() string {
+	return "tun_metadata40_masked"
+}
+
+func (self *OxmIdTunMetadata40Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata41 struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata41 interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata41) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata41(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata41, error) {
+	_oxmidtunmetadata41 := &OxmIdTunMetadata41{OxmId: parent}
+	return _oxmidtunmetadata41, nil
+}
+
+func NewOxmIdTunMetadata41() *OxmIdTunMetadata41 {
+	obj := &OxmIdTunMetadata41{
+		OxmId: NewOxmId(107132),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata41) GetOXMName() string {
+	return "tun_metadata41"
+}
+
+func (self *OxmIdTunMetadata41) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata41Masked struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata41Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata41Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata41Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata41Masked, error) {
+	_oxmidtunmetadata41masked := &OxmIdTunMetadata41Masked{OxmId: parent}
+	return _oxmidtunmetadata41masked, nil
+}
+
+func NewOxmIdTunMetadata41Masked() *OxmIdTunMetadata41Masked {
+	obj := &OxmIdTunMetadata41Masked{
+		OxmId: NewOxmId(107512),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata41Masked) GetOXMName() string {
+	return "tun_metadata41_masked"
+}
+
+func (self *OxmIdTunMetadata41Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata42 struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata42 interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata42) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata42(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata42, error) {
+	_oxmidtunmetadata42 := &OxmIdTunMetadata42{OxmId: parent}
+	return _oxmidtunmetadata42, nil
+}
+
+func NewOxmIdTunMetadata42() *OxmIdTunMetadata42 {
+	obj := &OxmIdTunMetadata42{
+		OxmId: NewOxmId(107644),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata42) GetOXMName() string {
+	return "tun_metadata42"
+}
+
+func (self *OxmIdTunMetadata42) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata42Masked struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata42Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata42Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata42Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata42Masked, error) {
+	_oxmidtunmetadata42masked := &OxmIdTunMetadata42Masked{OxmId: parent}
+	return _oxmidtunmetadata42masked, nil
+}
+
+func NewOxmIdTunMetadata42Masked() *OxmIdTunMetadata42Masked {
+	obj := &OxmIdTunMetadata42Masked{
+		OxmId: NewOxmId(108024),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata42Masked) GetOXMName() string {
+	return "tun_metadata42_masked"
+}
+
+func (self *OxmIdTunMetadata42Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata43 struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata43 interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata43) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata43(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata43, error) {
+	_oxmidtunmetadata43 := &OxmIdTunMetadata43{OxmId: parent}
+	return _oxmidtunmetadata43, nil
+}
+
+func NewOxmIdTunMetadata43() *OxmIdTunMetadata43 {
+	obj := &OxmIdTunMetadata43{
+		OxmId: NewOxmId(108156),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata43) GetOXMName() string {
+	return "tun_metadata43"
+}
+
+func (self *OxmIdTunMetadata43) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata43Masked struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata43Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata43Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata43Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata43Masked, error) {
+	_oxmidtunmetadata43masked := &OxmIdTunMetadata43Masked{OxmId: parent}
+	return _oxmidtunmetadata43masked, nil
+}
+
+func NewOxmIdTunMetadata43Masked() *OxmIdTunMetadata43Masked {
+	obj := &OxmIdTunMetadata43Masked{
+		OxmId: NewOxmId(108536),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata43Masked) GetOXMName() string {
+	return "tun_metadata43_masked"
+}
+
+func (self *OxmIdTunMetadata43Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata44 struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata44 interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata44) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata44(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata44, error) {
+	_oxmidtunmetadata44 := &OxmIdTunMetadata44{OxmId: parent}
+	return _oxmidtunmetadata44, nil
+}
+
+func NewOxmIdTunMetadata44() *OxmIdTunMetadata44 {
+	obj := &OxmIdTunMetadata44{
+		OxmId: NewOxmId(108668),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata44) GetOXMName() string {
+	return "tun_metadata44"
+}
+
+func (self *OxmIdTunMetadata44) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata44Masked struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata44Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata44Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata44Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata44Masked, error) {
+	_oxmidtunmetadata44masked := &OxmIdTunMetadata44Masked{OxmId: parent}
+	return _oxmidtunmetadata44masked, nil
+}
+
+func NewOxmIdTunMetadata44Masked() *OxmIdTunMetadata44Masked {
+	obj := &OxmIdTunMetadata44Masked{
+		OxmId: NewOxmId(109048),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata44Masked) GetOXMName() string {
+	return "tun_metadata44_masked"
+}
+
+func (self *OxmIdTunMetadata44Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata45 struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata45 interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata45) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata45(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata45, error) {
+	_oxmidtunmetadata45 := &OxmIdTunMetadata45{OxmId: parent}
+	return _oxmidtunmetadata45, nil
+}
+
+func NewOxmIdTunMetadata45() *OxmIdTunMetadata45 {
+	obj := &OxmIdTunMetadata45{
+		OxmId: NewOxmId(109180),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata45) GetOXMName() string {
+	return "tun_metadata45"
+}
+
+func (self *OxmIdTunMetadata45) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata45Masked struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata45Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata45Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata45Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata45Masked, error) {
+	_oxmidtunmetadata45masked := &OxmIdTunMetadata45Masked{OxmId: parent}
+	return _oxmidtunmetadata45masked, nil
+}
+
+func NewOxmIdTunMetadata45Masked() *OxmIdTunMetadata45Masked {
+	obj := &OxmIdTunMetadata45Masked{
+		OxmId: NewOxmId(109560),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata45Masked) GetOXMName() string {
+	return "tun_metadata45_masked"
+}
+
+func (self *OxmIdTunMetadata45Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata46 struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata46 interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata46) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata46(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata46, error) {
+	_oxmidtunmetadata46 := &OxmIdTunMetadata46{OxmId: parent}
+	return _oxmidtunmetadata46, nil
+}
+
+func NewOxmIdTunMetadata46() *OxmIdTunMetadata46 {
+	obj := &OxmIdTunMetadata46{
+		OxmId: NewOxmId(109692),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata46) GetOXMName() string {
+	return "tun_metadata46"
+}
+
+func (self *OxmIdTunMetadata46) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata46Masked struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata46Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata46Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata46Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata46Masked, error) {
+	_oxmidtunmetadata46masked := &OxmIdTunMetadata46Masked{OxmId: parent}
+	return _oxmidtunmetadata46masked, nil
+}
+
+func NewOxmIdTunMetadata46Masked() *OxmIdTunMetadata46Masked {
+	obj := &OxmIdTunMetadata46Masked{
+		OxmId: NewOxmId(110072),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata46Masked) GetOXMName() string {
+	return "tun_metadata46_masked"
+}
+
+func (self *OxmIdTunMetadata46Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata47 struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata47 interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata47) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata47(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata47, error) {
+	_oxmidtunmetadata47 := &OxmIdTunMetadata47{OxmId: parent}
+	return _oxmidtunmetadata47, nil
+}
+
+func NewOxmIdTunMetadata47() *OxmIdTunMetadata47 {
+	obj := &OxmIdTunMetadata47{
+		OxmId: NewOxmId(110204),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata47) GetOXMName() string {
+	return "tun_metadata47"
+}
+
+func (self *OxmIdTunMetadata47) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata47Masked struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata47Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata47Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata47Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata47Masked, error) {
+	_oxmidtunmetadata47masked := &OxmIdTunMetadata47Masked{OxmId: parent}
+	return _oxmidtunmetadata47masked, nil
+}
+
+func NewOxmIdTunMetadata47Masked() *OxmIdTunMetadata47Masked {
+	obj := &OxmIdTunMetadata47Masked{
+		OxmId: NewOxmId(110584),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata47Masked) GetOXMName() string {
+	return "tun_metadata47_masked"
+}
+
+func (self *OxmIdTunMetadata47Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata48 struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata48 interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata48) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata48(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata48, error) {
+	_oxmidtunmetadata48 := &OxmIdTunMetadata48{OxmId: parent}
+	return _oxmidtunmetadata48, nil
+}
+
+func NewOxmIdTunMetadata48() *OxmIdTunMetadata48 {
+	obj := &OxmIdTunMetadata48{
+		OxmId: NewOxmId(110716),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata48) GetOXMName() string {
+	return "tun_metadata48"
+}
+
+func (self *OxmIdTunMetadata48) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata48Masked struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata48Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata48Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata48Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata48Masked, error) {
+	_oxmidtunmetadata48masked := &OxmIdTunMetadata48Masked{OxmId: parent}
+	return _oxmidtunmetadata48masked, nil
+}
+
+func NewOxmIdTunMetadata48Masked() *OxmIdTunMetadata48Masked {
+	obj := &OxmIdTunMetadata48Masked{
+		OxmId: NewOxmId(111096),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata48Masked) GetOXMName() string {
+	return "tun_metadata48_masked"
+}
+
+func (self *OxmIdTunMetadata48Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata49 struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata49 interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata49) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata49(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata49, error) {
+	_oxmidtunmetadata49 := &OxmIdTunMetadata49{OxmId: parent}
+	return _oxmidtunmetadata49, nil
+}
+
+func NewOxmIdTunMetadata49() *OxmIdTunMetadata49 {
+	obj := &OxmIdTunMetadata49{
+		OxmId: NewOxmId(111228),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata49) GetOXMName() string {
+	return "tun_metadata49"
+}
+
+func (self *OxmIdTunMetadata49) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata49Masked struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata49Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata49Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata49Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata49Masked, error) {
+	_oxmidtunmetadata49masked := &OxmIdTunMetadata49Masked{OxmId: parent}
+	return _oxmidtunmetadata49masked, nil
+}
+
+func NewOxmIdTunMetadata49Masked() *OxmIdTunMetadata49Masked {
+	obj := &OxmIdTunMetadata49Masked{
+		OxmId: NewOxmId(111608),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata49Masked) GetOXMName() string {
+	return "tun_metadata49_masked"
+}
+
+func (self *OxmIdTunMetadata49Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata4Masked struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata4Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata4Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata4Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata4Masked, error) {
+	_oxmidtunmetadata4masked := &OxmIdTunMetadata4Masked{OxmId: parent}
+	return _oxmidtunmetadata4masked, nil
+}
+
+func NewOxmIdTunMetadata4Masked() *OxmIdTunMetadata4Masked {
+	obj := &OxmIdTunMetadata4Masked{
+		OxmId: NewOxmId(88568),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata4Masked) GetOXMName() string {
+	return "tun_metadata4_masked"
+}
+
+func (self *OxmIdTunMetadata4Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata5 struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata5 interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata5) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata5(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata5, error) {
+	_oxmidtunmetadata5 := &OxmIdTunMetadata5{OxmId: parent}
+	return _oxmidtunmetadata5, nil
+}
+
+func NewOxmIdTunMetadata5() *OxmIdTunMetadata5 {
+	obj := &OxmIdTunMetadata5{
+		OxmId: NewOxmId(88700),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata5) GetOXMName() string {
+	return "tun_metadata5"
+}
+
+func (self *OxmIdTunMetadata5) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata50 struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata50 interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata50) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata50(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata50, error) {
+	_oxmidtunmetadata50 := &OxmIdTunMetadata50{OxmId: parent}
+	return _oxmidtunmetadata50, nil
+}
+
+func NewOxmIdTunMetadata50() *OxmIdTunMetadata50 {
+	obj := &OxmIdTunMetadata50{
+		OxmId: NewOxmId(111740),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata50) GetOXMName() string {
+	return "tun_metadata50"
+}
+
+func (self *OxmIdTunMetadata50) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata50Masked struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata50Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata50Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata50Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata50Masked, error) {
+	_oxmidtunmetadata50masked := &OxmIdTunMetadata50Masked{OxmId: parent}
+	return _oxmidtunmetadata50masked, nil
+}
+
+func NewOxmIdTunMetadata50Masked() *OxmIdTunMetadata50Masked {
+	obj := &OxmIdTunMetadata50Masked{
+		OxmId: NewOxmId(112120),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata50Masked) GetOXMName() string {
+	return "tun_metadata50_masked"
+}
+
+func (self *OxmIdTunMetadata50Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata51 struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata51 interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata51) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata51(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata51, error) {
+	_oxmidtunmetadata51 := &OxmIdTunMetadata51{OxmId: parent}
+	return _oxmidtunmetadata51, nil
+}
+
+func NewOxmIdTunMetadata51() *OxmIdTunMetadata51 {
+	obj := &OxmIdTunMetadata51{
+		OxmId: NewOxmId(112252),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata51) GetOXMName() string {
+	return "tun_metadata51"
+}
+
+func (self *OxmIdTunMetadata51) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata51Masked struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata51Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata51Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata51Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata51Masked, error) {
+	_oxmidtunmetadata51masked := &OxmIdTunMetadata51Masked{OxmId: parent}
+	return _oxmidtunmetadata51masked, nil
+}
+
+func NewOxmIdTunMetadata51Masked() *OxmIdTunMetadata51Masked {
+	obj := &OxmIdTunMetadata51Masked{
+		OxmId: NewOxmId(112632),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata51Masked) GetOXMName() string {
+	return "tun_metadata51_masked"
+}
+
+func (self *OxmIdTunMetadata51Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata52 struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata52 interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata52) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata52(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata52, error) {
+	_oxmidtunmetadata52 := &OxmIdTunMetadata52{OxmId: parent}
+	return _oxmidtunmetadata52, nil
+}
+
+func NewOxmIdTunMetadata52() *OxmIdTunMetadata52 {
+	obj := &OxmIdTunMetadata52{
+		OxmId: NewOxmId(112764),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata52) GetOXMName() string {
+	return "tun_metadata52"
+}
+
+func (self *OxmIdTunMetadata52) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata52Masked struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata52Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata52Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata52Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata52Masked, error) {
+	_oxmidtunmetadata52masked := &OxmIdTunMetadata52Masked{OxmId: parent}
+	return _oxmidtunmetadata52masked, nil
+}
+
+func NewOxmIdTunMetadata52Masked() *OxmIdTunMetadata52Masked {
+	obj := &OxmIdTunMetadata52Masked{
+		OxmId: NewOxmId(113144),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata52Masked) GetOXMName() string {
+	return "tun_metadata52_masked"
+}
+
+func (self *OxmIdTunMetadata52Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata53 struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata53 interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata53) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata53(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata53, error) {
+	_oxmidtunmetadata53 := &OxmIdTunMetadata53{OxmId: parent}
+	return _oxmidtunmetadata53, nil
+}
+
+func NewOxmIdTunMetadata53() *OxmIdTunMetadata53 {
+	obj := &OxmIdTunMetadata53{
+		OxmId: NewOxmId(113276),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata53) GetOXMName() string {
+	return "tun_metadata53"
+}
+
+func (self *OxmIdTunMetadata53) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata53Masked struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata53Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata53Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata53Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata53Masked, error) {
+	_oxmidtunmetadata53masked := &OxmIdTunMetadata53Masked{OxmId: parent}
+	return _oxmidtunmetadata53masked, nil
+}
+
+func NewOxmIdTunMetadata53Masked() *OxmIdTunMetadata53Masked {
+	obj := &OxmIdTunMetadata53Masked{
+		OxmId: NewOxmId(113656),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata53Masked) GetOXMName() string {
+	return "tun_metadata53_masked"
+}
+
+func (self *OxmIdTunMetadata53Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata54 struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata54 interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata54) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata54(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata54, error) {
+	_oxmidtunmetadata54 := &OxmIdTunMetadata54{OxmId: parent}
+	return _oxmidtunmetadata54, nil
+}
+
+func NewOxmIdTunMetadata54() *OxmIdTunMetadata54 {
+	obj := &OxmIdTunMetadata54{
+		OxmId: NewOxmId(113788),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata54) GetOXMName() string {
+	return "tun_metadata54"
+}
+
+func (self *OxmIdTunMetadata54) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata54Masked struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata54Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata54Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata54Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata54Masked, error) {
+	_oxmidtunmetadata54masked := &OxmIdTunMetadata54Masked{OxmId: parent}
+	return _oxmidtunmetadata54masked, nil
+}
+
+func NewOxmIdTunMetadata54Masked() *OxmIdTunMetadata54Masked {
+	obj := &OxmIdTunMetadata54Masked{
+		OxmId: NewOxmId(114168),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata54Masked) GetOXMName() string {
+	return "tun_metadata54_masked"
+}
+
+func (self *OxmIdTunMetadata54Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata55 struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata55 interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata55) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata55(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata55, error) {
+	_oxmidtunmetadata55 := &OxmIdTunMetadata55{OxmId: parent}
+	return _oxmidtunmetadata55, nil
+}
+
+func NewOxmIdTunMetadata55() *OxmIdTunMetadata55 {
+	obj := &OxmIdTunMetadata55{
+		OxmId: NewOxmId(114300),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata55) GetOXMName() string {
+	return "tun_metadata55"
+}
+
+func (self *OxmIdTunMetadata55) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata55Masked struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata55Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata55Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata55Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata55Masked, error) {
+	_oxmidtunmetadata55masked := &OxmIdTunMetadata55Masked{OxmId: parent}
+	return _oxmidtunmetadata55masked, nil
+}
+
+func NewOxmIdTunMetadata55Masked() *OxmIdTunMetadata55Masked {
+	obj := &OxmIdTunMetadata55Masked{
+		OxmId: NewOxmId(114680),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata55Masked) GetOXMName() string {
+	return "tun_metadata55_masked"
+}
+
+func (self *OxmIdTunMetadata55Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata56 struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata56 interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata56) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata56(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata56, error) {
+	_oxmidtunmetadata56 := &OxmIdTunMetadata56{OxmId: parent}
+	return _oxmidtunmetadata56, nil
+}
+
+func NewOxmIdTunMetadata56() *OxmIdTunMetadata56 {
+	obj := &OxmIdTunMetadata56{
+		OxmId: NewOxmId(114812),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata56) GetOXMName() string {
+	return "tun_metadata56"
+}
+
+func (self *OxmIdTunMetadata56) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata56Masked struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata56Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata56Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata56Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata56Masked, error) {
+	_oxmidtunmetadata56masked := &OxmIdTunMetadata56Masked{OxmId: parent}
+	return _oxmidtunmetadata56masked, nil
+}
+
+func NewOxmIdTunMetadata56Masked() *OxmIdTunMetadata56Masked {
+	obj := &OxmIdTunMetadata56Masked{
+		OxmId: NewOxmId(115192),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata56Masked) GetOXMName() string {
+	return "tun_metadata56_masked"
+}
+
+func (self *OxmIdTunMetadata56Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata57 struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata57 interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata57) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata57(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata57, error) {
+	_oxmidtunmetadata57 := &OxmIdTunMetadata57{OxmId: parent}
+	return _oxmidtunmetadata57, nil
+}
+
+func NewOxmIdTunMetadata57() *OxmIdTunMetadata57 {
+	obj := &OxmIdTunMetadata57{
+		OxmId: NewOxmId(115324),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata57) GetOXMName() string {
+	return "tun_metadata57"
+}
+
+func (self *OxmIdTunMetadata57) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata57Masked struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata57Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata57Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata57Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata57Masked, error) {
+	_oxmidtunmetadata57masked := &OxmIdTunMetadata57Masked{OxmId: parent}
+	return _oxmidtunmetadata57masked, nil
+}
+
+func NewOxmIdTunMetadata57Masked() *OxmIdTunMetadata57Masked {
+	obj := &OxmIdTunMetadata57Masked{
+		OxmId: NewOxmId(115704),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata57Masked) GetOXMName() string {
+	return "tun_metadata57_masked"
+}
+
+func (self *OxmIdTunMetadata57Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata58 struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata58 interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata58) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata58(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata58, error) {
+	_oxmidtunmetadata58 := &OxmIdTunMetadata58{OxmId: parent}
+	return _oxmidtunmetadata58, nil
+}
+
+func NewOxmIdTunMetadata58() *OxmIdTunMetadata58 {
+	obj := &OxmIdTunMetadata58{
+		OxmId: NewOxmId(115836),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata58) GetOXMName() string {
+	return "tun_metadata58"
+}
+
+func (self *OxmIdTunMetadata58) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata58Masked struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata58Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata58Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata58Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata58Masked, error) {
+	_oxmidtunmetadata58masked := &OxmIdTunMetadata58Masked{OxmId: parent}
+	return _oxmidtunmetadata58masked, nil
+}
+
+func NewOxmIdTunMetadata58Masked() *OxmIdTunMetadata58Masked {
+	obj := &OxmIdTunMetadata58Masked{
+		OxmId: NewOxmId(116216),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata58Masked) GetOXMName() string {
+	return "tun_metadata58_masked"
+}
+
+func (self *OxmIdTunMetadata58Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata59 struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata59 interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata59) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata59(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata59, error) {
+	_oxmidtunmetadata59 := &OxmIdTunMetadata59{OxmId: parent}
+	return _oxmidtunmetadata59, nil
+}
+
+func NewOxmIdTunMetadata59() *OxmIdTunMetadata59 {
+	obj := &OxmIdTunMetadata59{
+		OxmId: NewOxmId(116348),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata59) GetOXMName() string {
+	return "tun_metadata59"
+}
+
+func (self *OxmIdTunMetadata59) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata59Masked struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata59Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata59Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata59Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata59Masked, error) {
+	_oxmidtunmetadata59masked := &OxmIdTunMetadata59Masked{OxmId: parent}
+	return _oxmidtunmetadata59masked, nil
+}
+
+func NewOxmIdTunMetadata59Masked() *OxmIdTunMetadata59Masked {
+	obj := &OxmIdTunMetadata59Masked{
+		OxmId: NewOxmId(116728),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata59Masked) GetOXMName() string {
+	return "tun_metadata59_masked"
+}
+
+func (self *OxmIdTunMetadata59Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata5Masked struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata5Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata5Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata5Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata5Masked, error) {
+	_oxmidtunmetadata5masked := &OxmIdTunMetadata5Masked{OxmId: parent}
+	return _oxmidtunmetadata5masked, nil
+}
+
+func NewOxmIdTunMetadata5Masked() *OxmIdTunMetadata5Masked {
+	obj := &OxmIdTunMetadata5Masked{
+		OxmId: NewOxmId(89080),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata5Masked) GetOXMName() string {
+	return "tun_metadata5_masked"
+}
+
+func (self *OxmIdTunMetadata5Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata6 struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata6 interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata6) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata6(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata6, error) {
+	_oxmidtunmetadata6 := &OxmIdTunMetadata6{OxmId: parent}
+	return _oxmidtunmetadata6, nil
+}
+
+func NewOxmIdTunMetadata6() *OxmIdTunMetadata6 {
+	obj := &OxmIdTunMetadata6{
+		OxmId: NewOxmId(89212),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata6) GetOXMName() string {
+	return "tun_metadata6"
+}
+
+func (self *OxmIdTunMetadata6) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata60 struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata60 interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata60) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata60(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata60, error) {
+	_oxmidtunmetadata60 := &OxmIdTunMetadata60{OxmId: parent}
+	return _oxmidtunmetadata60, nil
+}
+
+func NewOxmIdTunMetadata60() *OxmIdTunMetadata60 {
+	obj := &OxmIdTunMetadata60{
+		OxmId: NewOxmId(116860),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata60) GetOXMName() string {
+	return "tun_metadata60"
+}
+
+func (self *OxmIdTunMetadata60) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata60Masked struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata60Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata60Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata60Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata60Masked, error) {
+	_oxmidtunmetadata60masked := &OxmIdTunMetadata60Masked{OxmId: parent}
+	return _oxmidtunmetadata60masked, nil
+}
+
+func NewOxmIdTunMetadata60Masked() *OxmIdTunMetadata60Masked {
+	obj := &OxmIdTunMetadata60Masked{
+		OxmId: NewOxmId(117240),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata60Masked) GetOXMName() string {
+	return "tun_metadata60_masked"
+}
+
+func (self *OxmIdTunMetadata60Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata61 struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata61 interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata61) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata61(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata61, error) {
+	_oxmidtunmetadata61 := &OxmIdTunMetadata61{OxmId: parent}
+	return _oxmidtunmetadata61, nil
+}
+
+func NewOxmIdTunMetadata61() *OxmIdTunMetadata61 {
+	obj := &OxmIdTunMetadata61{
+		OxmId: NewOxmId(117372),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata61) GetOXMName() string {
+	return "tun_metadata61"
+}
+
+func (self *OxmIdTunMetadata61) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata61Masked struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata61Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata61Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata61Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata61Masked, error) {
+	_oxmidtunmetadata61masked := &OxmIdTunMetadata61Masked{OxmId: parent}
+	return _oxmidtunmetadata61masked, nil
+}
+
+func NewOxmIdTunMetadata61Masked() *OxmIdTunMetadata61Masked {
+	obj := &OxmIdTunMetadata61Masked{
+		OxmId: NewOxmId(117752),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata61Masked) GetOXMName() string {
+	return "tun_metadata61_masked"
+}
+
+func (self *OxmIdTunMetadata61Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata62 struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata62 interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata62) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata62(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata62, error) {
+	_oxmidtunmetadata62 := &OxmIdTunMetadata62{OxmId: parent}
+	return _oxmidtunmetadata62, nil
+}
+
+func NewOxmIdTunMetadata62() *OxmIdTunMetadata62 {
+	obj := &OxmIdTunMetadata62{
+		OxmId: NewOxmId(117884),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata62) GetOXMName() string {
+	return "tun_metadata62"
+}
+
+func (self *OxmIdTunMetadata62) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata62Masked struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata62Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata62Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata62Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata62Masked, error) {
+	_oxmidtunmetadata62masked := &OxmIdTunMetadata62Masked{OxmId: parent}
+	return _oxmidtunmetadata62masked, nil
+}
+
+func NewOxmIdTunMetadata62Masked() *OxmIdTunMetadata62Masked {
+	obj := &OxmIdTunMetadata62Masked{
+		OxmId: NewOxmId(118264),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata62Masked) GetOXMName() string {
+	return "tun_metadata62_masked"
+}
+
+func (self *OxmIdTunMetadata62Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata63 struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata63 interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata63) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata63(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata63, error) {
+	_oxmidtunmetadata63 := &OxmIdTunMetadata63{OxmId: parent}
+	return _oxmidtunmetadata63, nil
+}
+
+func NewOxmIdTunMetadata63() *OxmIdTunMetadata63 {
+	obj := &OxmIdTunMetadata63{
+		OxmId: NewOxmId(118396),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata63) GetOXMName() string {
+	return "tun_metadata63"
+}
+
+func (self *OxmIdTunMetadata63) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata63Masked struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata63Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata63Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata63Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata63Masked, error) {
+	_oxmidtunmetadata63masked := &OxmIdTunMetadata63Masked{OxmId: parent}
+	return _oxmidtunmetadata63masked, nil
+}
+
+func NewOxmIdTunMetadata63Masked() *OxmIdTunMetadata63Masked {
+	obj := &OxmIdTunMetadata63Masked{
+		OxmId: NewOxmId(118776),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata63Masked) GetOXMName() string {
+	return "tun_metadata63_masked"
+}
+
+func (self *OxmIdTunMetadata63Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata6Masked struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata6Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata6Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata6Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata6Masked, error) {
+	_oxmidtunmetadata6masked := &OxmIdTunMetadata6Masked{OxmId: parent}
+	return _oxmidtunmetadata6masked, nil
+}
+
+func NewOxmIdTunMetadata6Masked() *OxmIdTunMetadata6Masked {
+	obj := &OxmIdTunMetadata6Masked{
+		OxmId: NewOxmId(89592),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata6Masked) GetOXMName() string {
+	return "tun_metadata6_masked"
+}
+
+func (self *OxmIdTunMetadata6Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata7 struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata7 interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata7) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata7(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata7, error) {
+	_oxmidtunmetadata7 := &OxmIdTunMetadata7{OxmId: parent}
+	return _oxmidtunmetadata7, nil
+}
+
+func NewOxmIdTunMetadata7() *OxmIdTunMetadata7 {
+	obj := &OxmIdTunMetadata7{
+		OxmId: NewOxmId(89724),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata7) GetOXMName() string {
+	return "tun_metadata7"
+}
+
+func (self *OxmIdTunMetadata7) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata7Masked struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata7Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata7Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata7Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata7Masked, error) {
+	_oxmidtunmetadata7masked := &OxmIdTunMetadata7Masked{OxmId: parent}
+	return _oxmidtunmetadata7masked, nil
+}
+
+func NewOxmIdTunMetadata7Masked() *OxmIdTunMetadata7Masked {
+	obj := &OxmIdTunMetadata7Masked{
+		OxmId: NewOxmId(90104),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata7Masked) GetOXMName() string {
+	return "tun_metadata7_masked"
+}
+
+func (self *OxmIdTunMetadata7Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata8 struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata8 interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata8) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata8(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata8, error) {
+	_oxmidtunmetadata8 := &OxmIdTunMetadata8{OxmId: parent}
+	return _oxmidtunmetadata8, nil
+}
+
+func NewOxmIdTunMetadata8() *OxmIdTunMetadata8 {
+	obj := &OxmIdTunMetadata8{
+		OxmId: NewOxmId(90236),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata8) GetOXMName() string {
+	return "tun_metadata8"
+}
+
+func (self *OxmIdTunMetadata8) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata8Masked struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata8Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata8Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata8Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata8Masked, error) {
+	_oxmidtunmetadata8masked := &OxmIdTunMetadata8Masked{OxmId: parent}
+	return _oxmidtunmetadata8masked, nil
+}
+
+func NewOxmIdTunMetadata8Masked() *OxmIdTunMetadata8Masked {
+	obj := &OxmIdTunMetadata8Masked{
+		OxmId: NewOxmId(90616),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata8Masked) GetOXMName() string {
+	return "tun_metadata8_masked"
+}
+
+func (self *OxmIdTunMetadata8Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata9 struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata9 interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata9) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata9(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata9, error) {
+	_oxmidtunmetadata9 := &OxmIdTunMetadata9{OxmId: parent}
+	return _oxmidtunmetadata9, nil
+}
+
+func NewOxmIdTunMetadata9() *OxmIdTunMetadata9 {
+	obj := &OxmIdTunMetadata9{
+		OxmId: NewOxmId(90748),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata9) GetOXMName() string {
+	return "tun_metadata9"
+}
+
+func (self *OxmIdTunMetadata9) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunMetadata9Masked struct {
+	*OxmId
+}
+
+type IOxmIdTunMetadata9Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdTunMetadata9Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunMetadata9Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata9Masked, error) {
+	_oxmidtunmetadata9masked := &OxmIdTunMetadata9Masked{OxmId: parent}
+	return _oxmidtunmetadata9masked, nil
+}
+
+func NewOxmIdTunMetadata9Masked() *OxmIdTunMetadata9Masked {
+	obj := &OxmIdTunMetadata9Masked{
+		OxmId: NewOxmId(91128),
+	}
+	return obj
+}
+func (self *OxmIdTunMetadata9Masked) GetOXMName() string {
+	return "tun_metadata9_masked"
+}
+
+func (self *OxmIdTunMetadata9Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunSrc struct {
+	*OxmId
+}
+
+type IOxmIdTunSrc interface {
+	IOxmId
+}
+
+func (self *OxmIdTunSrc) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunSrc, error) {
+	_oxmidtunsrc := &OxmIdTunSrc{OxmId: parent}
+	return _oxmidtunsrc, nil
+}
+
+func NewOxmIdTunSrc() *OxmIdTunSrc {
+	obj := &OxmIdTunSrc{
+		OxmId: NewOxmId(81412),
+	}
+	return obj
+}
+func (self *OxmIdTunSrc) GetOXMName() string {
+	return "tun_src"
+}
+
+func (self *OxmIdTunSrc) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdTunSrcMasked struct {
+	*OxmId
+}
+
+type IOxmIdTunSrcMasked interface {
+	IOxmId
+}
+
+func (self *OxmIdTunSrcMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdTunSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunSrcMasked, error) {
+	_oxmidtunsrcmasked := &OxmIdTunSrcMasked{OxmId: parent}
+	return _oxmidtunsrcmasked, nil
+}
+
+func NewOxmIdTunSrcMasked() *OxmIdTunSrcMasked {
+	obj := &OxmIdTunSrcMasked{
+		OxmId: NewOxmId(81672),
+	}
+	return obj
+}
+func (self *OxmIdTunSrcMasked) GetOXMName() string {
+	return "tun_src_masked"
+}
+
+func (self *OxmIdTunSrcMasked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdUdpDst struct {
+	*OxmId
+}
+
+type IOxmIdUdpDst interface {
+	IOxmId
+}
+
+func (self *OxmIdUdpDst) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdUdpDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdUdpDst, error) {
+	_oxmidudpdst := &OxmIdUdpDst{OxmId: parent}
+	return _oxmidudpdst, nil
+}
+
+func NewOxmIdUdpDst() *OxmIdUdpDst {
+	obj := &OxmIdUdpDst{
+		OxmId: NewOxmId(6146),
+	}
+	return obj
+}
+func (self *OxmIdUdpDst) GetOXMName() string {
+	return "udp_dst"
+}
+
+func (self *OxmIdUdpDst) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdUdpDstMasked struct {
+	*OxmId
+}
+
+type IOxmIdUdpDstMasked interface {
+	IOxmId
+}
+
+func (self *OxmIdUdpDstMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdUdpDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdUdpDstMasked, error) {
+	_oxmidudpdstmasked := &OxmIdUdpDstMasked{OxmId: parent}
+	return _oxmidudpdstmasked, nil
+}
+
+func NewOxmIdUdpDstMasked() *OxmIdUdpDstMasked {
+	obj := &OxmIdUdpDstMasked{
+		OxmId: NewOxmId(6404),
+	}
+	return obj
+}
+func (self *OxmIdUdpDstMasked) GetOXMName() string {
+	return "udp_dst_masked"
+}
+
+func (self *OxmIdUdpDstMasked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdUdpSrc struct {
+	*OxmId
+}
+
+type IOxmIdUdpSrc interface {
+	IOxmId
+}
+
+func (self *OxmIdUdpSrc) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdUdpSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdUdpSrc, error) {
+	_oxmidudpsrc := &OxmIdUdpSrc{OxmId: parent}
+	return _oxmidudpsrc, nil
+}
+
+func NewOxmIdUdpSrc() *OxmIdUdpSrc {
+	obj := &OxmIdUdpSrc{
+		OxmId: NewOxmId(5634),
+	}
+	return obj
+}
+func (self *OxmIdUdpSrc) GetOXMName() string {
+	return "udp_src"
+}
+
+func (self *OxmIdUdpSrc) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdUdpSrcMasked struct {
+	*OxmId
+}
+
+type IOxmIdUdpSrcMasked interface {
+	IOxmId
+}
+
+func (self *OxmIdUdpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdUdpSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdUdpSrcMasked, error) {
+	_oxmidudpsrcmasked := &OxmIdUdpSrcMasked{OxmId: parent}
+	return _oxmidudpsrcmasked, nil
+}
+
+func NewOxmIdUdpSrcMasked() *OxmIdUdpSrcMasked {
+	obj := &OxmIdUdpSrcMasked{
+		OxmId: NewOxmId(5892),
+	}
+	return obj
+}
+func (self *OxmIdUdpSrcMasked) GetOXMName() string {
+	return "udp_src_masked"
+}
+
+func (self *OxmIdUdpSrcMasked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdVlanTci struct {
+	*OxmId
+}
+
+type IOxmIdVlanTci interface {
+	IOxmId
+}
+
+func (self *OxmIdVlanTci) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdVlanTci(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdVlanTci, error) {
+	_oxmidvlantci := &OxmIdVlanTci{OxmId: parent}
+	return _oxmidvlantci, nil
+}
+
+func NewOxmIdVlanTci() *OxmIdVlanTci {
+	obj := &OxmIdVlanTci{
+		OxmId: NewOxmId(2050),
+	}
+	return obj
+}
+func (self *OxmIdVlanTci) GetOXMName() string {
+	return "vlan_tci"
+}
+
+func (self *OxmIdVlanTci) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdVlanTciMasked struct {
+	*OxmId
+}
+
+type IOxmIdVlanTciMasked interface {
+	IOxmId
+}
+
+func (self *OxmIdVlanTciMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdVlanTciMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdVlanTciMasked, error) {
+	_oxmidvlantcimasked := &OxmIdVlanTciMasked{OxmId: parent}
+	return _oxmidvlantcimasked, nil
+}
+
+func NewOxmIdVlanTciMasked() *OxmIdVlanTciMasked {
+	obj := &OxmIdVlanTciMasked{
+		OxmId: NewOxmId(2308),
+	}
+	return obj
+}
+func (self *OxmIdVlanTciMasked) GetOXMName() string {
+	return "vlan_tci_masked"
+}
+
+func (self *OxmIdVlanTciMasked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdXxreg0 struct {
+	*OxmId
+}
+
+type IOxmIdXxreg0 interface {
+	IOxmId
+}
+
+func (self *OxmIdXxreg0) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdXxreg0(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg0, error) {
+	_oxmidxxreg0 := &OxmIdXxreg0{OxmId: parent}
+	return _oxmidxxreg0, nil
+}
+
+func NewOxmIdXxreg0() *OxmIdXxreg0 {
+	obj := &OxmIdXxreg0{
+		OxmId: NewOxmId(122384),
+	}
+	return obj
+}
+func (self *OxmIdXxreg0) GetOXMName() string {
+	return "xxreg0"
+}
+
+func (self *OxmIdXxreg0) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdXxreg0Masked struct {
+	*OxmId
+}
+
+type IOxmIdXxreg0Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdXxreg0Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdXxreg0Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg0Masked, error) {
+	_oxmidxxreg0masked := &OxmIdXxreg0Masked{OxmId: parent}
+	return _oxmidxxreg0masked, nil
+}
+
+func NewOxmIdXxreg0Masked() *OxmIdXxreg0Masked {
+	obj := &OxmIdXxreg0Masked{
+		OxmId: NewOxmId(122656),
+	}
+	return obj
+}
+func (self *OxmIdXxreg0Masked) GetOXMName() string {
+	return "xxreg0_masked"
+}
+
+func (self *OxmIdXxreg0Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdXxreg1 struct {
+	*OxmId
+}
+
+type IOxmIdXxreg1 interface {
+	IOxmId
+}
+
+func (self *OxmIdXxreg1) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdXxreg1(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg1, error) {
+	_oxmidxxreg1 := &OxmIdXxreg1{OxmId: parent}
+	return _oxmidxxreg1, nil
+}
+
+func NewOxmIdXxreg1() *OxmIdXxreg1 {
+	obj := &OxmIdXxreg1{
+		OxmId: NewOxmId(122896),
+	}
+	return obj
+}
+func (self *OxmIdXxreg1) GetOXMName() string {
+	return "xxreg1"
+}
+
+func (self *OxmIdXxreg1) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdXxreg1Masked struct {
+	*OxmId
+}
+
+type IOxmIdXxreg1Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdXxreg1Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdXxreg1Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg1Masked, error) {
+	_oxmidxxreg1masked := &OxmIdXxreg1Masked{OxmId: parent}
+	return _oxmidxxreg1masked, nil
+}
+
+func NewOxmIdXxreg1Masked() *OxmIdXxreg1Masked {
+	obj := &OxmIdXxreg1Masked{
+		OxmId: NewOxmId(123168),
+	}
+	return obj
+}
+func (self *OxmIdXxreg1Masked) GetOXMName() string {
+	return "xxreg1_masked"
+}
+
+func (self *OxmIdXxreg1Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdXxreg2 struct {
+	*OxmId
+}
+
+type IOxmIdXxreg2 interface {
+	IOxmId
+}
+
+func (self *OxmIdXxreg2) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdXxreg2(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg2, error) {
+	_oxmidxxreg2 := &OxmIdXxreg2{OxmId: parent}
+	return _oxmidxxreg2, nil
+}
+
+func NewOxmIdXxreg2() *OxmIdXxreg2 {
+	obj := &OxmIdXxreg2{
+		OxmId: NewOxmId(123408),
+	}
+	return obj
+}
+func (self *OxmIdXxreg2) GetOXMName() string {
+	return "xxreg2"
+}
+
+func (self *OxmIdXxreg2) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdXxreg2Masked struct {
+	*OxmId
+}
+
+type IOxmIdXxreg2Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdXxreg2Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdXxreg2Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg2Masked, error) {
+	_oxmidxxreg2masked := &OxmIdXxreg2Masked{OxmId: parent}
+	return _oxmidxxreg2masked, nil
+}
+
+func NewOxmIdXxreg2Masked() *OxmIdXxreg2Masked {
+	obj := &OxmIdXxreg2Masked{
+		OxmId: NewOxmId(123680),
+	}
+	return obj
+}
+func (self *OxmIdXxreg2Masked) GetOXMName() string {
+	return "xxreg2_masked"
+}
+
+func (self *OxmIdXxreg2Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdXxreg3 struct {
+	*OxmId
+}
+
+type IOxmIdXxreg3 interface {
+	IOxmId
+}
+
+func (self *OxmIdXxreg3) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdXxreg3(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg3, error) {
+	_oxmidxxreg3 := &OxmIdXxreg3{OxmId: parent}
+	return _oxmidxxreg3, nil
+}
+
+func NewOxmIdXxreg3() *OxmIdXxreg3 {
+	obj := &OxmIdXxreg3{
+		OxmId: NewOxmId(123920),
+	}
+	return obj
+}
+func (self *OxmIdXxreg3) GetOXMName() string {
+	return "xxreg3"
+}
+
+func (self *OxmIdXxreg3) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdXxreg3Masked struct {
+	*OxmId
+}
+
+type IOxmIdXxreg3Masked interface {
+	IOxmId
+}
+
+func (self *OxmIdXxreg3Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdXxreg3Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg3Masked, error) {
+	_oxmidxxreg3masked := &OxmIdXxreg3Masked{OxmId: parent}
+	return _oxmidxxreg3masked, nil
+}
+
+func NewOxmIdXxreg3Masked() *OxmIdXxreg3Masked {
+	obj := &OxmIdXxreg3Masked{
+		OxmId: NewOxmId(124192),
+	}
+	return obj
+}
+func (self *OxmIdXxreg3Masked) GetOXMName() string {
+	return "xxreg3_masked"
+}
+
+func (self *OxmIdXxreg3Masked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdArpOpMasked struct {
+	*OxmId
+}
+
+type IOxmIdArpOpMasked interface {
+	IOxmId
+}
+
+func (self *OxmIdArpOpMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdArpOpMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpOpMasked, error) {
+	_oxmidarpopmasked := &OxmIdArpOpMasked{OxmId: parent}
+	return _oxmidarpopmasked, nil
+}
+
+func NewOxmIdArpOpMasked() *OxmIdArpOpMasked {
+	obj := &OxmIdArpOpMasked{
+		OxmId: NewOxmId(2147494660),
+	}
+	return obj
+}
+func (self *OxmIdArpOpMasked) GetOXMName() string {
+	return "arp_op_masked"
+}
+
+func (self *OxmIdArpOpMasked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdConnTrackingIpv6Dst struct {
+	*OxmId
+}
+
+type IOxmIdConnTrackingIpv6Dst interface {
+	IOxmId
+}
+
+func (self *OxmIdConnTrackingIpv6Dst) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdConnTrackingIpv6Dst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingIpv6Dst, error) {
+	_oxmidconntrackingipv6dst := &OxmIdConnTrackingIpv6Dst{OxmId: parent}
+	return _oxmidconntrackingipv6dst, nil
+}
+
+func NewOxmIdConnTrackingIpv6Dst() *OxmIdConnTrackingIpv6Dst {
+	obj := &OxmIdConnTrackingIpv6Dst{
+		OxmId: NewOxmId(128528),
+	}
+	return obj
+}
+func (self *OxmIdConnTrackingIpv6Dst) GetOXMName() string {
+	return "conn_tracking_ipv6_dst"
+}
+
+func (self *OxmIdConnTrackingIpv6Dst) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdConnTrackingIpv6DstMasked struct {
+	*OxmId
+}
+
+type IOxmIdConnTrackingIpv6DstMasked interface {
+	IOxmId
+}
+
+func (self *OxmIdConnTrackingIpv6DstMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdConnTrackingIpv6DstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingIpv6DstMasked, error) {
+	_oxmidconntrackingipv6dstmasked := &OxmIdConnTrackingIpv6DstMasked{OxmId: parent}
+	return _oxmidconntrackingipv6dstmasked, nil
+}
+
+func NewOxmIdConnTrackingIpv6DstMasked() *OxmIdConnTrackingIpv6DstMasked {
+	obj := &OxmIdConnTrackingIpv6DstMasked{
+		OxmId: NewOxmId(128800),
+	}
+	return obj
+}
+func (self *OxmIdConnTrackingIpv6DstMasked) GetOXMName() string {
+	return "conn_tracking_ipv6_dst_masked"
+}
+
+func (self *OxmIdConnTrackingIpv6DstMasked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdConnTrackingIpv6Src struct {
+	*OxmId
+}
+
+type IOxmIdConnTrackingIpv6Src interface {
+	IOxmId
+}
+
+func (self *OxmIdConnTrackingIpv6Src) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdConnTrackingIpv6Src(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingIpv6Src, error) {
+	_oxmidconntrackingipv6src := &OxmIdConnTrackingIpv6Src{OxmId: parent}
+	return _oxmidconntrackingipv6src, nil
+}
+
+func NewOxmIdConnTrackingIpv6Src() *OxmIdConnTrackingIpv6Src {
+	obj := &OxmIdConnTrackingIpv6Src{
+		OxmId: NewOxmId(128016),
+	}
+	return obj
+}
+func (self *OxmIdConnTrackingIpv6Src) GetOXMName() string {
+	return "conn_tracking_ipv6_src"
+}
+
+func (self *OxmIdConnTrackingIpv6Src) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdConnTrackingIpv6SrcMasked struct {
+	*OxmId
+}
+
+type IOxmIdConnTrackingIpv6SrcMasked interface {
+	IOxmId
+}
+
+func (self *OxmIdConnTrackingIpv6SrcMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdConnTrackingIpv6SrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingIpv6SrcMasked, error) {
+	_oxmidconntrackingipv6srcmasked := &OxmIdConnTrackingIpv6SrcMasked{OxmId: parent}
+	return _oxmidconntrackingipv6srcmasked, nil
+}
+
+func NewOxmIdConnTrackingIpv6SrcMasked() *OxmIdConnTrackingIpv6SrcMasked {
+	obj := &OxmIdConnTrackingIpv6SrcMasked{
+		OxmId: NewOxmId(128288),
+	}
+	return obj
+}
+func (self *OxmIdConnTrackingIpv6SrcMasked) GetOXMName() string {
+	return "conn_tracking_ipv6_src_masked"
+}
+
+func (self *OxmIdConnTrackingIpv6SrcMasked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdConnTrackingLabel struct {
+	*OxmId
+}
+
+type IOxmIdConnTrackingLabel interface {
+	IOxmId
+}
+
+func (self *OxmIdConnTrackingLabel) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdConnTrackingLabel(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingLabel, error) {
+	_oxmidconntrackinglabel := &OxmIdConnTrackingLabel{OxmId: parent}
+	return _oxmidconntrackinglabel, nil
+}
+
+func NewOxmIdConnTrackingLabel() *OxmIdConnTrackingLabel {
+	obj := &OxmIdConnTrackingLabel{
+		OxmId: NewOxmId(120848),
+	}
+	return obj
+}
+func (self *OxmIdConnTrackingLabel) GetOXMName() string {
+	return "conn_tracking_label"
+}
+
+func (self *OxmIdConnTrackingLabel) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdConnTrackingLabelMasked struct {
+	*OxmId
+}
+
+type IOxmIdConnTrackingLabelMasked interface {
+	IOxmId
+}
+
+func (self *OxmIdConnTrackingLabelMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdConnTrackingLabelMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingLabelMasked, error) {
+	_oxmidconntrackinglabelmasked := &OxmIdConnTrackingLabelMasked{OxmId: parent}
+	return _oxmidconntrackinglabelmasked, nil
+}
+
+func NewOxmIdConnTrackingLabelMasked() *OxmIdConnTrackingLabelMasked {
+	obj := &OxmIdConnTrackingLabelMasked{
+		OxmId: NewOxmId(121120),
+	}
+	return obj
+}
+func (self *OxmIdConnTrackingLabelMasked) GetOXMName() string {
+	return "conn_tracking_label_masked"
+}
+
+func (self *OxmIdConnTrackingLabelMasked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdConnTrackingMark struct {
+	*OxmId
+}
+
+type IOxmIdConnTrackingMark interface {
+	IOxmId
+}
+
+func (self *OxmIdConnTrackingMark) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdConnTrackingMark(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingMark, error) {
+	_oxmidconntrackingmark := &OxmIdConnTrackingMark{OxmId: parent}
+	return _oxmidconntrackingmark, nil
+}
+
+func NewOxmIdConnTrackingMark() *OxmIdConnTrackingMark {
+	obj := &OxmIdConnTrackingMark{
+		OxmId: NewOxmId(120324),
+	}
+	return obj
+}
+func (self *OxmIdConnTrackingMark) GetOXMName() string {
+	return "conn_tracking_mark"
+}
+
+func (self *OxmIdConnTrackingMark) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdConnTrackingMarkMasked struct {
+	*OxmId
+}
+
+type IOxmIdConnTrackingMarkMasked interface {
+	IOxmId
+}
+
+func (self *OxmIdConnTrackingMarkMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdConnTrackingMarkMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingMarkMasked, error) {
+	_oxmidconntrackingmarkmasked := &OxmIdConnTrackingMarkMasked{OxmId: parent}
+	return _oxmidconntrackingmarkmasked, nil
+}
+
+func NewOxmIdConnTrackingMarkMasked() *OxmIdConnTrackingMarkMasked {
+	obj := &OxmIdConnTrackingMarkMasked{
+		OxmId: NewOxmId(120584),
+	}
+	return obj
+}
+func (self *OxmIdConnTrackingMarkMasked) GetOXMName() string {
+	return "conn_tracking_mark_masked"
+}
+
+func (self *OxmIdConnTrackingMarkMasked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdConnTrackingNwDst struct {
+	*OxmId
+}
+
+type IOxmIdConnTrackingNwDst interface {
+	IOxmId
+}
+
+func (self *OxmIdConnTrackingNwDst) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdConnTrackingNwDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingNwDst, error) {
+	_oxmidconntrackingnwdst := &OxmIdConnTrackingNwDst{OxmId: parent}
+	return _oxmidconntrackingnwdst, nil
+}
+
+func NewOxmIdConnTrackingNwDst() *OxmIdConnTrackingNwDst {
+	obj := &OxmIdConnTrackingNwDst{
+		OxmId: NewOxmId(127492),
+	}
+	return obj
+}
+func (self *OxmIdConnTrackingNwDst) GetOXMName() string {
+	return "conn_tracking_nw_dst"
+}
+
+func (self *OxmIdConnTrackingNwDst) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdConnTrackingNwDstMasked struct {
+	*OxmId
+}
+
+type IOxmIdConnTrackingNwDstMasked interface {
+	IOxmId
+}
+
+func (self *OxmIdConnTrackingNwDstMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdConnTrackingNwDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingNwDstMasked, error) {
+	_oxmidconntrackingnwdstmasked := &OxmIdConnTrackingNwDstMasked{OxmId: parent}
+	return _oxmidconntrackingnwdstmasked, nil
+}
+
+func NewOxmIdConnTrackingNwDstMasked() *OxmIdConnTrackingNwDstMasked {
+	obj := &OxmIdConnTrackingNwDstMasked{
+		OxmId: NewOxmId(127752),
+	}
+	return obj
+}
+func (self *OxmIdConnTrackingNwDstMasked) GetOXMName() string {
+	return "conn_tracking_nw_dst_masked"
+}
+
+func (self *OxmIdConnTrackingNwDstMasked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdConnTrackingNwProto struct {
+	*OxmId
+}
+
+type IOxmIdConnTrackingNwProto interface {
+	IOxmId
+}
+
+func (self *OxmIdConnTrackingNwProto) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdConnTrackingNwProto(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingNwProto, error) {
+	_oxmidconntrackingnwproto := &OxmIdConnTrackingNwProto{OxmId: parent}
+	return _oxmidconntrackingnwproto, nil
+}
+
+func NewOxmIdConnTrackingNwProto() *OxmIdConnTrackingNwProto {
+	obj := &OxmIdConnTrackingNwProto{
+		OxmId: NewOxmId(126465),
+	}
+	return obj
+}
+func (self *OxmIdConnTrackingNwProto) GetOXMName() string {
+	return "conn_tracking_nw_proto"
+}
+
+func (self *OxmIdConnTrackingNwProto) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdConnTrackingNwProtoMasked struct {
+	*OxmId
+}
+
+type IOxmIdConnTrackingNwProtoMasked interface {
+	IOxmId
+}
+
+func (self *OxmIdConnTrackingNwProtoMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdConnTrackingNwProtoMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingNwProtoMasked, error) {
+	_oxmidconntrackingnwprotomasked := &OxmIdConnTrackingNwProtoMasked{OxmId: parent}
+	return _oxmidconntrackingnwprotomasked, nil
+}
+
+func NewOxmIdConnTrackingNwProtoMasked() *OxmIdConnTrackingNwProtoMasked {
+	obj := &OxmIdConnTrackingNwProtoMasked{
+		OxmId: NewOxmId(126722),
+	}
+	return obj
+}
+func (self *OxmIdConnTrackingNwProtoMasked) GetOXMName() string {
+	return "conn_tracking_nw_proto_masked"
+}
+
+func (self *OxmIdConnTrackingNwProtoMasked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdConnTrackingNwSrc struct {
+	*OxmId
+}
+
+type IOxmIdConnTrackingNwSrc interface {
+	IOxmId
+}
+
+func (self *OxmIdConnTrackingNwSrc) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdConnTrackingNwSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingNwSrc, error) {
+	_oxmidconntrackingnwsrc := &OxmIdConnTrackingNwSrc{OxmId: parent}
+	return _oxmidconntrackingnwsrc, nil
+}
+
+func NewOxmIdConnTrackingNwSrc() *OxmIdConnTrackingNwSrc {
+	obj := &OxmIdConnTrackingNwSrc{
+		OxmId: NewOxmId(126980),
+	}
+	return obj
+}
+func (self *OxmIdConnTrackingNwSrc) GetOXMName() string {
+	return "conn_tracking_nw_src"
+}
+
+func (self *OxmIdConnTrackingNwSrc) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdConnTrackingNwSrcMasked struct {
+	*OxmId
+}
+
+type IOxmIdConnTrackingNwSrcMasked interface {
+	IOxmId
+}
+
+func (self *OxmIdConnTrackingNwSrcMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdConnTrackingNwSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingNwSrcMasked, error) {
+	_oxmidconntrackingnwsrcmasked := &OxmIdConnTrackingNwSrcMasked{OxmId: parent}
+	return _oxmidconntrackingnwsrcmasked, nil
+}
+
+func NewOxmIdConnTrackingNwSrcMasked() *OxmIdConnTrackingNwSrcMasked {
+	obj := &OxmIdConnTrackingNwSrcMasked{
+		OxmId: NewOxmId(127240),
+	}
+	return obj
+}
+func (self *OxmIdConnTrackingNwSrcMasked) GetOXMName() string {
+	return "conn_tracking_nw_src_masked"
+}
+
+func (self *OxmIdConnTrackingNwSrcMasked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdConnTrackingState struct {
+	*OxmId
+}
+
+type IOxmIdConnTrackingState interface {
+	IOxmId
+}
+
+func (self *OxmIdConnTrackingState) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdConnTrackingState(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingState, error) {
+	_oxmidconntrackingstate := &OxmIdConnTrackingState{OxmId: parent}
+	return _oxmidconntrackingstate, nil
+}
+
+func NewOxmIdConnTrackingState() *OxmIdConnTrackingState {
+	obj := &OxmIdConnTrackingState{
+		OxmId: NewOxmId(119300),
+	}
+	return obj
+}
+func (self *OxmIdConnTrackingState) GetOXMName() string {
+	return "conn_tracking_state"
+}
+
+func (self *OxmIdConnTrackingState) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdConnTrackingStateMasked struct {
+	*OxmId
+}
+
+type IOxmIdConnTrackingStateMasked interface {
+	IOxmId
+}
+
+func (self *OxmIdConnTrackingStateMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdConnTrackingStateMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingStateMasked, error) {
+	_oxmidconntrackingstatemasked := &OxmIdConnTrackingStateMasked{OxmId: parent}
+	return _oxmidconntrackingstatemasked, nil
+}
+
+func NewOxmIdConnTrackingStateMasked() *OxmIdConnTrackingStateMasked {
+	obj := &OxmIdConnTrackingStateMasked{
+		OxmId: NewOxmId(119560),
+	}
+	return obj
+}
+func (self *OxmIdConnTrackingStateMasked) GetOXMName() string {
+	return "conn_tracking_state_masked"
+}
+
+func (self *OxmIdConnTrackingStateMasked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdConnTrackingTpDst struct {
+	*OxmId
+}
+
+type IOxmIdConnTrackingTpDst interface {
+	IOxmId
+}
+
+func (self *OxmIdConnTrackingTpDst) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdConnTrackingTpDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingTpDst, error) {
+	_oxmidconntrackingtpdst := &OxmIdConnTrackingTpDst{OxmId: parent}
+	return _oxmidconntrackingtpdst, nil
+}
+
+func NewOxmIdConnTrackingTpDst() *OxmIdConnTrackingTpDst {
+	obj := &OxmIdConnTrackingTpDst{
+		OxmId: NewOxmId(129538),
+	}
+	return obj
+}
+func (self *OxmIdConnTrackingTpDst) GetOXMName() string {
+	return "conn_tracking_tp_dst"
+}
+
+func (self *OxmIdConnTrackingTpDst) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdConnTrackingTpDstMasked struct {
+	*OxmId
+}
+
+type IOxmIdConnTrackingTpDstMasked interface {
+	IOxmId
+}
+
+func (self *OxmIdConnTrackingTpDstMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdConnTrackingTpDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingTpDstMasked, error) {
+	_oxmidconntrackingtpdstmasked := &OxmIdConnTrackingTpDstMasked{OxmId: parent}
+	return _oxmidconntrackingtpdstmasked, nil
+}
+
+func NewOxmIdConnTrackingTpDstMasked() *OxmIdConnTrackingTpDstMasked {
+	obj := &OxmIdConnTrackingTpDstMasked{
+		OxmId: NewOxmId(129796),
+	}
+	return obj
+}
+func (self *OxmIdConnTrackingTpDstMasked) GetOXMName() string {
+	return "conn_tracking_tp_dst_masked"
+}
+
+func (self *OxmIdConnTrackingTpDstMasked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdConnTrackingTpSrc struct {
+	*OxmId
+}
+
+type IOxmIdConnTrackingTpSrc interface {
+	IOxmId
+}
+
+func (self *OxmIdConnTrackingTpSrc) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdConnTrackingTpSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingTpSrc, error) {
+	_oxmidconntrackingtpsrc := &OxmIdConnTrackingTpSrc{OxmId: parent}
+	return _oxmidconntrackingtpsrc, nil
+}
+
+func NewOxmIdConnTrackingTpSrc() *OxmIdConnTrackingTpSrc {
+	obj := &OxmIdConnTrackingTpSrc{
+		OxmId: NewOxmId(129026),
+	}
+	return obj
+}
+func (self *OxmIdConnTrackingTpSrc) GetOXMName() string {
+	return "conn_tracking_tp_src"
+}
+
+func (self *OxmIdConnTrackingTpSrc) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdConnTrackingTpSrcMasked struct {
+	*OxmId
+}
+
+type IOxmIdConnTrackingTpSrcMasked interface {
+	IOxmId
+}
+
+func (self *OxmIdConnTrackingTpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdConnTrackingTpSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingTpSrcMasked, error) {
+	_oxmidconntrackingtpsrcmasked := &OxmIdConnTrackingTpSrcMasked{OxmId: parent}
+	return _oxmidconntrackingtpsrcmasked, nil
+}
+
+func NewOxmIdConnTrackingTpSrcMasked() *OxmIdConnTrackingTpSrcMasked {
+	obj := &OxmIdConnTrackingTpSrcMasked{
+		OxmId: NewOxmId(129284),
+	}
+	return obj
+}
+func (self *OxmIdConnTrackingTpSrcMasked) GetOXMName() string {
+	return "conn_tracking_tp_src_masked"
+}
+
+func (self *OxmIdConnTrackingTpSrcMasked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdConnTrackingZone struct {
+	*OxmId
+}
+
+type IOxmIdConnTrackingZone interface {
+	IOxmId
+}
+
+func (self *OxmIdConnTrackingZone) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdConnTrackingZone(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingZone, error) {
+	_oxmidconntrackingzone := &OxmIdConnTrackingZone{OxmId: parent}
+	return _oxmidconntrackingzone, nil
+}
+
+func NewOxmIdConnTrackingZone() *OxmIdConnTrackingZone {
+	obj := &OxmIdConnTrackingZone{
+		OxmId: NewOxmId(119810),
+	}
+	return obj
+}
+func (self *OxmIdConnTrackingZone) GetOXMName() string {
+	return "conn_tracking_zone"
+}
+
+func (self *OxmIdConnTrackingZone) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdConnTrackingZoneMasked struct {
+	*OxmId
+}
+
+type IOxmIdConnTrackingZoneMasked interface {
+	IOxmId
+}
+
+func (self *OxmIdConnTrackingZoneMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdConnTrackingZoneMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingZoneMasked, error) {
+	_oxmidconntrackingzonemasked := &OxmIdConnTrackingZoneMasked{OxmId: parent}
+	return _oxmidconntrackingzonemasked, nil
+}
+
+func NewOxmIdConnTrackingZoneMasked() *OxmIdConnTrackingZoneMasked {
+	obj := &OxmIdConnTrackingZoneMasked{
+		OxmId: NewOxmId(120068),
+	}
+	return obj
+}
+func (self *OxmIdConnTrackingZoneMasked) GetOXMName() string {
+	return "conn_tracking_zone_masked"
+}
+
+func (self *OxmIdConnTrackingZoneMasked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdEthTypeMasked struct {
+	*OxmId
+}
+
+type IOxmIdEthTypeMasked interface {
+	IOxmId
+}
+
+func (self *OxmIdEthTypeMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdEthTypeMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdEthTypeMasked, error) {
+	_oxmidethtypemasked := &OxmIdEthTypeMasked{OxmId: parent}
+	return _oxmidethtypemasked, nil
+}
+
+func NewOxmIdEthTypeMasked() *OxmIdEthTypeMasked {
+	obj := &OxmIdEthTypeMasked{
+		OxmId: NewOxmId(2147486468),
+	}
+	return obj
+}
+func (self *OxmIdEthTypeMasked) GetOXMName() string {
+	return "eth_type_masked"
+}
+
+func (self *OxmIdEthTypeMasked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdIcmpv4Code struct {
+	*OxmId
+}
+
+type IOxmIdIcmpv4Code interface {
+	IOxmId
+}
+
+func (self *OxmIdIcmpv4Code) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdIcmpv4Code(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv4Code, error) {
+	_oxmidicmpv4code := &OxmIdIcmpv4Code{OxmId: parent}
+	return _oxmidicmpv4code, nil
+}
+
+func NewOxmIdIcmpv4Code() *OxmIdIcmpv4Code {
+	obj := &OxmIdIcmpv4Code{
+		OxmId: NewOxmId(2147493889),
+	}
+	return obj
+}
+func (self *OxmIdIcmpv4Code) GetOXMName() string {
+	return "icmpv4_code"
+}
+
+func (self *OxmIdIcmpv4Code) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdIcmpv4CodeMasked struct {
+	*OxmId
+}
+
+type IOxmIdIcmpv4CodeMasked interface {
+	IOxmId
+}
+
+func (self *OxmIdIcmpv4CodeMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdIcmpv4CodeMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv4CodeMasked, error) {
+	_oxmidicmpv4codemasked := &OxmIdIcmpv4CodeMasked{OxmId: parent}
+	return _oxmidicmpv4codemasked, nil
+}
+
+func NewOxmIdIcmpv4CodeMasked() *OxmIdIcmpv4CodeMasked {
+	obj := &OxmIdIcmpv4CodeMasked{
+		OxmId: NewOxmId(2147494146),
+	}
+	return obj
+}
+func (self *OxmIdIcmpv4CodeMasked) GetOXMName() string {
+	return "icmpv4_code_masked"
+}
+
+func (self *OxmIdIcmpv4CodeMasked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdIcmpv4Type struct {
+	*OxmId
+}
+
+type IOxmIdIcmpv4Type interface {
+	IOxmId
+}
+
+func (self *OxmIdIcmpv4Type) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdIcmpv4Type(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv4Type, error) {
+	_oxmidicmpv4type := &OxmIdIcmpv4Type{OxmId: parent}
+	return _oxmidicmpv4type, nil
+}
+
+func NewOxmIdIcmpv4Type() *OxmIdIcmpv4Type {
+	obj := &OxmIdIcmpv4Type{
+		OxmId: NewOxmId(2147493377),
+	}
+	return obj
+}
+func (self *OxmIdIcmpv4Type) GetOXMName() string {
+	return "icmpv4_type"
+}
+
+func (self *OxmIdIcmpv4Type) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdIcmpv4TypeMasked struct {
+	*OxmId
+}
+
+type IOxmIdIcmpv4TypeMasked interface {
+	IOxmId
+}
+
+func (self *OxmIdIcmpv4TypeMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdIcmpv4TypeMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv4TypeMasked, error) {
+	_oxmidicmpv4typemasked := &OxmIdIcmpv4TypeMasked{OxmId: parent}
+	return _oxmidicmpv4typemasked, nil
+}
+
+func NewOxmIdIcmpv4TypeMasked() *OxmIdIcmpv4TypeMasked {
+	obj := &OxmIdIcmpv4TypeMasked{
+		OxmId: NewOxmId(2147493634),
+	}
+	return obj
+}
+func (self *OxmIdIcmpv4TypeMasked) GetOXMName() string {
+	return "icmpv4_type_masked"
+}
+
+func (self *OxmIdIcmpv4TypeMasked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdIcmpv6CodeMasked struct {
+	*OxmId
+}
+
+type IOxmIdIcmpv6CodeMasked interface {
+	IOxmId
+}
+
+func (self *OxmIdIcmpv6CodeMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdIcmpv6CodeMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv6CodeMasked, error) {
+	_oxmidicmpv6codemasked := &OxmIdIcmpv6CodeMasked{OxmId: parent}
+	return _oxmidicmpv6codemasked, nil
+}
+
+func NewOxmIdIcmpv6CodeMasked() *OxmIdIcmpv6CodeMasked {
+	obj := &OxmIdIcmpv6CodeMasked{
+		OxmId: NewOxmId(2147499266),
+	}
+	return obj
+}
+func (self *OxmIdIcmpv6CodeMasked) GetOXMName() string {
+	return "icmpv6_code_masked"
+}
+
+func (self *OxmIdIcmpv6CodeMasked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdIcmpv6TypeMasked struct {
+	*OxmId
+}
+
+type IOxmIdIcmpv6TypeMasked interface {
+	IOxmId
+}
+
+func (self *OxmIdIcmpv6TypeMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdIcmpv6TypeMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv6TypeMasked, error) {
+	_oxmidicmpv6typemasked := &OxmIdIcmpv6TypeMasked{OxmId: parent}
+	return _oxmidicmpv6typemasked, nil
+}
+
+func NewOxmIdIcmpv6TypeMasked() *OxmIdIcmpv6TypeMasked {
+	obj := &OxmIdIcmpv6TypeMasked{
+		OxmId: NewOxmId(2147498754),
+	}
+	return obj
+}
+func (self *OxmIdIcmpv6TypeMasked) GetOXMName() string {
+	return "icmpv6_type_masked"
+}
+
+func (self *OxmIdIcmpv6TypeMasked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdInPhyPort struct {
+	*OxmId
+}
+
+type IOxmIdInPhyPort interface {
+	IOxmId
+}
+
+func (self *OxmIdInPhyPort) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdInPhyPort(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdInPhyPort, error) {
+	_oxmidinphyport := &OxmIdInPhyPort{OxmId: parent}
+	return _oxmidinphyport, nil
+}
+
+func NewOxmIdInPhyPort() *OxmIdInPhyPort {
+	obj := &OxmIdInPhyPort{
+		OxmId: NewOxmId(2147484164),
+	}
+	return obj
+}
+func (self *OxmIdInPhyPort) GetOXMName() string {
+	return "in_phy_port"
+}
+
+func (self *OxmIdInPhyPort) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdInPhyPortMasked struct {
+	*OxmId
+}
+
+type IOxmIdInPhyPortMasked interface {
+	IOxmId
+}
+
+func (self *OxmIdInPhyPortMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdInPhyPortMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdInPhyPortMasked, error) {
+	_oxmidinphyportmasked := &OxmIdInPhyPortMasked{OxmId: parent}
+	return _oxmidinphyportmasked, nil
+}
+
+func NewOxmIdInPhyPortMasked() *OxmIdInPhyPortMasked {
+	obj := &OxmIdInPhyPortMasked{
+		OxmId: NewOxmId(2147484424),
+	}
+	return obj
+}
+func (self *OxmIdInPhyPortMasked) GetOXMName() string {
+	return "in_phy_port_masked"
+}
+
+func (self *OxmIdInPhyPortMasked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdInPortMasked struct {
+	*OxmId
+}
+
+type IOxmIdInPortMasked interface {
+	IOxmId
+}
+
+func (self *OxmIdInPortMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdInPortMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdInPortMasked, error) {
+	_oxmidinportmasked := &OxmIdInPortMasked{OxmId: parent}
+	return _oxmidinportmasked, nil
+}
+
+func NewOxmIdInPortMasked() *OxmIdInPortMasked {
+	obj := &OxmIdInPortMasked{
+		OxmId: NewOxmId(2147483912),
+	}
+	return obj
+}
+func (self *OxmIdInPortMasked) GetOXMName() string {
+	return "in_port_masked"
+}
+
+func (self *OxmIdInPortMasked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdIpDscp struct {
+	*OxmId
+}
+
+type IOxmIdIpDscp interface {
+	IOxmId
+}
+
+func (self *OxmIdIpDscp) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdIpDscp(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpDscp, error) {
+	_oxmidipdscp := &OxmIdIpDscp{OxmId: parent}
+	return _oxmidipdscp, nil
+}
+
+func NewOxmIdIpDscp() *OxmIdIpDscp {
+	obj := &OxmIdIpDscp{
+		OxmId: NewOxmId(2147487745),
+	}
+	return obj
+}
+func (self *OxmIdIpDscp) GetOXMName() string {
+	return "ip_dscp"
+}
+
+func (self *OxmIdIpDscp) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdIpDscpMasked struct {
+	*OxmId
+}
+
+type IOxmIdIpDscpMasked interface {
+	IOxmId
+}
+
+func (self *OxmIdIpDscpMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdIpDscpMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpDscpMasked, error) {
+	_oxmidipdscpmasked := &OxmIdIpDscpMasked{OxmId: parent}
+	return _oxmidipdscpmasked, nil
+}
+
+func NewOxmIdIpDscpMasked() *OxmIdIpDscpMasked {
+	obj := &OxmIdIpDscpMasked{
+		OxmId: NewOxmId(2147488002),
+	}
+	return obj
+}
+func (self *OxmIdIpDscpMasked) GetOXMName() string {
+	return "ip_dscp_masked"
+}
+
+func (self *OxmIdIpDscpMasked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdIpEcn struct {
+	*OxmId
+}
+
+type IOxmIdIpEcn interface {
+	IOxmId
+}
+
+func (self *OxmIdIpEcn) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdIpEcn(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpEcn, error) {
+	_oxmidipecn := &OxmIdIpEcn{OxmId: parent}
+	return _oxmidipecn, nil
+}
+
+func NewOxmIdIpEcn() *OxmIdIpEcn {
+	obj := &OxmIdIpEcn{
+		OxmId: NewOxmId(2147488257),
+	}
+	return obj
+}
+func (self *OxmIdIpEcn) GetOXMName() string {
+	return "ip_ecn"
+}
+
+func (self *OxmIdIpEcn) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdIpEcnMasked struct {
+	*OxmId
+}
+
+type IOxmIdIpEcnMasked interface {
+	IOxmId
+}
+
+func (self *OxmIdIpEcnMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdIpEcnMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpEcnMasked, error) {
+	_oxmidipecnmasked := &OxmIdIpEcnMasked{OxmId: parent}
+	return _oxmidipecnmasked, nil
+}
+
+func NewOxmIdIpEcnMasked() *OxmIdIpEcnMasked {
+	obj := &OxmIdIpEcnMasked{
+		OxmId: NewOxmId(2147488514),
+	}
+	return obj
+}
+func (self *OxmIdIpEcnMasked) GetOXMName() string {
+	return "ip_ecn_masked"
+}
+
+func (self *OxmIdIpEcnMasked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdIpProto struct {
+	*OxmId
+}
+
+type IOxmIdIpProto interface {
+	IOxmId
+}
+
+func (self *OxmIdIpProto) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdIpProto(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpProto, error) {
+	_oxmidipproto := &OxmIdIpProto{OxmId: parent}
+	return _oxmidipproto, nil
+}
+
+func NewOxmIdIpProto() *OxmIdIpProto {
+	obj := &OxmIdIpProto{
+		OxmId: NewOxmId(2147488769),
+	}
+	return obj
+}
+func (self *OxmIdIpProto) GetOXMName() string {
+	return "ip_proto"
+}
+
+func (self *OxmIdIpProto) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdIpProtoMasked struct {
+	*OxmId
+}
+
+type IOxmIdIpProtoMasked interface {
+	IOxmId
+}
+
+func (self *OxmIdIpProtoMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdIpProtoMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpProtoMasked, error) {
+	_oxmidipprotomasked := &OxmIdIpProtoMasked{OxmId: parent}
+	return _oxmidipprotomasked, nil
+}
+
+func NewOxmIdIpProtoMasked() *OxmIdIpProtoMasked {
+	obj := &OxmIdIpProtoMasked{
+		OxmId: NewOxmId(2147489026),
+	}
+	return obj
+}
+func (self *OxmIdIpProtoMasked) GetOXMName() string {
+	return "ip_proto_masked"
+}
+
+func (self *OxmIdIpProtoMasked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdIpv4Dst struct {
+	*OxmId
+}
+
+type IOxmIdIpv4Dst interface {
+	IOxmId
+}
+
+func (self *OxmIdIpv4Dst) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdIpv4Dst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv4Dst, error) {
+	_oxmidipv4dst := &OxmIdIpv4Dst{OxmId: parent}
+	return _oxmidipv4dst, nil
+}
+
+func NewOxmIdIpv4Dst() *OxmIdIpv4Dst {
+	obj := &OxmIdIpv4Dst{
+		OxmId: NewOxmId(2147489796),
+	}
+	return obj
+}
+func (self *OxmIdIpv4Dst) GetOXMName() string {
+	return "ipv4_dst"
+}
+
+func (self *OxmIdIpv4Dst) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdIpv4DstMasked struct {
+	*OxmId
+}
+
+type IOxmIdIpv4DstMasked interface {
+	IOxmId
+}
+
+func (self *OxmIdIpv4DstMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdIpv4DstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv4DstMasked, error) {
+	_oxmidipv4dstmasked := &OxmIdIpv4DstMasked{OxmId: parent}
+	return _oxmidipv4dstmasked, nil
+}
+
+func NewOxmIdIpv4DstMasked() *OxmIdIpv4DstMasked {
+	obj := &OxmIdIpv4DstMasked{
+		OxmId: NewOxmId(2147490056),
+	}
+	return obj
+}
+func (self *OxmIdIpv4DstMasked) GetOXMName() string {
+	return "ipv4_dst_masked"
+}
+
+func (self *OxmIdIpv4DstMasked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdIpv4Src struct {
+	*OxmId
+}
+
+type IOxmIdIpv4Src interface {
+	IOxmId
+}
+
+func (self *OxmIdIpv4Src) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdIpv4Src(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv4Src, error) {
+	_oxmidipv4src := &OxmIdIpv4Src{OxmId: parent}
+	return _oxmidipv4src, nil
+}
+
+func NewOxmIdIpv4Src() *OxmIdIpv4Src {
+	obj := &OxmIdIpv4Src{
+		OxmId: NewOxmId(2147489284),
+	}
+	return obj
+}
+func (self *OxmIdIpv4Src) GetOXMName() string {
+	return "ipv4_src"
+}
+
+func (self *OxmIdIpv4Src) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdIpv4SrcMasked struct {
+	*OxmId
+}
+
+type IOxmIdIpv4SrcMasked interface {
+	IOxmId
+}
+
+func (self *OxmIdIpv4SrcMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdIpv4SrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv4SrcMasked, error) {
+	_oxmidipv4srcmasked := &OxmIdIpv4SrcMasked{OxmId: parent}
+	return _oxmidipv4srcmasked, nil
+}
+
+func NewOxmIdIpv4SrcMasked() *OxmIdIpv4SrcMasked {
+	obj := &OxmIdIpv4SrcMasked{
+		OxmId: NewOxmId(2147489544),
+	}
+	return obj
+}
+func (self *OxmIdIpv4SrcMasked) GetOXMName() string {
+	return "ipv4_src_masked"
+}
+
+func (self *OxmIdIpv4SrcMasked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdIpv6Flabel struct {
+	*OxmId
+}
+
+type IOxmIdIpv6Flabel interface {
+	IOxmId
+}
+
+func (self *OxmIdIpv6Flabel) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdIpv6Flabel(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6Flabel, error) {
+	_oxmidipv6flabel := &OxmIdIpv6Flabel{OxmId: parent}
+	return _oxmidipv6flabel, nil
+}
+
+func NewOxmIdIpv6Flabel() *OxmIdIpv6Flabel {
+	obj := &OxmIdIpv6Flabel{
+		OxmId: NewOxmId(2147497988),
+	}
+	return obj
+}
+func (self *OxmIdIpv6Flabel) GetOXMName() string {
+	return "ipv6_flabel"
+}
+
+func (self *OxmIdIpv6Flabel) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdIpv6FlabelMasked struct {
+	*OxmId
+}
+
+type IOxmIdIpv6FlabelMasked interface {
+	IOxmId
+}
+
+func (self *OxmIdIpv6FlabelMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdIpv6FlabelMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6FlabelMasked, error) {
+	_oxmidipv6flabelmasked := &OxmIdIpv6FlabelMasked{OxmId: parent}
+	return _oxmidipv6flabelmasked, nil
+}
+
+func NewOxmIdIpv6FlabelMasked() *OxmIdIpv6FlabelMasked {
+	obj := &OxmIdIpv6FlabelMasked{
+		OxmId: NewOxmId(2147498248),
+	}
+	return obj
+}
+func (self *OxmIdIpv6FlabelMasked) GetOXMName() string {
+	return "ipv6_flabel_masked"
+}
+
+func (self *OxmIdIpv6FlabelMasked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdIpv6NdSll struct {
+	*OxmId
+}
+
+type IOxmIdIpv6NdSll interface {
+	IOxmId
+}
+
+func (self *OxmIdIpv6NdSll) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdIpv6NdSll(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6NdSll, error) {
+	_oxmidipv6ndsll := &OxmIdIpv6NdSll{OxmId: parent}
+	return _oxmidipv6ndsll, nil
+}
+
+func NewOxmIdIpv6NdSll() *OxmIdIpv6NdSll {
+	obj := &OxmIdIpv6NdSll{
+		OxmId: NewOxmId(2147500038),
+	}
+	return obj
+}
+func (self *OxmIdIpv6NdSll) GetOXMName() string {
+	return "ipv6_nd_sll"
+}
+
+func (self *OxmIdIpv6NdSll) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdIpv6NdSllMasked struct {
+	*OxmId
+}
+
+type IOxmIdIpv6NdSllMasked interface {
+	IOxmId
+}
+
+func (self *OxmIdIpv6NdSllMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdIpv6NdSllMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6NdSllMasked, error) {
+	_oxmidipv6ndsllmasked := &OxmIdIpv6NdSllMasked{OxmId: parent}
+	return _oxmidipv6ndsllmasked, nil
+}
+
+func NewOxmIdIpv6NdSllMasked() *OxmIdIpv6NdSllMasked {
+	obj := &OxmIdIpv6NdSllMasked{
+		OxmId: NewOxmId(2147500300),
+	}
+	return obj
+}
+func (self *OxmIdIpv6NdSllMasked) GetOXMName() string {
+	return "ipv6_nd_sll_masked"
+}
+
+func (self *OxmIdIpv6NdSllMasked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdIpv6NdTarget struct {
+	*OxmId
+}
+
+type IOxmIdIpv6NdTarget interface {
+	IOxmId
+}
+
+func (self *OxmIdIpv6NdTarget) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdIpv6NdTarget(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6NdTarget, error) {
+	_oxmidipv6ndtarget := &OxmIdIpv6NdTarget{OxmId: parent}
+	return _oxmidipv6ndtarget, nil
+}
+
+func NewOxmIdIpv6NdTarget() *OxmIdIpv6NdTarget {
+	obj := &OxmIdIpv6NdTarget{
+		OxmId: NewOxmId(2147499536),
+	}
+	return obj
+}
+func (self *OxmIdIpv6NdTarget) GetOXMName() string {
+	return "ipv6_nd_target"
+}
+
+func (self *OxmIdIpv6NdTarget) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdIpv6NdTargetMasked struct {
+	*OxmId
+}
+
+type IOxmIdIpv6NdTargetMasked interface {
+	IOxmId
+}
+
+func (self *OxmIdIpv6NdTargetMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdIpv6NdTargetMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6NdTargetMasked, error) {
+	_oxmidipv6ndtargetmasked := &OxmIdIpv6NdTargetMasked{OxmId: parent}
+	return _oxmidipv6ndtargetmasked, nil
+}
+
+func NewOxmIdIpv6NdTargetMasked() *OxmIdIpv6NdTargetMasked {
+	obj := &OxmIdIpv6NdTargetMasked{
+		OxmId: NewOxmId(2147499808),
+	}
+	return obj
+}
+func (self *OxmIdIpv6NdTargetMasked) GetOXMName() string {
+	return "ipv6_nd_target_masked"
+}
+
+func (self *OxmIdIpv6NdTargetMasked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdIpv6NdTll struct {
+	*OxmId
+}
+
+type IOxmIdIpv6NdTll interface {
+	IOxmId
+}
+
+func (self *OxmIdIpv6NdTll) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdIpv6NdTll(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6NdTll, error) {
+	_oxmidipv6ndtll := &OxmIdIpv6NdTll{OxmId: parent}
+	return _oxmidipv6ndtll, nil
+}
+
+func NewOxmIdIpv6NdTll() *OxmIdIpv6NdTll {
+	obj := &OxmIdIpv6NdTll{
+		OxmId: NewOxmId(2147500550),
+	}
+	return obj
+}
+func (self *OxmIdIpv6NdTll) GetOXMName() string {
+	return "ipv6_nd_tll"
+}
+
+func (self *OxmIdIpv6NdTll) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdIpv6NdTllMasked struct {
+	*OxmId
+}
+
+type IOxmIdIpv6NdTllMasked interface {
+	IOxmId
+}
+
+func (self *OxmIdIpv6NdTllMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdIpv6NdTllMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6NdTllMasked, error) {
+	_oxmidipv6ndtllmasked := &OxmIdIpv6NdTllMasked{OxmId: parent}
+	return _oxmidipv6ndtllmasked, nil
+}
+
+func NewOxmIdIpv6NdTllMasked() *OxmIdIpv6NdTllMasked {
+	obj := &OxmIdIpv6NdTllMasked{
+		OxmId: NewOxmId(2147500812),
+	}
+	return obj
+}
+func (self *OxmIdIpv6NdTllMasked) GetOXMName() string {
+	return "ipv6_nd_tll_masked"
+}
+
+func (self *OxmIdIpv6NdTllMasked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdMetadata struct {
+	*OxmId
+}
+
+type IOxmIdMetadata interface {
+	IOxmId
+}
+
+func (self *OxmIdMetadata) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdMetadata(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMetadata, error) {
+	_oxmidmetadata := &OxmIdMetadata{OxmId: parent}
+	return _oxmidmetadata, nil
+}
+
+func NewOxmIdMetadata() *OxmIdMetadata {
+	obj := &OxmIdMetadata{
+		OxmId: NewOxmId(2147484680),
+	}
+	return obj
+}
+func (self *OxmIdMetadata) GetOXMName() string {
+	return "metadata"
+}
+
+func (self *OxmIdMetadata) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdMetadataMasked struct {
+	*OxmId
+}
+
+type IOxmIdMetadataMasked interface {
+	IOxmId
+}
+
+func (self *OxmIdMetadataMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdMetadataMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMetadataMasked, error) {
+	_oxmidmetadatamasked := &OxmIdMetadataMasked{OxmId: parent}
+	return _oxmidmetadatamasked, nil
+}
+
+func NewOxmIdMetadataMasked() *OxmIdMetadataMasked {
+	obj := &OxmIdMetadataMasked{
+		OxmId: NewOxmId(2147484944),
+	}
+	return obj
+}
+func (self *OxmIdMetadataMasked) GetOXMName() string {
+	return "metadata_masked"
+}
+
+func (self *OxmIdMetadataMasked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdMplsLabel struct {
+	*OxmId
+}
+
+type IOxmIdMplsLabel interface {
+	IOxmId
+}
+
+func (self *OxmIdMplsLabel) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdMplsLabel(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMplsLabel, error) {
+	_oxmidmplslabel := &OxmIdMplsLabel{OxmId: parent}
+	return _oxmidmplslabel, nil
+}
+
+func NewOxmIdMplsLabel() *OxmIdMplsLabel {
+	obj := &OxmIdMplsLabel{
+		OxmId: NewOxmId(2147501060),
+	}
+	return obj
+}
+func (self *OxmIdMplsLabel) GetOXMName() string {
+	return "mpls_label"
+}
+
+func (self *OxmIdMplsLabel) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdMplsLabelMasked struct {
+	*OxmId
+}
+
+type IOxmIdMplsLabelMasked interface {
+	IOxmId
+}
+
+func (self *OxmIdMplsLabelMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdMplsLabelMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMplsLabelMasked, error) {
+	_oxmidmplslabelmasked := &OxmIdMplsLabelMasked{OxmId: parent}
+	return _oxmidmplslabelmasked, nil
+}
+
+func NewOxmIdMplsLabelMasked() *OxmIdMplsLabelMasked {
+	obj := &OxmIdMplsLabelMasked{
+		OxmId: NewOxmId(2147501320),
+	}
+	return obj
+}
+func (self *OxmIdMplsLabelMasked) GetOXMName() string {
+	return "mpls_label_masked"
+}
+
+func (self *OxmIdMplsLabelMasked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdMplsTc struct {
+	*OxmId
+}
+
+type IOxmIdMplsTc interface {
+	IOxmId
+}
+
+func (self *OxmIdMplsTc) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdMplsTc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMplsTc, error) {
+	_oxmidmplstc := &OxmIdMplsTc{OxmId: parent}
+	return _oxmidmplstc, nil
+}
+
+func NewOxmIdMplsTc() *OxmIdMplsTc {
+	obj := &OxmIdMplsTc{
+		OxmId: NewOxmId(2147501569),
+	}
+	return obj
+}
+func (self *OxmIdMplsTc) GetOXMName() string {
+	return "mpls_tc"
+}
+
+func (self *OxmIdMplsTc) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdMplsTcMasked struct {
+	*OxmId
+}
+
+type IOxmIdMplsTcMasked interface {
+	IOxmId
+}
+
+func (self *OxmIdMplsTcMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdMplsTcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMplsTcMasked, error) {
+	_oxmidmplstcmasked := &OxmIdMplsTcMasked{OxmId: parent}
+	return _oxmidmplstcmasked, nil
+}
+
+func NewOxmIdMplsTcMasked() *OxmIdMplsTcMasked {
+	obj := &OxmIdMplsTcMasked{
+		OxmId: NewOxmId(2147501826),
+	}
+	return obj
+}
+func (self *OxmIdMplsTcMasked) GetOXMName() string {
+	return "mpls_tc_masked"
+}
+
+func (self *OxmIdMplsTcMasked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdSctpDst struct {
+	*OxmId
+}
+
+type IOxmIdSctpDst interface {
+	IOxmId
+}
+
+func (self *OxmIdSctpDst) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdSctpDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdSctpDst, error) {
+	_oxmidsctpdst := &OxmIdSctpDst{OxmId: parent}
+	return _oxmidsctpdst, nil
+}
+
+func NewOxmIdSctpDst() *OxmIdSctpDst {
+	obj := &OxmIdSctpDst{
+		OxmId: NewOxmId(2147492866),
+	}
+	return obj
+}
+func (self *OxmIdSctpDst) GetOXMName() string {
+	return "sctp_dst"
+}
+
+func (self *OxmIdSctpDst) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdSctpDstMasked struct {
+	*OxmId
+}
+
+type IOxmIdSctpDstMasked interface {
+	IOxmId
+}
+
+func (self *OxmIdSctpDstMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdSctpDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdSctpDstMasked, error) {
+	_oxmidsctpdstmasked := &OxmIdSctpDstMasked{OxmId: parent}
+	return _oxmidsctpdstmasked, nil
+}
+
+func NewOxmIdSctpDstMasked() *OxmIdSctpDstMasked {
+	obj := &OxmIdSctpDstMasked{
+		OxmId: NewOxmId(2147493124),
+	}
+	return obj
+}
+func (self *OxmIdSctpDstMasked) GetOXMName() string {
+	return "sctp_dst_masked"
+}
+
+func (self *OxmIdSctpDstMasked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdSctpSrc struct {
+	*OxmId
+}
+
+type IOxmIdSctpSrc interface {
+	IOxmId
+}
+
+func (self *OxmIdSctpSrc) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdSctpSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdSctpSrc, error) {
+	_oxmidsctpsrc := &OxmIdSctpSrc{OxmId: parent}
+	return _oxmidsctpsrc, nil
+}
+
+func NewOxmIdSctpSrc() *OxmIdSctpSrc {
+	obj := &OxmIdSctpSrc{
+		OxmId: NewOxmId(2147492354),
+	}
+	return obj
+}
+func (self *OxmIdSctpSrc) GetOXMName() string {
+	return "sctp_src"
+}
+
+func (self *OxmIdSctpSrc) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdSctpSrcMasked struct {
+	*OxmId
+}
+
+type IOxmIdSctpSrcMasked interface {
+	IOxmId
+}
+
+func (self *OxmIdSctpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdSctpSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdSctpSrcMasked, error) {
+	_oxmidsctpsrcmasked := &OxmIdSctpSrcMasked{OxmId: parent}
+	return _oxmidsctpsrcmasked, nil
+}
+
+func NewOxmIdSctpSrcMasked() *OxmIdSctpSrcMasked {
+	obj := &OxmIdSctpSrcMasked{
+		OxmId: NewOxmId(2147492612),
+	}
+	return obj
+}
+func (self *OxmIdSctpSrcMasked) GetOXMName() string {
+	return "sctp_src_masked"
+}
+
+func (self *OxmIdSctpSrcMasked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdVlanPcp struct {
+	*OxmId
+}
+
+type IOxmIdVlanPcp interface {
+	IOxmId
+}
+
+func (self *OxmIdVlanPcp) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdVlanPcp(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdVlanPcp, error) {
+	_oxmidvlanpcp := &OxmIdVlanPcp{OxmId: parent}
+	return _oxmidvlanpcp, nil
+}
+
+func NewOxmIdVlanPcp() *OxmIdVlanPcp {
+	obj := &OxmIdVlanPcp{
+		OxmId: NewOxmId(2147487233),
+	}
+	return obj
+}
+func (self *OxmIdVlanPcp) GetOXMName() string {
+	return "vlan_pcp"
+}
+
+func (self *OxmIdVlanPcp) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdVlanPcpMasked struct {
+	*OxmId
+}
+
+type IOxmIdVlanPcpMasked interface {
+	IOxmId
+}
+
+func (self *OxmIdVlanPcpMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdVlanPcpMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdVlanPcpMasked, error) {
+	_oxmidvlanpcpmasked := &OxmIdVlanPcpMasked{OxmId: parent}
+	return _oxmidvlanpcpmasked, nil
+}
+
+func NewOxmIdVlanPcpMasked() *OxmIdVlanPcpMasked {
+	obj := &OxmIdVlanPcpMasked{
+		OxmId: NewOxmId(2147487490),
+	}
+	return obj
+}
+func (self *OxmIdVlanPcpMasked) GetOXMName() string {
+	return "vlan_pcp_masked"
+}
+
+func (self *OxmIdVlanPcpMasked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdVlanVid struct {
+	*OxmId
+}
+
+type IOxmIdVlanVid interface {
+	IOxmId
+}
+
+func (self *OxmIdVlanVid) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdVlanVid(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdVlanVid, error) {
+	_oxmidvlanvid := &OxmIdVlanVid{OxmId: parent}
+	return _oxmidvlanvid, nil
+}
+
+func NewOxmIdVlanVid() *OxmIdVlanVid {
+	obj := &OxmIdVlanVid{
+		OxmId: NewOxmId(2147486722),
+	}
+	return obj
+}
+func (self *OxmIdVlanVid) GetOXMName() string {
+	return "vlan_vid"
+}
+
+func (self *OxmIdVlanVid) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type OxmIdVlanVidMasked struct {
+	*OxmId
+}
+
+type IOxmIdVlanVidMasked interface {
+	IOxmId
+}
+
+func (self *OxmIdVlanVidMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.OxmId.Serialize(encoder); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func DecodeOxmIdVlanVidMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdVlanVidMasked, error) {
+	_oxmidvlanvidmasked := &OxmIdVlanVidMasked{OxmId: parent}
+	return _oxmidvlanvidmasked, nil
+}
+
+func NewOxmIdVlanVidMasked() *OxmIdVlanVidMasked {
+	obj := &OxmIdVlanVidMasked{
+		OxmId: NewOxmId(2147486980),
+	}
+	return obj
+}
+func (self *OxmIdVlanVidMasked) GetOXMName() string {
+	return "vlan_vid_masked"
+}
+
+func (self *OxmIdVlanVidMasked) MarshalJSON() ([]byte, error) {
+	if self.TypeLen == 0 {
+		return []byte("\"\""), nil
+	} else {
+		return []byte("\"" + self.GetOXMName() + "\""), nil
+	}
+}
+
+type PacketQueue struct {
+	QueueId    uint32
+	Len        uint16
+	Properties []IQueueProp
+}
+
+type IPacketQueue interface {
+	goloxi.Serializable
+	GetQueueId() uint32
+	GetLen() uint16
+	GetProperties() []IQueueProp
+}
+
+func (self *PacketQueue) GetQueueId() uint32 {
+	return self.QueueId
+}
+
+func (self *PacketQueue) SetQueueId(v uint32) {
+	self.QueueId = v
+}
+
+func (self *PacketQueue) GetLen() uint16 {
+	return self.Len
+}
+
+func (self *PacketQueue) SetLen(v uint16) {
+	self.Len = v
+}
+
+func (self *PacketQueue) GetProperties() []IQueueProp {
+	return self.Properties
+}
+
+func (self *PacketQueue) SetProperties(v []IQueueProp) {
+	self.Properties = v
+}
+
+func (self *PacketQueue) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+
+	encoder.PutUint32(uint32(self.QueueId))
+	encoder.PutUint16(uint16(self.Len))
+	encoder.Write(bytes.Repeat([]byte{0}, 2))
+	for _, obj := range self.Properties {
+		if err := obj.Serialize(encoder); err != nil {
+			return err
+		}
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+4:startIndex+6], uint16(length))
+
+	return nil
+}
+
+func DecodePacketQueue(decoder *goloxi.Decoder) (*PacketQueue, error) {
+	_packetqueue := &PacketQueue{}
+	if decoder.Length() < 8 {
+		return nil, fmt.Errorf("PacketQueue packet too short: %d < 8", decoder.Length())
+	}
+	_packetqueue.QueueId = uint32(decoder.ReadUint32())
+	_packetqueue.Len = uint16(decoder.ReadUint16())
+	oldDecoder := decoder
+	defer func() { decoder = oldDecoder }()
+	decoder = decoder.SliceDecoder(int(_packetqueue.Len), 2+4)
+	decoder.Skip(2)
+
+	for decoder.Length() >= 8 {
+		item, err := DecodeQueueProp(decoder)
+		if err != nil {
+			return nil, err
+		}
+		if item != nil {
+			_packetqueue.Properties = append(_packetqueue.Properties, item)
+		}
+	}
+	return _packetqueue, nil
+}
+
+func NewPacketQueue() *PacketQueue {
+	obj := &PacketQueue{}
+	return obj
+}
+
+type PortDesc struct {
+	PortNo     Port
+	HwAddr     net.HardwareAddr
+	Name       string
+	Config     PortConfig
+	State      PortState
+	Curr       PortFeatures
+	Advertised PortFeatures
+	Supported  PortFeatures
+	Peer       PortFeatures
+}
+
+type IPortDesc interface {
+	goloxi.Serializable
+	GetPortNo() Port
+	GetHwAddr() net.HardwareAddr
+	GetName() string
+	GetConfig() PortConfig
+	GetState() PortState
+	GetCurr() PortFeatures
+	GetAdvertised() PortFeatures
+	GetSupported() PortFeatures
+	GetPeer() PortFeatures
+}
+
+func (self *PortDesc) GetPortNo() Port {
+	return self.PortNo
+}
+
+func (self *PortDesc) SetPortNo(v Port) {
+	self.PortNo = v
+}
+
+func (self *PortDesc) GetHwAddr() net.HardwareAddr {
+	return self.HwAddr
+}
+
+func (self *PortDesc) SetHwAddr(v net.HardwareAddr) {
+	self.HwAddr = v
+}
+
+func (self *PortDesc) GetName() string {
+	return self.Name
+}
+
+func (self *PortDesc) SetName(v string) {
+	self.Name = v
+}
+
+func (self *PortDesc) GetConfig() PortConfig {
+	return self.Config
+}
+
+func (self *PortDesc) SetConfig(v PortConfig) {
+	self.Config = v
+}
+
+func (self *PortDesc) GetState() PortState {
+	return self.State
+}
+
+func (self *PortDesc) SetState(v PortState) {
+	self.State = v
+}
+
+func (self *PortDesc) GetCurr() PortFeatures {
+	return self.Curr
+}
+
+func (self *PortDesc) SetCurr(v PortFeatures) {
+	self.Curr = v
+}
+
+func (self *PortDesc) GetAdvertised() PortFeatures {
+	return self.Advertised
+}
+
+func (self *PortDesc) SetAdvertised(v PortFeatures) {
+	self.Advertised = v
+}
+
+func (self *PortDesc) GetSupported() PortFeatures {
+	return self.Supported
+}
+
+func (self *PortDesc) SetSupported(v PortFeatures) {
+	self.Supported = v
+}
+
+func (self *PortDesc) GetPeer() PortFeatures {
+	return self.Peer
+}
+
+func (self *PortDesc) SetPeer(v PortFeatures) {
+	self.Peer = v
+}
+
+func (self *PortDesc) Serialize(encoder *goloxi.Encoder) error {
+
+	self.PortNo.Serialize(encoder)
+	encoder.Write(self.HwAddr)
+	encoder.Write([]byte(self.Name))
+	encoder.PutUint32(uint32(self.Config))
+	encoder.PutUint32(uint32(self.State))
+	encoder.PutUint32(uint32(self.Curr))
+	encoder.PutUint32(uint32(self.Advertised))
+	encoder.PutUint32(uint32(self.Supported))
+	encoder.PutUint32(uint32(self.Peer))
+
+	return nil
+}
+func (self *PortDesc) Decode(decoder *goloxi.Decoder) error {
+	if decoder.Length() < 48 {
+		return fmt.Errorf("PortDesc packet too short: %d < 48", decoder.Length())
+	}
+
+	self.PortNo.Decode(decoder)
+	self.HwAddr = net.HardwareAddr(decoder.Read(6))
+	self.Name = string(bytes.Trim(decoder.Read(16), "\x00"))
+	self.Config = PortConfig(decoder.ReadUint32())
+	self.State = PortState(decoder.ReadUint32())
+	self.Curr = PortFeatures(decoder.ReadUint32())
+	self.Advertised = PortFeatures(decoder.ReadUint32())
+	self.Supported = PortFeatures(decoder.ReadUint32())
+	self.Peer = PortFeatures(decoder.ReadUint32())
+
+	return nil
+}
+
+func NewPortDesc() *PortDesc {
+	obj := &PortDesc{}
+	return obj
+}
+
+type PortStatsEntry struct {
+	PortNo     Port
+	RxPackets  uint64
+	TxPackets  uint64
+	RxBytes    uint64
+	TxBytes    uint64
+	RxDropped  uint64
+	TxDropped  uint64
+	RxErrors   uint64
+	TxErrors   uint64
+	RxFrameErr uint64
+	RxOverErr  uint64
+	RxCrcErr   uint64
+	Collisions uint64
+}
+
+type IPortStatsEntry interface {
+	goloxi.Serializable
+	GetPortNo() Port
+	GetRxPackets() uint64
+	GetTxPackets() uint64
+	GetRxBytes() uint64
+	GetTxBytes() uint64
+	GetRxDropped() uint64
+	GetTxDropped() uint64
+	GetRxErrors() uint64
+	GetTxErrors() uint64
+	GetRxFrameErr() uint64
+	GetRxOverErr() uint64
+	GetRxCrcErr() uint64
+	GetCollisions() uint64
+}
+
+func (self *PortStatsEntry) GetPortNo() Port {
+	return self.PortNo
+}
+
+func (self *PortStatsEntry) SetPortNo(v Port) {
+	self.PortNo = v
+}
+
+func (self *PortStatsEntry) GetRxPackets() uint64 {
+	return self.RxPackets
+}
+
+func (self *PortStatsEntry) SetRxPackets(v uint64) {
+	self.RxPackets = v
+}
+
+func (self *PortStatsEntry) GetTxPackets() uint64 {
+	return self.TxPackets
+}
+
+func (self *PortStatsEntry) SetTxPackets(v uint64) {
+	self.TxPackets = v
+}
+
+func (self *PortStatsEntry) GetRxBytes() uint64 {
+	return self.RxBytes
+}
+
+func (self *PortStatsEntry) SetRxBytes(v uint64) {
+	self.RxBytes = v
+}
+
+func (self *PortStatsEntry) GetTxBytes() uint64 {
+	return self.TxBytes
+}
+
+func (self *PortStatsEntry) SetTxBytes(v uint64) {
+	self.TxBytes = v
+}
+
+func (self *PortStatsEntry) GetRxDropped() uint64 {
+	return self.RxDropped
+}
+
+func (self *PortStatsEntry) SetRxDropped(v uint64) {
+	self.RxDropped = v
+}
+
+func (self *PortStatsEntry) GetTxDropped() uint64 {
+	return self.TxDropped
+}
+
+func (self *PortStatsEntry) SetTxDropped(v uint64) {
+	self.TxDropped = v
+}
+
+func (self *PortStatsEntry) GetRxErrors() uint64 {
+	return self.RxErrors
+}
+
+func (self *PortStatsEntry) SetRxErrors(v uint64) {
+	self.RxErrors = v
+}
+
+func (self *PortStatsEntry) GetTxErrors() uint64 {
+	return self.TxErrors
+}
+
+func (self *PortStatsEntry) SetTxErrors(v uint64) {
+	self.TxErrors = v
+}
+
+func (self *PortStatsEntry) GetRxFrameErr() uint64 {
+	return self.RxFrameErr
+}
+
+func (self *PortStatsEntry) SetRxFrameErr(v uint64) {
+	self.RxFrameErr = v
+}
+
+func (self *PortStatsEntry) GetRxOverErr() uint64 {
+	return self.RxOverErr
+}
+
+func (self *PortStatsEntry) SetRxOverErr(v uint64) {
+	self.RxOverErr = v
+}
+
+func (self *PortStatsEntry) GetRxCrcErr() uint64 {
+	return self.RxCrcErr
+}
+
+func (self *PortStatsEntry) SetRxCrcErr(v uint64) {
+	self.RxCrcErr = v
+}
+
+func (self *PortStatsEntry) GetCollisions() uint64 {
+	return self.Collisions
+}
+
+func (self *PortStatsEntry) SetCollisions(v uint64) {
+	self.Collisions = v
+}
+
+func (self *PortStatsEntry) Serialize(encoder *goloxi.Encoder) error {
+
+	self.PortNo.Serialize(encoder)
+	encoder.Write(bytes.Repeat([]byte{0}, 6))
+	encoder.PutUint64(uint64(self.RxPackets))
+	encoder.PutUint64(uint64(self.TxPackets))
+	encoder.PutUint64(uint64(self.RxBytes))
+	encoder.PutUint64(uint64(self.TxBytes))
+	encoder.PutUint64(uint64(self.RxDropped))
+	encoder.PutUint64(uint64(self.TxDropped))
+	encoder.PutUint64(uint64(self.RxErrors))
+	encoder.PutUint64(uint64(self.TxErrors))
+	encoder.PutUint64(uint64(self.RxFrameErr))
+	encoder.PutUint64(uint64(self.RxOverErr))
+	encoder.PutUint64(uint64(self.RxCrcErr))
+	encoder.PutUint64(uint64(self.Collisions))
+
+	return nil
+}
+
+func DecodePortStatsEntry(decoder *goloxi.Decoder) (*PortStatsEntry, error) {
+	_portstatsentry := &PortStatsEntry{}
+	if decoder.Length() < 104 {
+		return nil, fmt.Errorf("PortStatsEntry packet too short: %d < 104", decoder.Length())
+	}
+	_portstatsentry.PortNo.Decode(decoder)
+	decoder.Skip(6)
+	_portstatsentry.RxPackets = uint64(decoder.ReadUint64())
+	_portstatsentry.TxPackets = uint64(decoder.ReadUint64())
+	_portstatsentry.RxBytes = uint64(decoder.ReadUint64())
+	_portstatsentry.TxBytes = uint64(decoder.ReadUint64())
+	_portstatsentry.RxDropped = uint64(decoder.ReadUint64())
+	_portstatsentry.TxDropped = uint64(decoder.ReadUint64())
+	_portstatsentry.RxErrors = uint64(decoder.ReadUint64())
+	_portstatsentry.TxErrors = uint64(decoder.ReadUint64())
+	_portstatsentry.RxFrameErr = uint64(decoder.ReadUint64())
+	_portstatsentry.RxOverErr = uint64(decoder.ReadUint64())
+	_portstatsentry.RxCrcErr = uint64(decoder.ReadUint64())
+	_portstatsentry.Collisions = uint64(decoder.ReadUint64())
+	return _portstatsentry, nil
+}
+
+func NewPortStatsEntry() *PortStatsEntry {
+	obj := &PortStatsEntry{}
+	return obj
+}
+
+type QueueProp struct {
+	Type uint16
+	Len  uint16
+}
+
+type IQueueProp interface {
+	goloxi.Serializable
+	GetType() uint16
+	GetLen() uint16
+}
+
+func (self *QueueProp) GetType() uint16 {
+	return self.Type
+}
+
+func (self *QueueProp) SetType(v uint16) {
+	self.Type = v
+}
+
+func (self *QueueProp) GetLen() uint16 {
+	return self.Len
+}
+
+func (self *QueueProp) SetLen(v uint16) {
+	self.Len = v
+}
+
+func (self *QueueProp) Serialize(encoder *goloxi.Encoder) error {
+
+	encoder.PutUint16(uint16(self.Type))
+	encoder.PutUint16(uint16(self.Len))
+
+	return nil
+}
+
+func DecodeQueueProp(decoder *goloxi.Decoder) (IQueueProp, error) {
+	_queueprop := &QueueProp{}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("QueueProp packet too short: %d < 4", decoder.Length())
+	}
+	_queueprop.Type = uint16(decoder.ReadUint16())
+	_queueprop.Len = uint16(decoder.ReadUint16())
+	oldDecoder := decoder
+	defer func() { decoder = oldDecoder }()
+	decoder = decoder.SliceDecoder(int(_queueprop.Len), 2+2)
+
+	switch _queueprop.Type {
+	case 1:
+		return DecodeQueuePropMinRate(_queueprop, decoder)
+	default:
+		return nil, fmt.Errorf("Invalid type '%d' for 'QueueProp'", _queueprop.Type)
+	}
+}
+
+func NewQueueProp(_type uint16) *QueueProp {
+	obj := &QueueProp{}
+	obj.Type = _type
+	return obj
+}
+
+type QueuePropMinRate struct {
+	*QueueProp
+	Rate uint16
+}
+
+type IQueuePropMinRate interface {
+	IQueueProp
+	GetRate() uint16
+}
+
+func (self *QueuePropMinRate) GetRate() uint16 {
+	return self.Rate
+}
+
+func (self *QueuePropMinRate) SetRate(v uint16) {
+	self.Rate = v
+}
+
+func (self *QueuePropMinRate) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.QueueProp.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(bytes.Repeat([]byte{0}, 4))
+	encoder.PutUint16(uint16(self.Rate))
+	encoder.Write(bytes.Repeat([]byte{0}, 6))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeQueuePropMinRate(parent *QueueProp, decoder *goloxi.Decoder) (*QueuePropMinRate, error) {
+	_queuepropminrate := &QueuePropMinRate{QueueProp: parent}
+	if decoder.Length() < 12 {
+		return nil, fmt.Errorf("QueuePropMinRate packet too short: %d < 12", decoder.Length())
+	}
+	decoder.Skip(4)
+	_queuepropminrate.Rate = uint16(decoder.ReadUint16())
+	decoder.Skip(6)
+	return _queuepropminrate, nil
+}
+
+func NewQueuePropMinRate() *QueuePropMinRate {
+	obj := &QueuePropMinRate{
+		QueueProp: NewQueueProp(1),
+	}
+	return obj
+}
+
+type QueueStatsEntry struct {
+	PortNo    Port
+	QueueId   uint32
+	TxBytes   uint64
+	TxPackets uint64
+	TxErrors  uint64
+}
+
+type IQueueStatsEntry interface {
+	goloxi.Serializable
+	GetPortNo() Port
+	GetQueueId() uint32
+	GetTxBytes() uint64
+	GetTxPackets() uint64
+	GetTxErrors() uint64
+}
+
+func (self *QueueStatsEntry) GetPortNo() Port {
+	return self.PortNo
+}
+
+func (self *QueueStatsEntry) SetPortNo(v Port) {
+	self.PortNo = v
+}
+
+func (self *QueueStatsEntry) GetQueueId() uint32 {
+	return self.QueueId
+}
+
+func (self *QueueStatsEntry) SetQueueId(v uint32) {
+	self.QueueId = v
+}
+
+func (self *QueueStatsEntry) GetTxBytes() uint64 {
+	return self.TxBytes
+}
+
+func (self *QueueStatsEntry) SetTxBytes(v uint64) {
+	self.TxBytes = v
+}
+
+func (self *QueueStatsEntry) GetTxPackets() uint64 {
+	return self.TxPackets
+}
+
+func (self *QueueStatsEntry) SetTxPackets(v uint64) {
+	self.TxPackets = v
+}
+
+func (self *QueueStatsEntry) GetTxErrors() uint64 {
+	return self.TxErrors
+}
+
+func (self *QueueStatsEntry) SetTxErrors(v uint64) {
+	self.TxErrors = v
+}
+
+func (self *QueueStatsEntry) Serialize(encoder *goloxi.Encoder) error {
+
+	self.PortNo.Serialize(encoder)
+	encoder.Write(bytes.Repeat([]byte{0}, 2))
+	encoder.PutUint32(uint32(self.QueueId))
+	encoder.PutUint64(uint64(self.TxBytes))
+	encoder.PutUint64(uint64(self.TxPackets))
+	encoder.PutUint64(uint64(self.TxErrors))
+
+	return nil
+}
+
+func DecodeQueueStatsEntry(decoder *goloxi.Decoder) (*QueueStatsEntry, error) {
+	_queuestatsentry := &QueueStatsEntry{}
+	if decoder.Length() < 32 {
+		return nil, fmt.Errorf("QueueStatsEntry packet too short: %d < 32", decoder.Length())
+	}
+	_queuestatsentry.PortNo.Decode(decoder)
+	decoder.Skip(2)
+	_queuestatsentry.QueueId = uint32(decoder.ReadUint32())
+	_queuestatsentry.TxBytes = uint64(decoder.ReadUint64())
+	_queuestatsentry.TxPackets = uint64(decoder.ReadUint64())
+	_queuestatsentry.TxErrors = uint64(decoder.ReadUint64())
+	return _queuestatsentry, nil
+}
+
+func NewQueueStatsEntry() *QueueStatsEntry {
+	obj := &QueueStatsEntry{}
+	return obj
+}
+
+type TableStatsEntry struct {
+	TableId      uint8
+	Name         string
+	Wildcards    WcBmap
+	MaxEntries   uint32
+	ActiveCount  uint32
+	LookupCount  uint64
+	MatchedCount uint64
+}
+
+type ITableStatsEntry interface {
+	goloxi.Serializable
+	GetTableId() uint8
+	GetName() string
+	GetWildcards() WcBmap
+	GetMaxEntries() uint32
+	GetActiveCount() uint32
+	GetLookupCount() uint64
+	GetMatchedCount() uint64
+}
+
+func (self *TableStatsEntry) GetTableId() uint8 {
+	return self.TableId
+}
+
+func (self *TableStatsEntry) SetTableId(v uint8) {
+	self.TableId = v
+}
+
+func (self *TableStatsEntry) GetName() string {
+	return self.Name
+}
+
+func (self *TableStatsEntry) SetName(v string) {
+	self.Name = v
+}
+
+func (self *TableStatsEntry) GetWildcards() WcBmap {
+	return self.Wildcards
+}
+
+func (self *TableStatsEntry) SetWildcards(v WcBmap) {
+	self.Wildcards = v
+}
+
+func (self *TableStatsEntry) GetMaxEntries() uint32 {
+	return self.MaxEntries
+}
+
+func (self *TableStatsEntry) SetMaxEntries(v uint32) {
+	self.MaxEntries = v
+}
+
+func (self *TableStatsEntry) GetActiveCount() uint32 {
+	return self.ActiveCount
+}
+
+func (self *TableStatsEntry) SetActiveCount(v uint32) {
+	self.ActiveCount = v
+}
+
+func (self *TableStatsEntry) GetLookupCount() uint64 {
+	return self.LookupCount
+}
+
+func (self *TableStatsEntry) SetLookupCount(v uint64) {
+	self.LookupCount = v
+}
+
+func (self *TableStatsEntry) GetMatchedCount() uint64 {
+	return self.MatchedCount
+}
+
+func (self *TableStatsEntry) SetMatchedCount(v uint64) {
+	self.MatchedCount = v
+}
+
+func (self *TableStatsEntry) Serialize(encoder *goloxi.Encoder) error {
+
+	encoder.PutUint8(uint8(self.TableId))
+	encoder.Write(bytes.Repeat([]byte{0}, 3))
+	encoder.Write([]byte(self.Name))
+	self.Wildcards.Serialize(encoder)
+	encoder.PutUint32(uint32(self.MaxEntries))
+	encoder.PutUint32(uint32(self.ActiveCount))
+	encoder.PutUint64(uint64(self.LookupCount))
+	encoder.PutUint64(uint64(self.MatchedCount))
+
+	return nil
+}
+
+func DecodeTableStatsEntry(decoder *goloxi.Decoder) (*TableStatsEntry, error) {
+	_tablestatsentry := &TableStatsEntry{}
+	if decoder.Length() < 64 {
+		return nil, fmt.Errorf("TableStatsEntry packet too short: %d < 64", decoder.Length())
+	}
+	_tablestatsentry.TableId = uint8(decoder.ReadByte())
+	decoder.Skip(3)
+	_tablestatsentry.Name = string(bytes.Trim(decoder.Read(32), "\x00"))
+	_tablestatsentry.Wildcards.Decode(decoder)
+	_tablestatsentry.MaxEntries = uint32(decoder.ReadUint32())
+	_tablestatsentry.ActiveCount = uint32(decoder.ReadUint32())
+	_tablestatsentry.LookupCount = uint64(decoder.ReadUint64())
+	_tablestatsentry.MatchedCount = uint64(decoder.ReadUint64())
+	return _tablestatsentry, nil
+}
+
+func NewTableStatsEntry() *TableStatsEntry {
+	obj := &TableStatsEntry{}
+	return obj
+}
diff --git a/of10/const.go b/of10/const.go
new file mode 100644
index 0000000..3d384e4
--- /dev/null
+++ b/of10/const.go
@@ -0,0 +1,1495 @@
+/*
+ * Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
+ * Copyright (c) 2011, 2012 Open Networking Foundation
+ * Copyright 2013, Big Switch Networks, Inc. This library was generated by the LoxiGen Compiler.
+ * Copyright 2018, Red Hat, Inc.
+ */
+// Automatically generated by LOXI from template const.go
+// Do not modify
+
+package of10
+
+import (
+	"fmt"
+	"strings"
+)
+
+const (
+	// Identifiers from group macro_definitions
+	MaxTableNameLen    = 32         // OFP_MAX_TABLE_NAME_LEN
+	MaxPortNameLen     = 16         // OFP_MAX_PORT_NAME_LEN
+	TCPPort            = 6653       // OFP_TCP_PORT
+	SSLPort            = 6653       // OFP_SSL_PORT
+	EthAlen            = 6          // OFP_ETH_ALEN
+	DefaultMissSendLen = 128        // OFP_DEFAULT_MISS_SEND_LEN
+	VLANNone           = 65535      // OFP_VLAN_NONE
+	OFPFWICMPType      = 64         // OFPFW_ICMP_TYPE
+	OFPFWICMPCode      = 128        // OFPFW_ICMP_CODE
+	DlTypeEth2Cutoff   = 1536       // OFP_DL_TYPE_ETH2_CUTOFF
+	DlTypeNotEthType   = 1535       // OFP_DL_TYPE_NOT_ETH_TYPE
+	FlowPermanent      = 0          // OFP_FLOW_PERMANENT
+	DefaultPriority    = 32768      // OFP_DEFAULT_PRIORITY
+	DescStrLen         = 256        // DESC_STR_LEN
+	SerialNumLen       = 32         // SERIAL_NUM_LEN
+	OFPQAll            = 4294967295 // OFPQ_ALL
+	OFPQMinRateUncfg   = 65535      // OFPQ_MIN_RATE_UNCFG
+)
+
+const (
+	// Identifiers from group nx_action_controller2_prop_type
+	Nxac2PtMaxLen       = 0 // NXAC2PT_MAX_LEN
+	Nxac2PtControllerID = 1 // NXAC2PT_CONTROLLER_ID
+	Nxac2PtReason       = 2 // NXAC2PT_REASON
+	Nxac2PtUserdata     = 3 // NXAC2PT_USERDATA
+	Nxac2PtPause        = 4 // NXAC2PT_PAUSE
+	Nxac2PtMeterID      = 5 // NXAC2PT_METER_ID
+)
+
+type NxActionController2PropType uint16
+
+func (self NxActionController2PropType) MarshalJSON() ([]byte, error) {
+	return []byte(fmt.Sprintf("%d", self)), nil
+}
+
+const (
+	// Identifiers from group nx_bd_algorithms
+	NxBdAlgActiveBackup = 0 // NX_BD_ALG_ACTIVE_BACKUP
+	NxBdAlgHrw          = 1 // NX_BD_ALG_HRW
+)
+
+type NxBdAlgorithms uint16
+
+func (self NxBdAlgorithms) MarshalJSON() ([]byte, error) {
+	return []byte(fmt.Sprintf("\"%s\"", self)), nil
+}
+
+func (self NxBdAlgorithms) String() string {
+	switch self {
+	case NxBdAlgActiveBackup:
+		return "active_backup"
+	case NxBdAlgHrw:
+		return "hrw"
+	default:
+		return fmt.Sprintf("%d", self)
+	}
+}
+
+const (
+	// Identifiers from group nx_conntrack_flags
+	NxCtFCommit = 1 // NX_CT_F_COMMIT
+	NxCtFForce  = 2 // NX_CT_F_FORCE
+)
+
+type NxConntrackFlags uint16
+
+func (self NxConntrackFlags) MarshalJSON() ([]byte, error) {
+	var flags []string
+	if self&NxCtFCommit == NxCtFCommit {
+		flags = append(flags, "\"Commit\": true")
+	}
+	if self&NxCtFForce == NxCtFForce {
+		flags = append(flags, "\"Force\": true")
+	}
+	return []byte("{" + strings.Join(flags, ", ") + "}"), nil
+}
+
+const (
+	// Identifiers from group nx_flow_monitor_flags
+	NxfmfInitial = 1  // NXFMF_INITIAL
+	NxfmfAdd     = 2  // NXFMF_ADD
+	NxfmfDelete  = 4  // NXFMF_DELETE
+	NxfmfModify  = 8  // NXFMF_MODIFY
+	NxfmfActions = 16 // NXFMF_ACTIONS
+	NxfmfOwn     = 32 // NXFMF_OWN
+)
+
+type NxFlowMonitorFlags uint16
+
+func (self NxFlowMonitorFlags) MarshalJSON() ([]byte, error) {
+	var flags []string
+	if self&NxfmfInitial == NxfmfInitial {
+		flags = append(flags, "\"Initial\": true")
+	}
+	if self&NxfmfAdd == NxfmfAdd {
+		flags = append(flags, "\"Add\": true")
+	}
+	if self&NxfmfDelete == NxfmfDelete {
+		flags = append(flags, "\"Delete\": true")
+	}
+	if self&NxfmfModify == NxfmfModify {
+		flags = append(flags, "\"Modify\": true")
+	}
+	if self&NxfmfActions == NxfmfActions {
+		flags = append(flags, "\"Actions\": true")
+	}
+	if self&NxfmfOwn == NxfmfOwn {
+		flags = append(flags, "\"Own\": true")
+	}
+	return []byte("{" + strings.Join(flags, ", ") + "}"), nil
+}
+
+const (
+	// Identifiers from group nx_hash_fields
+	NxHashFieldsEthSrc           = 0 // NX_HASH_FIELDS_ETH_SRC
+	NxHashFieldsSymmetricL4      = 1 // NX_HASH_FIELDS_SYMMETRIC_L4
+	NxHashFieldsSymmetricL3L4    = 2 // NX_HASH_FIELDS_SYMMETRIC_L3L4
+	NxHashFieldsSymmetricL3L4Udp = 3 // NX_HASH_FIELDS_SYMMETRIC_L3L4_UDP
+	NxHashFieldsNwSrc            = 4 // NX_HASH_FIELDS_NW_SRC
+	NxHashFieldsNwDst            = 5 // NX_HASH_FIELDS_NW_DST
+	NxHashFieldsSymmetricL3      = 6 // NX_HASH_FIELDS_SYMMETRIC_L3
+)
+
+type NxHashFields uint16
+
+func (self NxHashFields) MarshalJSON() ([]byte, error) {
+	return []byte(fmt.Sprintf("\"%s\"", self)), nil
+}
+
+func (self NxHashFields) String() string {
+	switch self {
+	case NxHashFieldsEthSrc:
+		return "eth_src"
+	case NxHashFieldsSymmetricL4:
+		return "symmetric_l4"
+	case NxHashFieldsSymmetricL3L4:
+		return "symmetric_l3l4"
+	case NxHashFieldsSymmetricL3L4Udp:
+		return "symmetric_l3l4_udp"
+	case NxHashFieldsNwSrc:
+		return "nw_src"
+	case NxHashFieldsNwDst:
+		return "nw_dst"
+	case NxHashFieldsSymmetricL3:
+		return "symmetric_l3"
+	default:
+		return fmt.Sprintf("%d", self)
+	}
+}
+
+const (
+	// Identifiers from group nx_mp_algorithm
+	NxMpAlgModuloN       = 0 // NX_MP_ALG_MODULO_N
+	NxMpAlgHashThreshold = 1 // NX_MP_ALG_HASH_THRESHOLD
+	NxMpAlgHrw           = 2 // NX_MP_ALG_HRW
+	NxMpAlgIterHash      = 3 // NX_MP_ALG_ITER_HASH
+)
+
+type NxMpAlgorithm uint16
+
+func (self NxMpAlgorithm) MarshalJSON() ([]byte, error) {
+	return []byte(fmt.Sprintf("\"%s\"", self)), nil
+}
+
+func (self NxMpAlgorithm) String() string {
+	switch self {
+	case NxMpAlgModuloN:
+		return "modulo_n"
+	case NxMpAlgHashThreshold:
+		return "hash_threshold"
+	case NxMpAlgHrw:
+		return "hrw"
+	case NxMpAlgIterHash:
+		return "iter_hash"
+	default:
+		return fmt.Sprintf("%d", self)
+	}
+}
+
+const (
+	// Identifiers from group of_action_nx_bundle_slave_type
+	NxmOfInPort                  = 2     // NXM_OF_IN_PORT
+	NxmOfJustThereToDefinePrefix = 10000 // NXM_OF_JUST_THERE_TO_DEFINE_PREFIX
+)
+
+type ActionNxBundleSlaveType uint32
+
+func (self ActionNxBundleSlaveType) MarshalJSON() ([]byte, error) {
+	return []byte(fmt.Sprintf("\"%s\"", self)), nil
+}
+
+func (self ActionNxBundleSlaveType) String() string {
+	switch self {
+	case NxmOfInPort:
+		return "in_port"
+	case NxmOfJustThereToDefinePrefix:
+		return "just_there_to_define_prefix"
+	default:
+		return fmt.Sprintf("%d", self)
+	}
+}
+
+const (
+	// Identifiers from group of_bsn_pdu_slot_num
+	BsnPduSlotNumAny = 255 // BSN_PDU_SLOT_NUM_ANY
+)
+
+type BsnPduSlotNum uint8
+
+func (self BsnPduSlotNum) MarshalJSON() ([]byte, error) {
+	return []byte(fmt.Sprintf("%d", self)), nil
+}
+
+const (
+	// Identifiers from group of_nx_nat_range
+	NxNatRangeIpv4Min  = 1  // NX_NAT_RANGE_IPV4_MIN
+	NxNatRangeIpv4Max  = 2  // NX_NAT_RANGE_IPV4_MAX
+	NxNatRangeIpv6Min  = 4  // NX_NAT_RANGE_IPV6_MIN
+	NxNatRangeIpv6Max  = 8  // NX_NAT_RANGE_IPV6_MAX
+	NxNatRangeProtoMin = 16 // NX_NAT_RANGE_PROTO_MIN
+	NxNatRangeProtoMax = 32 // NX_NAT_RANGE_PROTO_MAX
+)
+
+type NxNatRange uint16
+
+func (self NxNatRange) MarshalJSON() ([]byte, error) {
+	var flags []string
+	if self&NxNatRangeIpv4Min == NxNatRangeIpv4Min {
+		flags = append(flags, "\"Ipv4Min\": true")
+	}
+	if self&NxNatRangeIpv4Max == NxNatRangeIpv4Max {
+		flags = append(flags, "\"Ipv4Max\": true")
+	}
+	if self&NxNatRangeIpv6Min == NxNatRangeIpv6Min {
+		flags = append(flags, "\"Ipv6Min\": true")
+	}
+	if self&NxNatRangeIpv6Max == NxNatRangeIpv6Max {
+		flags = append(flags, "\"Ipv6Max\": true")
+	}
+	if self&NxNatRangeProtoMin == NxNatRangeProtoMin {
+		flags = append(flags, "\"ProtoMin\": true")
+	}
+	if self&NxNatRangeProtoMax == NxNatRangeProtoMax {
+		flags = append(flags, "\"ProtoMax\": true")
+	}
+	return []byte("{" + strings.Join(flags, ", ") + "}"), nil
+}
+
+const (
+	// Identifiers from group ofp_action_type
+	OFPATOutput       = 0     // OFPAT_OUTPUT
+	OFPATSetVLANVid   = 1     // OFPAT_SET_VLAN_VID
+	OFPATSetVLANPCP   = 2     // OFPAT_SET_VLAN_PCP
+	OFPATStripVLAN    = 3     // OFPAT_STRIP_VLAN
+	OFPATSetDlSrc     = 4     // OFPAT_SET_DL_SRC
+	OFPATSetDlDst     = 5     // OFPAT_SET_DL_DST
+	OFPATSetNwSrc     = 6     // OFPAT_SET_NW_SRC
+	OFPATSetNwDst     = 7     // OFPAT_SET_NW_DST
+	OFPATSetNwTos     = 8     // OFPAT_SET_NW_TOS
+	OFPATSetTpSrc     = 9     // OFPAT_SET_TP_SRC
+	OFPATSetTpDst     = 10    // OFPAT_SET_TP_DST
+	OFPATEnqueue      = 11    // OFPAT_ENQUEUE
+	OFPATExperimenter = 65535 // OFPAT_EXPERIMENTER
+)
+
+type ActionType uint16
+
+func (self ActionType) MarshalJSON() ([]byte, error) {
+	return []byte(fmt.Sprintf("%d", self)), nil
+}
+
+const (
+	// Identifiers from group ofp_bad_action_code
+	OFPBACBadType             = 0 // OFPBAC_BAD_TYPE
+	OFPBACBadLen              = 1 // OFPBAC_BAD_LEN
+	OFPBACBadExperimenter     = 2 // OFPBAC_BAD_EXPERIMENTER
+	OFPBACBadExperimenterType = 3 // OFPBAC_BAD_EXPERIMENTER_TYPE
+	OFPBACBadOutPort          = 4 // OFPBAC_BAD_OUT_PORT
+	OFPBACBadArgument         = 5 // OFPBAC_BAD_ARGUMENT
+	OFPBACEperm               = 6 // OFPBAC_EPERM
+	OFPBACTooMany             = 7 // OFPBAC_TOO_MANY
+	OFPBACBadQueue            = 8 // OFPBAC_BAD_QUEUE
+)
+
+type BadActionCode uint16
+
+func (self BadActionCode) MarshalJSON() ([]byte, error) {
+	return []byte(fmt.Sprintf("%d", self)), nil
+}
+
+const (
+	// Identifiers from group ofp_bad_request_code
+	OFPBRCBadVersion      = 0 // OFPBRC_BAD_VERSION
+	OFPBRCBadType         = 1 // OFPBRC_BAD_TYPE
+	OFPBRCBadStat         = 2 // OFPBRC_BAD_STAT
+	OFPBRCBadExperimenter = 3 // OFPBRC_BAD_EXPERIMENTER
+	OFPBRCBadSubtype      = 4 // OFPBRC_BAD_SUBTYPE
+	OFPBRCEperm           = 5 // OFPBRC_EPERM
+	OFPBRCBadLen          = 6 // OFPBRC_BAD_LEN
+	OFPBRCBufferEmpty     = 7 // OFPBRC_BUFFER_EMPTY
+	OFPBRCBufferUnknown   = 8 // OFPBRC_BUFFER_UNKNOWN
+)
+
+type BadRequestCode uint16
+
+func (self BadRequestCode) MarshalJSON() ([]byte, error) {
+	return []byte(fmt.Sprintf("%d", self)), nil
+}
+
+const (
+	// Identifiers from group ofp_bsn_vport_l2gre_flags
+	OFBSNVportL2GreLocalMACIsValid  = 1  // OF_BSN_VPORT_L2GRE_LOCAL_MAC_IS_VALID
+	OFBSNVportL2GreDSCPAssign       = 2  // OF_BSN_VPORT_L2GRE_DSCP_ASSIGN
+	OFBSNVportL2GreDSCPCopy         = 4  // OF_BSN_VPORT_L2GRE_DSCP_COPY
+	OFBSNVportL2GreLoopbackIsValid  = 8  // OF_BSN_VPORT_L2GRE_LOOPBACK_IS_VALID
+	OFBSNVportL2GreRateLimitIsValid = 16 // OF_BSN_VPORT_L2GRE_RATE_LIMIT_IS_VALID
+)
+
+type BsnVportL2GreFlags uint32
+
+func (self BsnVportL2GreFlags) MarshalJSON() ([]byte, error) {
+	var flags []string
+	if self&OFBSNVportL2GreLocalMACIsValid == OFBSNVportL2GreLocalMACIsValid {
+		flags = append(flags, "\"LocalMACIsValid\": true")
+	}
+	if self&OFBSNVportL2GreDSCPAssign == OFBSNVportL2GreDSCPAssign {
+		flags = append(flags, "\"DscpAssign\": true")
+	}
+	if self&OFBSNVportL2GreDSCPCopy == OFBSNVportL2GreDSCPCopy {
+		flags = append(flags, "\"DscpCopy\": true")
+	}
+	if self&OFBSNVportL2GreLoopbackIsValid == OFBSNVportL2GreLoopbackIsValid {
+		flags = append(flags, "\"LoopbackIsValid\": true")
+	}
+	if self&OFBSNVportL2GreRateLimitIsValid == OFBSNVportL2GreRateLimitIsValid {
+		flags = append(flags, "\"RateLimitIsValid\": true")
+	}
+	return []byte("{" + strings.Join(flags, ", ") + "}"), nil
+}
+
+const (
+	// Identifiers from group ofp_bsn_vport_q_in_q_untagged
+	OFBSNVportQInQUntagged = 65535 // OF_BSN_VPORT_Q_IN_Q_UNTAGGED
+)
+
+type BsnVportQInQUntagged uint16
+
+func (self BsnVportQInQUntagged) MarshalJSON() ([]byte, error) {
+	return []byte(fmt.Sprintf("%d", self)), nil
+}
+
+const (
+	// Identifiers from group ofp_bsn_vport_status
+	OFBSNVportStatusOk     = 0 // OF_BSN_VPORT_STATUS_OK
+	OFBSNVportStatusFailed = 1 // OF_BSN_VPORT_STATUS_FAILED
+)
+
+const (
+	// Identifiers from group ofp_capabilities
+	OFPCFlowStats  = 1   // OFPC_FLOW_STATS
+	OFPCTableStats = 2   // OFPC_TABLE_STATS
+	OFPCPortStats  = 4   // OFPC_PORT_STATS
+	OFPCSTP        = 8   // OFPC_STP
+	OFPCReserved   = 16  // OFPC_RESERVED
+	OFPCIpReasm    = 32  // OFPC_IP_REASM
+	OFPCQueueStats = 64  // OFPC_QUEUE_STATS
+	OFPCARPMatchIp = 128 // OFPC_ARP_MATCH_IP
+)
+
+type Capabilities uint32
+
+func (self Capabilities) MarshalJSON() ([]byte, error) {
+	var flags []string
+	if self&OFPCFlowStats == OFPCFlowStats {
+		flags = append(flags, "\"FlowStats\": true")
+	}
+	if self&OFPCTableStats == OFPCTableStats {
+		flags = append(flags, "\"TableStats\": true")
+	}
+	if self&OFPCPortStats == OFPCPortStats {
+		flags = append(flags, "\"PortStats\": true")
+	}
+	if self&OFPCSTP == OFPCSTP {
+		flags = append(flags, "\"Stp\": true")
+	}
+	if self&OFPCReserved == OFPCReserved {
+		flags = append(flags, "\"Reserved\": true")
+	}
+	if self&OFPCIpReasm == OFPCIpReasm {
+		flags = append(flags, "\"IpReasm\": true")
+	}
+	if self&OFPCQueueStats == OFPCQueueStats {
+		flags = append(flags, "\"QueueStats\": true")
+	}
+	if self&OFPCARPMatchIp == OFPCARPMatchIp {
+		flags = append(flags, "\"ArpMatchIp\": true")
+	}
+	return []byte("{" + strings.Join(flags, ", ") + "}"), nil
+}
+
+const (
+	// Identifiers from group ofp_config_flags
+	OFPCFragNormal = 0 // OFPC_FRAG_NORMAL
+	OFPCFragDrop   = 1 // OFPC_FRAG_DROP
+	OFPCFragReasm  = 2 // OFPC_FRAG_REASM
+	OFPCFragMask   = 3 // OFPC_FRAG_MASK
+)
+
+type ConfigFlags uint16
+
+func (self ConfigFlags) MarshalJSON() ([]byte, error) {
+	var flags []string
+	if self&OFPCFragNormal == OFPCFragNormal {
+		flags = append(flags, "\"Normal\": true")
+	}
+	if self&OFPCFragDrop == OFPCFragDrop {
+		flags = append(flags, "\"Drop\": true")
+	}
+	if self&OFPCFragReasm == OFPCFragReasm {
+		flags = append(flags, "\"Reasm\": true")
+	}
+	if self&OFPCFragMask == OFPCFragMask {
+		flags = append(flags, "\"Mask\": true")
+	}
+	return []byte("{" + strings.Join(flags, ", ") + "}"), nil
+}
+
+const (
+	// Identifiers from group ofp_cs_states
+	CsNew         = 1   // OFP_CS_NEW
+	CsEstablished = 2   // OFP_CS_ESTABLISHED
+	CsRelated     = 4   // OFP_CS_RELATED
+	CsReplyDir    = 8   // OFP_CS_REPLY_DIR
+	CsInvalid     = 16  // OFP_CS_INVALID
+	CsTracked     = 32  // OFP_CS_TRACKED
+	CsSrcNat      = 64  // OFP_CS_SRC_NAT
+	CsDstNat      = 128 // OFP_CS_DST_NAT
+)
+
+type CsStates uint32
+
+func (self CsStates) MarshalJSON() ([]byte, error) {
+	var flags []string
+	if self&CsNew == CsNew {
+		flags = append(flags, "\"New\": true")
+	}
+	if self&CsEstablished == CsEstablished {
+		flags = append(flags, "\"Established\": true")
+	}
+	if self&CsRelated == CsRelated {
+		flags = append(flags, "\"Related\": true")
+	}
+	if self&CsReplyDir == CsReplyDir {
+		flags = append(flags, "\"ReplyDir\": true")
+	}
+	if self&CsInvalid == CsInvalid {
+		flags = append(flags, "\"Invalid\": true")
+	}
+	if self&CsTracked == CsTracked {
+		flags = append(flags, "\"Tracked\": true")
+	}
+	if self&CsSrcNat == CsSrcNat {
+		flags = append(flags, "\"SrcNat\": true")
+	}
+	if self&CsDstNat == CsDstNat {
+		flags = append(flags, "\"DstNat\": true")
+	}
+	return []byte("{" + strings.Join(flags, ", ") + "}"), nil
+}
+
+const (
+	// Identifiers from group ofp_ed_nsh_prop_type
+	OFPPPTPropNshNone   = 0 // OFPPPT_PROP_NSH_NONE
+	OFPPPTPropNshMdtype = 1 // OFPPPT_PROP_NSH_MDTYPE
+	OFPPPTPropNshTlv    = 2 // OFPPPT_PROP_NSH_TLV
+)
+
+type EdNshPropType uint8
+
+func (self EdNshPropType) MarshalJSON() ([]byte, error) {
+	return []byte(fmt.Sprintf("%d", self)), nil
+}
+
+const (
+	// Identifiers from group ofp_ed_prop_class
+	OFPPPCBasic        = 0     // OFPPPC_BASIC
+	OFPPPCMpls         = 1     // OFPPPC_MPLS
+	OFPPPCGRE          = 2     // OFPPPC_GRE
+	OFPPPCGtp          = 3     // OFPPPC_GTP
+	OFPPPCNsh          = 4     // OFPPPC_NSH
+	OFPPPCExperimenter = 65535 // OFPPPC_EXPERIMENTER
+)
+
+type EdPropClass uint16
+
+func (self EdPropClass) MarshalJSON() ([]byte, error) {
+	return []byte(fmt.Sprintf("%d", self)), nil
+}
+
+const (
+	// Identifiers from group ofp_error_type
+	OFPETHelloFailed   = 0 // OFPET_HELLO_FAILED
+	OFPETBadRequest    = 1 // OFPET_BAD_REQUEST
+	OFPETBadAction     = 2 // OFPET_BAD_ACTION
+	OFPETFlowModFailed = 3 // OFPET_FLOW_MOD_FAILED
+	OFPETPortModFailed = 4 // OFPET_PORT_MOD_FAILED
+	OFPETQueueOpFailed = 5 // OFPET_QUEUE_OP_FAILED
+)
+
+type ErrorType uint16
+
+func (self ErrorType) MarshalJSON() ([]byte, error) {
+	return []byte(fmt.Sprintf("%d", self)), nil
+}
+
+const (
+	// Identifiers from group ofp_ethernet_type
+	EthPLoop      = 96    // ETH_P_LOOP
+	EthPPup       = 512   // ETH_P_PUP
+	EthPPupat     = 513   // ETH_P_PUPAT
+	EthPIp        = 2048  // ETH_P_IP
+	EthPX25       = 2053  // ETH_P_X25
+	EthPARP       = 2054  // ETH_P_ARP
+	EthPBpq       = 2303  // ETH_P_BPQ
+	EthPIeeepup   = 2560  // ETH_P_IEEEPUP
+	EthPIeeepupat = 2561  // ETH_P_IEEEPUPAT
+	EthPDec       = 24576 // ETH_P_DEC
+	EthPDnaDl     = 24577 // ETH_P_DNA_DL
+	EthPDnaRc     = 24578 // ETH_P_DNA_RC
+	EthPDnaRt     = 24579 // ETH_P_DNA_RT
+	EthPLat       = 24580 // ETH_P_LAT
+	EthPDiag      = 24581 // ETH_P_DIAG
+	EthPCust      = 24582 // ETH_P_CUST
+	EthPSca       = 24583 // ETH_P_SCA
+	EthPTeb       = 25944 // ETH_P_TEB
+	EthPRarp      = 32821 // ETH_P_RARP
+	EthPAtalk     = 32923 // ETH_P_ATALK
+	EthPAarp      = 33011 // ETH_P_AARP
+	EthP8021Q     = 33024 // ETH_P_8021Q
+	EthPIpx       = 33079 // ETH_P_IPX
+	EthPIpv6      = 34525 // ETH_P_IPV6
+	EthPPause     = 34824 // ETH_P_PAUSE
+	EthPSlow      = 34825 // ETH_P_SLOW
+	EthPWccp      = 34878 // ETH_P_WCCP
+	EthPPppDisc   = 34915 // ETH_P_PPP_DISC
+	EthPPppSes    = 34916 // ETH_P_PPP_SES
+	EthPMplsUc    = 34887 // ETH_P_MPLS_UC
+	EthPMplsMc    = 34888 // ETH_P_MPLS_MC
+	EthPAtmmpoa   = 34892 // ETH_P_ATMMPOA
+	EthPAtmfate   = 34948 // ETH_P_ATMFATE
+	EthPPae       = 34958 // ETH_P_PAE
+	EthPAoe       = 34978 // ETH_P_AOE
+	EthPTipc      = 35018 // ETH_P_TIPC
+	EthP1588      = 35063 // ETH_P_1588
+	EthPFcoe      = 35078 // ETH_P_FCOE
+	EthPFip       = 35092 // ETH_P_FIP
+	EthPEdsa      = 56026 // ETH_P_EDSA
+)
+
+type EthernetType uint16
+
+func (self EthernetType) MarshalJSON() ([]byte, error) {
+	return []byte(fmt.Sprintf("\"%s\"", self)), nil
+}
+
+func (self EthernetType) String() string {
+	switch self {
+	case EthPLoop:
+		return "loop"
+	case EthPPup:
+		return "pup"
+	case EthPPupat:
+		return "pupat"
+	case EthPIp:
+		return "ip"
+	case EthPX25:
+		return "x25"
+	case EthPARP:
+		return "arp"
+	case EthPBpq:
+		return "bpq"
+	case EthPIeeepup:
+		return "ieeepup"
+	case EthPIeeepupat:
+		return "ieeepupat"
+	case EthPDec:
+		return "dec"
+	case EthPDnaDl:
+		return "dna_dl"
+	case EthPDnaRc:
+		return "dna_rc"
+	case EthPDnaRt:
+		return "dna_rt"
+	case EthPLat:
+		return "lat"
+	case EthPDiag:
+		return "diag"
+	case EthPCust:
+		return "cust"
+	case EthPSca:
+		return "sca"
+	case EthPTeb:
+		return "teb"
+	case EthPRarp:
+		return "rarp"
+	case EthPAtalk:
+		return "atalk"
+	case EthPAarp:
+		return "aarp"
+	case EthP8021Q:
+		return "8021q"
+	case EthPIpx:
+		return "ipx"
+	case EthPIpv6:
+		return "ipv6"
+	case EthPPause:
+		return "pause"
+	case EthPSlow:
+		return "slow"
+	case EthPWccp:
+		return "wccp"
+	case EthPPppDisc:
+		return "ppp_disc"
+	case EthPPppSes:
+		return "ppp_ses"
+	case EthPMplsUc:
+		return "mpls_uc"
+	case EthPMplsMc:
+		return "mpls_mc"
+	case EthPAtmmpoa:
+		return "atmmpoa"
+	case EthPAtmfate:
+		return "atmfate"
+	case EthPPae:
+		return "pae"
+	case EthPAoe:
+		return "aoe"
+	case EthPTipc:
+		return "tipc"
+	case EthP1588:
+		return "1588"
+	case EthPFcoe:
+		return "fcoe"
+	case EthPFip:
+		return "fip"
+	case EthPEdsa:
+		return "edsa"
+	default:
+		return fmt.Sprintf("%d", self)
+	}
+}
+
+const (
+	// Identifiers from group ofp_flow_mod_command
+	OFPFCAdd          = 0 // OFPFC_ADD
+	OFPFCModify       = 1 // OFPFC_MODIFY
+	OFPFCModifyStrict = 2 // OFPFC_MODIFY_STRICT
+	OFPFCDelete       = 3 // OFPFC_DELETE
+	OFPFCDeleteStrict = 4 // OFPFC_DELETE_STRICT
+)
+
+type FlowModCommand uint16
+
+func (self FlowModCommand) MarshalJSON() ([]byte, error) {
+	return []byte(fmt.Sprintf("%d", self)), nil
+}
+
+const (
+	// Identifiers from group ofp_flow_mod_failed_code
+	OFPFMFCAllTablesFull   = 0 // OFPFMFC_ALL_TABLES_FULL
+	OFPFMFCOverlap         = 1 // OFPFMFC_OVERLAP
+	OFPFMFCEperm           = 2 // OFPFMFC_EPERM
+	OFPFMFCBadEmergTimeout = 3 // OFPFMFC_BAD_EMERG_TIMEOUT
+	OFPFMFCBadCommand      = 4 // OFPFMFC_BAD_COMMAND
+	OFPFMFCUnsupported     = 5 // OFPFMFC_UNSUPPORTED
+)
+
+type FlowModFailedCode uint16
+
+func (self FlowModFailedCode) MarshalJSON() ([]byte, error) {
+	return []byte(fmt.Sprintf("%d", self)), nil
+}
+
+const (
+	// Identifiers from group ofp_flow_mod_flags
+	OFPFFSendFlowRem  = 1 // OFPFF_SEND_FLOW_REM
+	OFPFFCheckOverlap = 2 // OFPFF_CHECK_OVERLAP
+	OFPFFEmerg        = 4 // OFPFF_EMERG
+)
+
+type FlowModFlags uint16
+
+func (self FlowModFlags) MarshalJSON() ([]byte, error) {
+	var flags []string
+	if self&OFPFFSendFlowRem == OFPFFSendFlowRem {
+		flags = append(flags, "\"SendFlowRem\": true")
+	}
+	if self&OFPFFCheckOverlap == OFPFFCheckOverlap {
+		flags = append(flags, "\"CheckOverlap\": true")
+	}
+	if self&OFPFFEmerg == OFPFFEmerg {
+		flags = append(flags, "\"Emerg\": true")
+	}
+	return []byte("{" + strings.Join(flags, ", ") + "}"), nil
+}
+
+const (
+	// Identifiers from group ofp_flow_removed_reason
+	OFPRRIdleTimeout = 0 // OFPRR_IDLE_TIMEOUT
+	OFPRRHardTimeout = 1 // OFPRR_HARD_TIMEOUT
+	OFPRRDelete      = 2 // OFPRR_DELETE
+)
+
+type FlowRemovedReason uint8
+
+func (self FlowRemovedReason) MarshalJSON() ([]byte, error) {
+	return []byte(fmt.Sprintf("%d", self)), nil
+}
+
+const (
+	// Identifiers from group ofp_flow_wildcards
+	OFPFWInPort     = 1       // OFPFW_IN_PORT
+	OFPFWDlVLAN     = 2       // OFPFW_DL_VLAN
+	OFPFWDlSrc      = 4       // OFPFW_DL_SRC
+	OFPFWNwDstBits  = 6       // OFPFW_NW_DST_BITS
+	OFPFWNwSrcBits  = 6       // OFPFW_NW_SRC_BITS
+	OFPFWNwSrcShift = 8       // OFPFW_NW_SRC_SHIFT
+	OFPFWDlDst      = 8       // OFPFW_DL_DST
+	OFPFWNwDstShift = 14      // OFPFW_NW_DST_SHIFT
+	OFPFWDlType     = 16      // OFPFW_DL_TYPE
+	OFPFWNwProto    = 32      // OFPFW_NW_PROTO
+	OFPFWTpSrc      = 64      // OFPFW_TP_SRC
+	OFPFWTpDst      = 128     // OFPFW_TP_DST
+	OFPFWNwSrcAll   = 8192    // OFPFW_NW_SRC_ALL
+	OFPFWNwSrcMask  = 16128   // OFPFW_NW_SRC_MASK
+	OFPFWNwDstAll   = 524288  // OFPFW_NW_DST_ALL
+	OFPFWNwDstMask  = 1032192 // OFPFW_NW_DST_MASK
+	OFPFWDlVLANPCP  = 1048576 // OFPFW_DL_VLAN_PCP
+	OFPFWNwTos      = 2097152 // OFPFW_NW_TOS
+	OFPFWAll        = 4194303 // OFPFW_ALL
+)
+
+type FlowWildcards uint32
+
+func (self FlowWildcards) MarshalJSON() ([]byte, error) {
+	var flags []string
+	if self&OFPFWInPort == OFPFWInPort {
+		flags = append(flags, "\"InPort\": true")
+	}
+	if self&OFPFWDlVLAN == OFPFWDlVLAN {
+		flags = append(flags, "\"DlVLAN\": true")
+	}
+	if self&OFPFWDlSrc == OFPFWDlSrc {
+		flags = append(flags, "\"DlSrc\": true")
+	}
+	if self&OFPFWNwDstBits == OFPFWNwDstBits {
+		flags = append(flags, "\"NwDstBits\": true")
+	}
+	if self&OFPFWNwSrcBits == OFPFWNwSrcBits {
+		flags = append(flags, "\"NwSrcBits\": true")
+	}
+	if self&OFPFWNwSrcShift == OFPFWNwSrcShift {
+		flags = append(flags, "\"NwSrcShift\": true")
+	}
+	if self&OFPFWDlDst == OFPFWDlDst {
+		flags = append(flags, "\"DlDst\": true")
+	}
+	if self&OFPFWNwDstShift == OFPFWNwDstShift {
+		flags = append(flags, "\"NwDstShift\": true")
+	}
+	if self&OFPFWDlType == OFPFWDlType {
+		flags = append(flags, "\"DlType\": true")
+	}
+	if self&OFPFWNwProto == OFPFWNwProto {
+		flags = append(flags, "\"NwProto\": true")
+	}
+	if self&OFPFWTpSrc == OFPFWTpSrc {
+		flags = append(flags, "\"TpSrc\": true")
+	}
+	if self&OFPFWTpDst == OFPFWTpDst {
+		flags = append(flags, "\"TpDst\": true")
+	}
+	if self&OFPFWNwSrcAll == OFPFWNwSrcAll {
+		flags = append(flags, "\"NwSrcAll\": true")
+	}
+	if self&OFPFWNwSrcMask == OFPFWNwSrcMask {
+		flags = append(flags, "\"NwSrcMask\": true")
+	}
+	if self&OFPFWNwDstAll == OFPFWNwDstAll {
+		flags = append(flags, "\"NwDstAll\": true")
+	}
+	if self&OFPFWNwDstMask == OFPFWNwDstMask {
+		flags = append(flags, "\"NwDstMask\": true")
+	}
+	if self&OFPFWDlVLANPCP == OFPFWDlVLANPCP {
+		flags = append(flags, "\"DlVLANPCP\": true")
+	}
+	if self&OFPFWNwTos == OFPFWNwTos {
+		flags = append(flags, "\"NwTos\": true")
+	}
+	if self&OFPFWAll == OFPFWAll {
+		flags = append(flags, "\"All\": true")
+	}
+	return []byte("{" + strings.Join(flags, ", ") + "}"), nil
+}
+
+const (
+	// Identifiers from group ofp_hello_failed_code
+	OFPHFCIncompatible = 0 // OFPHFC_INCOMPATIBLE
+	OFPHFCEperm        = 1 // OFPHFC_EPERM
+)
+
+type HelloFailedCode uint16
+
+func (self HelloFailedCode) MarshalJSON() ([]byte, error) {
+	return []byte(fmt.Sprintf("%d", self)), nil
+}
+
+const (
+	// Identifiers from group ofp_icmp_type
+	IcmpEchoreply      = 0  // ICMP_ECHOREPLY
+	IcmpDestUnreach    = 3  // ICMP_DEST_UNREACH
+	IcmpSourceQuench   = 4  // ICMP_SOURCE_QUENCH
+	IcmpRedirect       = 5  // ICMP_REDIRECT
+	IcmpEcho           = 8  // ICMP_ECHO
+	IcmpTimeExceeded   = 11 // ICMP_TIME_EXCEEDED
+	IcmpParameterprob  = 12 // ICMP_PARAMETERPROB
+	IcmpTimestamp      = 13 // ICMP_TIMESTAMP
+	IcmpTimestampreply = 14 // ICMP_TIMESTAMPREPLY
+	IcmpInfoRequest    = 15 // ICMP_INFO_REQUEST
+	IcmpInfoReply      = 16 // ICMP_INFO_REPLY
+	IcmpAddress        = 17 // ICMP_ADDRESS
+	IcmpAddressreply   = 18 // ICMP_ADDRESSREPLY
+)
+
+type IcmpType uint8
+
+func (self IcmpType) MarshalJSON() ([]byte, error) {
+	return []byte(fmt.Sprintf("\"%s\"", self)), nil
+}
+
+func (self IcmpType) String() string {
+	switch self {
+	case IcmpEchoreply:
+		return "echoreply"
+	case IcmpDestUnreach:
+		return "dest_unreach"
+	case IcmpSourceQuench:
+		return "source_quench"
+	case IcmpRedirect:
+		return "redirect"
+	case IcmpEcho:
+		return "echo"
+	case IcmpTimeExceeded:
+		return "time_exceeded"
+	case IcmpParameterprob:
+		return "parameterprob"
+	case IcmpTimestamp:
+		return "timestamp"
+	case IcmpTimestampreply:
+		return "timestampreply"
+	case IcmpInfoRequest:
+		return "info_request"
+	case IcmpInfoReply:
+		return "info_reply"
+	case IcmpAddress:
+		return "address"
+	case IcmpAddressreply:
+		return "addressreply"
+	default:
+		return fmt.Sprintf("%d", self)
+	}
+}
+
+const (
+	// Identifiers from group ofp_icmpv6_type
+	Icmpv6EchoRequest     = 128 // ICMPV6_ECHO_REQUEST
+	Icmpv6EchoReply       = 129 // ICMPV6_ECHO_REPLY
+	Icmpv6MgmQuery        = 130 // ICMPV6_MGM_QUERY
+	Icmpv6MgmReport       = 131 // ICMPV6_MGM_REPORT
+	Icmpv6MgmReduction    = 132 // ICMPV6_MGM_REDUCTION
+	Icmpv6NiQuery         = 139 // ICMPV6_NI_QUERY
+	Icmpv6NiReply         = 140 // ICMPV6_NI_REPLY
+	Icmpv6Mld2Report      = 143 // ICMPV6_MLD2_REPORT
+	Icmpv6DhaadRequest    = 144 // ICMPV6_DHAAD_REQUEST
+	Icmpv6DhaadReply      = 145 // ICMPV6_DHAAD_REPLY
+	Icmpv6MobilePrefixSol = 146 // ICMPV6_MOBILE_PREFIX_SOL
+	Icmpv6MobilePrefixAdv = 147 // ICMPV6_MOBILE_PREFIX_ADV
+)
+
+type Icmpv6Type uint8
+
+func (self Icmpv6Type) MarshalJSON() ([]byte, error) {
+	return []byte(fmt.Sprintf("\"%s\"", self)), nil
+}
+
+func (self Icmpv6Type) String() string {
+	switch self {
+	case Icmpv6EchoRequest:
+		return "echo_request"
+	case Icmpv6EchoReply:
+		return "echo_reply"
+	case Icmpv6MgmQuery:
+		return "mgm_query"
+	case Icmpv6MgmReport:
+		return "mgm_report"
+	case Icmpv6MgmReduction:
+		return "mgm_reduction"
+	case Icmpv6NiQuery:
+		return "ni_query"
+	case Icmpv6NiReply:
+		return "ni_reply"
+	case Icmpv6Mld2Report:
+		return "mld2_report"
+	case Icmpv6DhaadRequest:
+		return "dhaad_request"
+	case Icmpv6DhaadReply:
+		return "dhaad_reply"
+	case Icmpv6MobilePrefixSol:
+		return "mobile_prefix_sol"
+	case Icmpv6MobilePrefixAdv:
+		return "mobile_prefix_adv"
+	default:
+		return fmt.Sprintf("%d", self)
+	}
+}
+
+const (
+	// Identifiers from group ofp_ip_prototype
+	IpprotoIp       = 0   // IPPROTO_IP
+	IpprotoICMP     = 1   // IPPROTO_ICMP
+	IpprotoIgmp     = 2   // IPPROTO_IGMP
+	IpprotoIpip     = 4   // IPPROTO_IPIP
+	IpprotoTCP      = 6   // IPPROTO_TCP
+	IpprotoEgp      = 8   // IPPROTO_EGP
+	IpprotoPup      = 12  // IPPROTO_PUP
+	IpprotoUdp      = 17  // IPPROTO_UDP
+	IpprotoIdp      = 22  // IPPROTO_IDP
+	IpprotoTp       = 29  // IPPROTO_TP
+	IpprotoDccp     = 33  // IPPROTO_DCCP
+	IpprotoIpv6     = 41  // IPPROTO_IPV6
+	IpprotoRsvp     = 46  // IPPROTO_RSVP
+	IpprotoGRE      = 47  // IPPROTO_GRE
+	IpprotoEsp      = 50  // IPPROTO_ESP
+	IpprotoAh       = 51  // IPPROTO_AH
+	IpprotoMtp      = 92  // IPPROTO_MTP
+	IpprotoBeetph   = 94  // IPPROTO_BEETPH
+	IpprotoEncap    = 98  // IPPROTO_ENCAP
+	IpprotoPim      = 103 // IPPROTO_PIM
+	IpprotoComp     = 108 // IPPROTO_COMP
+	IpprotoSctp     = 132 // IPPROTO_SCTP
+	IpprotoUdplite  = 136 // IPPROTO_UDPLITE
+	IpprotoMpls     = 137 // IPPROTO_MPLS
+	IpprotoRaw      = 255 // IPPROTO_RAW
+	IpprotoRouting  = 43  // IPPROTO_ROUTING
+	IpprotoFragment = 44  // IPPROTO_FRAGMENT
+	IpprotoIcmpv6   = 58  // IPPROTO_ICMPV6
+	IpprotoNone     = 59  // IPPROTO_NONE
+	IpprotoDstopts  = 60  // IPPROTO_DSTOPTS
+	IpprotoMh       = 135 // IPPROTO_MH
+	IpprotoL2Tp     = 115 // IPPROTO_L2TP
+)
+
+type IpPrototype uint8
+
+func (self IpPrototype) MarshalJSON() ([]byte, error) {
+	return []byte(fmt.Sprintf("\"%s\"", self)), nil
+}
+
+func (self IpPrototype) String() string {
+	switch self {
+	case IpprotoIp:
+		return "ip"
+	case IpprotoICMP:
+		return "icmp"
+	case IpprotoIgmp:
+		return "igmp"
+	case IpprotoIpip:
+		return "ipip"
+	case IpprotoTCP:
+		return "tcp"
+	case IpprotoEgp:
+		return "egp"
+	case IpprotoPup:
+		return "pup"
+	case IpprotoUdp:
+		return "udp"
+	case IpprotoIdp:
+		return "idp"
+	case IpprotoTp:
+		return "tp"
+	case IpprotoDccp:
+		return "dccp"
+	case IpprotoIpv6:
+		return "ipv6"
+	case IpprotoRsvp:
+		return "rsvp"
+	case IpprotoGRE:
+		return "gre"
+	case IpprotoEsp:
+		return "esp"
+	case IpprotoAh:
+		return "ah"
+	case IpprotoMtp:
+		return "mtp"
+	case IpprotoBeetph:
+		return "beetph"
+	case IpprotoEncap:
+		return "encap"
+	case IpprotoPim:
+		return "pim"
+	case IpprotoComp:
+		return "comp"
+	case IpprotoSctp:
+		return "sctp"
+	case IpprotoUdplite:
+		return "udplite"
+	case IpprotoMpls:
+		return "mpls"
+	case IpprotoRaw:
+		return "raw"
+	case IpprotoRouting:
+		return "routing"
+	case IpprotoFragment:
+		return "fragment"
+	case IpprotoIcmpv6:
+		return "icmpv6"
+	case IpprotoNone:
+		return "none"
+	case IpprotoDstopts:
+		return "dstopts"
+	case IpprotoMh:
+		return "mh"
+	case IpprotoL2Tp:
+		return "l2tp"
+	default:
+		return fmt.Sprintf("%d", self)
+	}
+}
+
+const (
+	// Identifiers from group ofp_nicira_controller_role
+	NxRoleOther  = 0 // NX_ROLE_OTHER
+	NxRoleMaster = 1 // NX_ROLE_MASTER
+	NxRoleSlave  = 2 // NX_ROLE_SLAVE
+)
+
+type NiciraControllerRole uint32
+
+func (self NiciraControllerRole) MarshalJSON() ([]byte, error) {
+	return []byte(fmt.Sprintf("%d", self)), nil
+}
+
+const (
+	// Identifiers from group ofp_packet_in_reason
+	OFPRNoMatch = 0 // OFPR_NO_MATCH
+	OFPRAction  = 1 // OFPR_ACTION
+)
+
+type PacketInReason uint8
+
+func (self PacketInReason) MarshalJSON() ([]byte, error) {
+	return []byte(fmt.Sprintf("%d", self)), nil
+}
+
+const (
+	// Identifiers from group ofp_packet_type
+	PtEthernet     = 0          // OFP_PT_ETHERNET
+	PtUseNextProto = 65534      // OFP_PT_USE_NEXT_PROTO
+	PtIpv4         = 67584      // OFP_PT_IPV4
+	PtMpls         = 100423     // OFP_PT_MPLS
+	PtMplsMc       = 100424     // OFP_PT_MPLS_MC
+	PtNsh          = 100687     // OFP_PT_NSH
+	PtUnknown      = 4294967295 // OFP_PT_UNKNOWN
+)
+
+type PacketType uint32
+
+func (self PacketType) MarshalJSON() ([]byte, error) {
+	return []byte(fmt.Sprintf("\"%s\"", self)), nil
+}
+
+func (self PacketType) String() string {
+	switch self {
+	case PtEthernet:
+		return "ethernet"
+	case PtUseNextProto:
+		return "use_next_proto"
+	case PtIpv4:
+		return "ipv4"
+	case PtMpls:
+		return "mpls"
+	case PtMplsMc:
+		return "mpls_mc"
+	case PtNsh:
+		return "nsh"
+	case PtUnknown:
+		return "unknown"
+	default:
+		return fmt.Sprintf("%d", self)
+	}
+}
+
+const (
+	// Identifiers from group ofp_port
+	OFPPMax        = 0xff00 // OFPP_MAX
+	OFPPInPort     = 0xfff8 // OFPP_IN_PORT
+	OFPPTable      = 0xfff9 // OFPP_TABLE
+	OFPPNormal     = 0xfffa // OFPP_NORMAL
+	OFPPFlood      = 0xfffb // OFPP_FLOOD
+	OFPPAll        = 0xfffc // OFPP_ALL
+	OFPPController = 0xfffd // OFPP_CONTROLLER
+	OFPPLocal      = 0xfffe // OFPP_LOCAL
+	OFPPNone       = 0xffff // OFPP_NONE
+)
+
+type Port uint16
+
+func (self Port) MarshalJSON() ([]byte, error) {
+	return []byte(fmt.Sprintf("%d", self)), nil
+}
+
+const (
+	// Identifiers from group ofp_port_config
+	OFPPCPortDown      = 1          // OFPPC_PORT_DOWN
+	OFPPCNoSTP         = 2          // OFPPC_NO_STP
+	OFPPCNoRecv        = 4          // OFPPC_NO_RECV
+	OFPPCNoRecvSTP     = 8          // OFPPC_NO_RECV_STP
+	OFPPCNoFlood       = 16         // OFPPC_NO_FLOOD
+	OFPPCNoFwd         = 32         // OFPPC_NO_FWD
+	OFPPCNoPacketIn    = 64         // OFPPC_NO_PACKET_IN
+	OFPPCBSNMirrorDest = 2147483648 // OFPPC_BSN_MIRROR_DEST
+)
+
+type PortConfig uint32
+
+func (self PortConfig) MarshalJSON() ([]byte, error) {
+	var flags []string
+	if self&OFPPCPortDown == OFPPCPortDown {
+		flags = append(flags, "\"PortDown\": true")
+	}
+	if self&OFPPCNoSTP == OFPPCNoSTP {
+		flags = append(flags, "\"NoSTP\": true")
+	}
+	if self&OFPPCNoRecv == OFPPCNoRecv {
+		flags = append(flags, "\"NoRecv\": true")
+	}
+	if self&OFPPCNoRecvSTP == OFPPCNoRecvSTP {
+		flags = append(flags, "\"NoRecvSTP\": true")
+	}
+	if self&OFPPCNoFlood == OFPPCNoFlood {
+		flags = append(flags, "\"NoFlood\": true")
+	}
+	if self&OFPPCNoFwd == OFPPCNoFwd {
+		flags = append(flags, "\"NoFwd\": true")
+	}
+	if self&OFPPCNoPacketIn == OFPPCNoPacketIn {
+		flags = append(flags, "\"NoPacketIn\": true")
+	}
+	if self&OFPPCBSNMirrorDest == OFPPCBSNMirrorDest {
+		flags = append(flags, "\"BsnMirrorDest\": true")
+	}
+	return []byte("{" + strings.Join(flags, ", ") + "}"), nil
+}
+
+const (
+	// Identifiers from group ofp_port_features
+	OFPPF10MbHd    = 1    // OFPPF_10MB_HD
+	OFPPF10MbFd    = 2    // OFPPF_10MB_FD
+	OFPPF100MbHd   = 4    // OFPPF_100MB_HD
+	OFPPF100MbFd   = 8    // OFPPF_100MB_FD
+	OFPPF1GbHd     = 16   // OFPPF_1GB_HD
+	OFPPF1GbFd     = 32   // OFPPF_1GB_FD
+	OFPPF10GbFd    = 64   // OFPPF_10GB_FD
+	OFPPFCopper    = 128  // OFPPF_COPPER
+	OFPPFFiber     = 256  // OFPPF_FIBER
+	OFPPFAutoneg   = 512  // OFPPF_AUTONEG
+	OFPPFPause     = 1024 // OFPPF_PAUSE
+	OFPPFPauseAsym = 2048 // OFPPF_PAUSE_ASYM
+)
+
+type PortFeatures uint32
+
+func (self PortFeatures) MarshalJSON() ([]byte, error) {
+	var flags []string
+	if self&OFPPF10MbHd == OFPPF10MbHd {
+		flags = append(flags, "\"10MbHd\": true")
+	}
+	if self&OFPPF10MbFd == OFPPF10MbFd {
+		flags = append(flags, "\"10MbFd\": true")
+	}
+	if self&OFPPF100MbHd == OFPPF100MbHd {
+		flags = append(flags, "\"100MbHd\": true")
+	}
+	if self&OFPPF100MbFd == OFPPF100MbFd {
+		flags = append(flags, "\"100MbFd\": true")
+	}
+	if self&OFPPF1GbHd == OFPPF1GbHd {
+		flags = append(flags, "\"1GbHd\": true")
+	}
+	if self&OFPPF1GbFd == OFPPF1GbFd {
+		flags = append(flags, "\"1GbFd\": true")
+	}
+	if self&OFPPF10GbFd == OFPPF10GbFd {
+		flags = append(flags, "\"10GbFd\": true")
+	}
+	if self&OFPPFCopper == OFPPFCopper {
+		flags = append(flags, "\"Copper\": true")
+	}
+	if self&OFPPFFiber == OFPPFFiber {
+		flags = append(flags, "\"Fiber\": true")
+	}
+	if self&OFPPFAutoneg == OFPPFAutoneg {
+		flags = append(flags, "\"Autoneg\": true")
+	}
+	if self&OFPPFPause == OFPPFPause {
+		flags = append(flags, "\"Pause\": true")
+	}
+	if self&OFPPFPauseAsym == OFPPFPauseAsym {
+		flags = append(flags, "\"PauseAsym\": true")
+	}
+	return []byte("{" + strings.Join(flags, ", ") + "}"), nil
+}
+
+const (
+	// Identifiers from group ofp_port_mod_failed_code
+	OFPPMFCBadPort   = 0 // OFPPMFC_BAD_PORT
+	OFPPMFCBadHwAddr = 1 // OFPPMFC_BAD_HW_ADDR
+)
+
+type PortModFailedCode uint16
+
+func (self PortModFailedCode) MarshalJSON() ([]byte, error) {
+	return []byte(fmt.Sprintf("%d", self)), nil
+}
+
+const (
+	// Identifiers from group ofp_port_reason
+	OFPPRAdd    = 0 // OFPPR_ADD
+	OFPPRDelete = 1 // OFPPR_DELETE
+	OFPPRModify = 2 // OFPPR_MODIFY
+)
+
+type PortReason uint8
+
+func (self PortReason) MarshalJSON() ([]byte, error) {
+	return []byte(fmt.Sprintf("%d", self)), nil
+}
+
+const (
+	// Identifiers from group ofp_port_state
+	OFPPSLinkDown   = 1   // OFPPS_LINK_DOWN
+	OFPPSSTPListen  = 0   // OFPPS_STP_LISTEN
+	OFPPSSTPLearn   = 256 // OFPPS_STP_LEARN
+	OFPPSSTPForward = 512 // OFPPS_STP_FORWARD
+	OFPPSSTPBlock   = 768 // OFPPS_STP_BLOCK
+	OFPPSSTPMask    = 768 // OFPPS_STP_MASK
+)
+
+type PortState uint32
+
+func (self PortState) MarshalJSON() ([]byte, error) {
+	var flags []string
+	if self&OFPPSLinkDown == OFPPSLinkDown {
+		flags = append(flags, "\"LinkDown\": true")
+	}
+	if self&OFPPSSTPListen == OFPPSSTPListen {
+		flags = append(flags, "\"StpListen\": true")
+	}
+	if self&OFPPSSTPLearn == OFPPSSTPLearn {
+		flags = append(flags, "\"StpLearn\": true")
+	}
+	if self&OFPPSSTPForward == OFPPSSTPForward {
+		flags = append(flags, "\"StpForward\": true")
+	}
+	if self&OFPPSSTPBlock == OFPPSSTPBlock {
+		flags = append(flags, "\"StpBlock\": true")
+	}
+	if self&OFPPSSTPMask == OFPPSSTPMask {
+		flags = append(flags, "\"StpMask\": true")
+	}
+	return []byte("{" + strings.Join(flags, ", ") + "}"), nil
+}
+
+const (
+	// Identifiers from group ofp_queue_op_failed_code
+	OFPQOFCBadPort  = 0 // OFPQOFC_BAD_PORT
+	OFPQOFCBadQueue = 1 // OFPQOFC_BAD_QUEUE
+	OFPQOFCEperm    = 2 // OFPQOFC_EPERM
+)
+
+type QueueOpFailedCode uint16
+
+func (self QueueOpFailedCode) MarshalJSON() ([]byte, error) {
+	return []byte(fmt.Sprintf("%d", self)), nil
+}
+
+const (
+	// Identifiers from group ofp_queue_properties
+	OFPQTNone    = 0 // OFPQT_NONE
+	OFPQTMinRate = 1 // OFPQT_MIN_RATE
+)
+
+type QueueProperties uint32
+
+func (self QueueProperties) MarshalJSON() ([]byte, error) {
+	return []byte(fmt.Sprintf("%d", self)), nil
+}
+
+const (
+	// Identifiers from group ofp_stats_reply_flags
+	OFPSFReplyMore = 1 // OFPSF_REPLY_MORE
+)
+
+type StatsReplyFlags uint16
+
+func (self StatsReplyFlags) MarshalJSON() ([]byte, error) {
+	var flags []string
+	if self&OFPSFReplyMore == OFPSFReplyMore {
+		flags = append(flags, "\"OFPSFReplyMore\": true")
+	}
+	return []byte("{" + strings.Join(flags, ", ") + "}"), nil
+}
+
+const (
+// Identifiers from group ofp_stats_request_flags
+)
+
+type StatsRequestFlags uint16
+
+func (self StatsRequestFlags) MarshalJSON() ([]byte, error) {
+	var flags []string
+	return []byte("{" + strings.Join(flags, ", ") + "}"), nil
+}
+
+const (
+	// Identifiers from group ofp_stats_type
+	OFPSTDesc         = 0     // OFPST_DESC
+	OFPSTFlow         = 1     // OFPST_FLOW
+	OFPSTAggregate    = 2     // OFPST_AGGREGATE
+	OFPSTTable        = 3     // OFPST_TABLE
+	OFPSTPort         = 4     // OFPST_PORT
+	OFPSTQueue        = 5     // OFPST_QUEUE
+	OFPSTExperimenter = 65535 // OFPST_EXPERIMENTER
+)
+
+type StatsType uint16
+
+func (self StatsType) MarshalJSON() ([]byte, error) {
+	return []byte(fmt.Sprintf("%d", self)), nil
+}
+
+const (
+	// Identifiers from group ofp_tcp_flags
+	TcpFlagCwr = 128 // TCP_FLAG_CWR
+	TcpFlagEce = 64  // TCP_FLAG_ECE
+	TcpFlagUrg = 32  // TCP_FLAG_URG
+	TcpFlagAck = 16  // TCP_FLAG_ACK
+	TcpFlagPsh = 8   // TCP_FLAG_PSH
+	TcpFlagRst = 4   // TCP_FLAG_RST
+	TcpFlagSyn = 2   // TCP_FLAG_SYN
+	TcpFlagFin = 1   // TCP_FLAG_FIN
+)
+
+type TcpFlags uint16
+
+func (self TcpFlags) MarshalJSON() ([]byte, error) {
+	var flags []string
+	if self&TcpFlagCwr == TcpFlagCwr {
+		flags = append(flags, "\"Cwr\": true")
+	}
+	if self&TcpFlagEce == TcpFlagEce {
+		flags = append(flags, "\"Ece\": true")
+	}
+	if self&TcpFlagUrg == TcpFlagUrg {
+		flags = append(flags, "\"Urg\": true")
+	}
+	if self&TcpFlagAck == TcpFlagAck {
+		flags = append(flags, "\"Ack\": true")
+	}
+	if self&TcpFlagPsh == TcpFlagPsh {
+		flags = append(flags, "\"Psh\": true")
+	}
+	if self&TcpFlagRst == TcpFlagRst {
+		flags = append(flags, "\"Rst\": true")
+	}
+	if self&TcpFlagSyn == TcpFlagSyn {
+		flags = append(flags, "\"Syn\": true")
+	}
+	if self&TcpFlagFin == TcpFlagFin {
+		flags = append(flags, "\"Fin\": true")
+	}
+	return []byte("{" + strings.Join(flags, ", ") + "}"), nil
+}
+
+const (
+	// Identifiers from group ofp_type
+	OFPTHello                 = 0  // OFPT_HELLO
+	OFPTError                 = 1  // OFPT_ERROR
+	OFPTEchoRequest           = 2  // OFPT_ECHO_REQUEST
+	OFPTEchoReply             = 3  // OFPT_ECHO_REPLY
+	OFPTExperimenter          = 4  // OFPT_EXPERIMENTER
+	OFPTFeaturesRequest       = 5  // OFPT_FEATURES_REQUEST
+	OFPTFeaturesReply         = 6  // OFPT_FEATURES_REPLY
+	OFPTGetConfigRequest      = 7  // OFPT_GET_CONFIG_REQUEST
+	OFPTGetConfigReply        = 8  // OFPT_GET_CONFIG_REPLY
+	OFPTSetConfig             = 9  // OFPT_SET_CONFIG
+	OFPTPacketIn              = 10 // OFPT_PACKET_IN
+	OFPTFlowRemoved           = 11 // OFPT_FLOW_REMOVED
+	OFPTPortStatus            = 12 // OFPT_PORT_STATUS
+	OFPTPacketOut             = 13 // OFPT_PACKET_OUT
+	OFPTFlowMod               = 14 // OFPT_FLOW_MOD
+	OFPTPortMod               = 15 // OFPT_PORT_MOD
+	OFPTStatsRequest          = 16 // OFPT_STATS_REQUEST
+	OFPTStatsReply            = 17 // OFPT_STATS_REPLY
+	OFPTBarrierRequest        = 18 // OFPT_BARRIER_REQUEST
+	OFPTBarrierReply          = 19 // OFPT_BARRIER_REPLY
+	OFPTQueueGetConfigRequest = 20 // OFPT_QUEUE_GET_CONFIG_REQUEST
+	OFPTQueueGetConfigReply   = 21 // OFPT_QUEUE_GET_CONFIG_REPLY
+)
+
+type Type uint8
+
+func (self Type) MarshalJSON() ([]byte, error) {
+	return []byte(fmt.Sprintf("\"%s\"", self)), nil
+}
+
+func (self Type) String() string {
+	switch self {
+	case OFPTHello:
+		return "hello"
+	case OFPTError:
+		return "error"
+	case OFPTEchoRequest:
+		return "echo_request"
+	case OFPTEchoReply:
+		return "echo_reply"
+	case OFPTExperimenter:
+		return "experimenter"
+	case OFPTFeaturesRequest:
+		return "features_request"
+	case OFPTFeaturesReply:
+		return "features_reply"
+	case OFPTGetConfigRequest:
+		return "get_config_request"
+	case OFPTGetConfigReply:
+		return "get_config_reply"
+	case OFPTSetConfig:
+		return "set_config"
+	case OFPTPacketIn:
+		return "packet_in"
+	case OFPTFlowRemoved:
+		return "flow_removed"
+	case OFPTPortStatus:
+		return "port_status"
+	case OFPTPacketOut:
+		return "packet_out"
+	case OFPTFlowMod:
+		return "flow_mod"
+	case OFPTPortMod:
+		return "port_mod"
+	case OFPTStatsRequest:
+		return "stats_request"
+	case OFPTStatsReply:
+		return "stats_reply"
+	case OFPTBarrierRequest:
+		return "barrier_request"
+	case OFPTBarrierReply:
+		return "barrier_reply"
+	case OFPTQueueGetConfigRequest:
+		return "queue_get_config_request"
+	case OFPTQueueGetConfigReply:
+		return "queue_get_config_reply"
+	default:
+		return fmt.Sprintf("%d", self)
+	}
+}
diff --git a/of10/message.go b/of10/message.go
new file mode 100644
index 0000000..422a722
--- /dev/null
+++ b/of10/message.go
@@ -0,0 +1,5834 @@
+/*
+ * Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
+ * Copyright (c) 2011, 2012 Open Networking Foundation
+ * Copyright 2013, Big Switch Networks, Inc. This library was generated by the LoxiGen Compiler.
+ * Copyright 2018, Red Hat, Inc.
+ */
+// Automatically generated by LOXI from template module.go
+// Do not modify
+
+package of10
+
+import (
+	"bytes"
+	"encoding/binary"
+	"fmt"
+	"net"
+
+	"github.com/opencord/goloxi"
+)
+
+type Header struct {
+	Version uint8
+	Type    uint8
+	Length  uint16
+	Xid     uint32
+}
+
+type IHeader interface {
+	goloxi.Serializable
+	GetVersion() uint8
+	GetType() uint8
+	GetLength() uint16
+	GetXid() uint32
+}
+
+func (self *Header) GetVersion() uint8 {
+	return self.Version
+}
+
+func (self *Header) SetVersion(v uint8) {
+	self.Version = v
+}
+
+func (self *Header) GetType() uint8 {
+	return self.Type
+}
+
+func (self *Header) SetType(v uint8) {
+	self.Type = v
+}
+
+func (self *Header) GetLength() uint16 {
+	return self.Length
+}
+
+func (self *Header) SetLength(v uint16) {
+	self.Length = v
+}
+
+func (self *Header) GetXid() uint32 {
+	return self.Xid
+}
+
+func (self *Header) SetXid(v uint32) {
+	self.Xid = v
+}
+
+func (self *Header) Serialize(encoder *goloxi.Encoder) error {
+
+	encoder.PutUint8(uint8(1))
+	encoder.PutUint8(uint8(self.Type))
+	encoder.PutUint16(uint16(self.Length))
+	encoder.PutUint32(uint32(self.Xid))
+
+	return nil
+}
+func (self *Header) Decode(decoder *goloxi.Decoder) error {
+	if decoder.Length() < 8 {
+		return fmt.Errorf("Header packet too short: %d < 8", decoder.Length())
+	}
+
+	self.Version = uint8(decoder.ReadByte())
+	self.Type = uint8(decoder.ReadByte())
+	self.Length = uint16(decoder.ReadUint16())
+	oldDecoder := decoder
+	defer func() { decoder = oldDecoder }()
+	decoder = decoder.SliceDecoder(int(self.Length), 2+2)
+	self.Xid = uint32(decoder.ReadUint32())
+
+	return nil
+}
+func DecodeHeader(decoder *goloxi.Decoder) (IHeader, error) {
+	_header := &Header{}
+	if decoder.Length() < 8 {
+		return nil, fmt.Errorf("Header packet too short: %d < 8", decoder.Length())
+	}
+	_header.Version = uint8(decoder.ReadByte())
+	_header.Type = uint8(decoder.ReadByte())
+	_header.Length = uint16(decoder.ReadUint16())
+	oldDecoder := decoder
+	defer func() { decoder = oldDecoder }()
+	decoder = decoder.SliceDecoder(int(_header.Length), 2+2)
+	_header.Xid = uint32(decoder.ReadUint32())
+
+	switch _header.Type {
+	case 0:
+		return DecodeHello(_header, decoder)
+	case 1:
+		return DecodeErrorMsg(_header, decoder)
+	case 2:
+		return DecodeEchoRequest(_header, decoder)
+	case 3:
+		return DecodeEchoReply(_header, decoder)
+	case 4:
+		return DecodeExperimenter(_header, decoder)
+	case 5:
+		return DecodeFeaturesRequest(_header, decoder)
+	case 6:
+		return DecodeFeaturesReply(_header, decoder)
+	case 7:
+		return DecodeGetConfigRequest(_header, decoder)
+	case 8:
+		return DecodeGetConfigReply(_header, decoder)
+	case 9:
+		return DecodeSetConfig(_header, decoder)
+	case 10:
+		return DecodePacketIn(_header, decoder)
+	case 11:
+		return DecodeFlowRemoved(_header, decoder)
+	case 12:
+		return DecodePortStatus(_header, decoder)
+	case 13:
+		return DecodePacketOut(_header, decoder)
+	case 14:
+		return DecodeFlowMod(_header, decoder)
+	case 15:
+		return DecodePortMod(_header, decoder)
+	case 16:
+		return DecodeStatsRequest(_header, decoder)
+	case 17:
+		return DecodeStatsReply(_header, decoder)
+	case 18:
+		return DecodeBarrierRequest(_header, decoder)
+	case 19:
+		return DecodeBarrierReply(_header, decoder)
+	case 20:
+		return DecodeQueueGetConfigRequest(_header, decoder)
+	case 21:
+		return DecodeQueueGetConfigReply(_header, decoder)
+	case 22:
+		return DecodeTableMod(_header, decoder)
+	default:
+		return nil, fmt.Errorf("Invalid type '%d' for 'Header'", _header.Type)
+	}
+}
+
+func NewHeader(_type uint8) *Header {
+	obj := &Header{}
+	obj.Type = _type
+	return obj
+}
+
+type StatsReply struct {
+	*Header
+	StatsType uint16
+	Flags     StatsReplyFlags
+}
+
+type IStatsReply interface {
+	IHeader
+	GetStatsType() uint16
+	GetFlags() StatsReplyFlags
+}
+
+func (self *StatsReply) GetStatsType() uint16 {
+	return self.StatsType
+}
+
+func (self *StatsReply) SetStatsType(v uint16) {
+	self.StatsType = v
+}
+
+func (self *StatsReply) GetFlags() StatsReplyFlags {
+	return self.Flags
+}
+
+func (self *StatsReply) SetFlags(v StatsReplyFlags) {
+	self.Flags = v
+}
+
+func (self *StatsReply) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Header.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.StatsType))
+	encoder.PutUint16(uint16(self.Flags))
+
+	return nil
+}
+
+func DecodeStatsReply(parent *Header, decoder *goloxi.Decoder) (IStatsReply, error) {
+	_statsreply := &StatsReply{Header: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("StatsReply packet too short: %d < 4", decoder.Length())
+	}
+	_statsreply.StatsType = uint16(decoder.ReadUint16())
+	_statsreply.Flags = StatsReplyFlags(decoder.ReadUint16())
+
+	switch _statsreply.StatsType {
+	case 0:
+		return DecodeDescStatsReply(_statsreply, decoder)
+	case 1:
+		return DecodeFlowStatsReply(_statsreply, decoder)
+	case 2:
+		return DecodeAggregateStatsReply(_statsreply, decoder)
+	case 3:
+		return DecodeTableStatsReply(_statsreply, decoder)
+	case 4:
+		return DecodePortStatsReply(_statsreply, decoder)
+	case 5:
+		return DecodeQueueStatsReply(_statsreply, decoder)
+	case 65535:
+		return DecodeExperimenterStatsReply(_statsreply, decoder)
+	default:
+		return nil, fmt.Errorf("Invalid type '%d' for 'StatsReply'", _statsreply.StatsType)
+	}
+}
+
+func NewStatsReply(_stats_type uint16) *StatsReply {
+	obj := &StatsReply{
+		Header: NewHeader(17),
+	}
+	obj.StatsType = _stats_type
+	return obj
+}
+
+type AggregateStatsReply struct {
+	*StatsReply
+	PacketCount uint64
+	ByteCount   uint64
+	FlowCount   uint32
+}
+
+type IAggregateStatsReply interface {
+	IStatsReply
+	GetPacketCount() uint64
+	GetByteCount() uint64
+	GetFlowCount() uint32
+}
+
+func (self *AggregateStatsReply) GetPacketCount() uint64 {
+	return self.PacketCount
+}
+
+func (self *AggregateStatsReply) SetPacketCount(v uint64) {
+	self.PacketCount = v
+}
+
+func (self *AggregateStatsReply) GetByteCount() uint64 {
+	return self.ByteCount
+}
+
+func (self *AggregateStatsReply) SetByteCount(v uint64) {
+	self.ByteCount = v
+}
+
+func (self *AggregateStatsReply) GetFlowCount() uint32 {
+	return self.FlowCount
+}
+
+func (self *AggregateStatsReply) SetFlowCount(v uint32) {
+	self.FlowCount = v
+}
+
+func (self *AggregateStatsReply) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.StatsReply.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint64(uint64(self.PacketCount))
+	encoder.PutUint64(uint64(self.ByteCount))
+	encoder.PutUint32(uint32(self.FlowCount))
+	encoder.Write(bytes.Repeat([]byte{0}, 4))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeAggregateStatsReply(parent *StatsReply, decoder *goloxi.Decoder) (*AggregateStatsReply, error) {
+	_aggregatestatsreply := &AggregateStatsReply{StatsReply: parent}
+	if decoder.Length() < 24 {
+		return nil, fmt.Errorf("AggregateStatsReply packet too short: %d < 24", decoder.Length())
+	}
+	_aggregatestatsreply.PacketCount = uint64(decoder.ReadUint64())
+	_aggregatestatsreply.ByteCount = uint64(decoder.ReadUint64())
+	_aggregatestatsreply.FlowCount = uint32(decoder.ReadUint32())
+	decoder.Skip(4)
+	return _aggregatestatsreply, nil
+}
+
+func NewAggregateStatsReply() *AggregateStatsReply {
+	obj := &AggregateStatsReply{
+		StatsReply: NewStatsReply(2),
+	}
+	return obj
+}
+
+type StatsRequest struct {
+	*Header
+	StatsType uint16
+	Flags     StatsRequestFlags
+}
+
+type IStatsRequest interface {
+	IHeader
+	GetStatsType() uint16
+	GetFlags() StatsRequestFlags
+}
+
+func (self *StatsRequest) GetStatsType() uint16 {
+	return self.StatsType
+}
+
+func (self *StatsRequest) SetStatsType(v uint16) {
+	self.StatsType = v
+}
+
+func (self *StatsRequest) GetFlags() StatsRequestFlags {
+	return self.Flags
+}
+
+func (self *StatsRequest) SetFlags(v StatsRequestFlags) {
+	self.Flags = v
+}
+
+func (self *StatsRequest) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Header.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.StatsType))
+	encoder.PutUint16(uint16(self.Flags))
+
+	return nil
+}
+
+func DecodeStatsRequest(parent *Header, decoder *goloxi.Decoder) (IStatsRequest, error) {
+	_statsrequest := &StatsRequest{Header: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("StatsRequest packet too short: %d < 4", decoder.Length())
+	}
+	_statsrequest.StatsType = uint16(decoder.ReadUint16())
+	_statsrequest.Flags = StatsRequestFlags(decoder.ReadUint16())
+
+	switch _statsrequest.StatsType {
+	case 0:
+		return DecodeDescStatsRequest(_statsrequest, decoder)
+	case 1:
+		return DecodeFlowStatsRequest(_statsrequest, decoder)
+	case 2:
+		return DecodeAggregateStatsRequest(_statsrequest, decoder)
+	case 3:
+		return DecodeTableStatsRequest(_statsrequest, decoder)
+	case 4:
+		return DecodePortStatsRequest(_statsrequest, decoder)
+	case 5:
+		return DecodeQueueStatsRequest(_statsrequest, decoder)
+	case 65535:
+		return DecodeExperimenterStatsRequest(_statsrequest, decoder)
+	default:
+		return nil, fmt.Errorf("Invalid type '%d' for 'StatsRequest'", _statsrequest.StatsType)
+	}
+}
+
+func NewStatsRequest(_stats_type uint16) *StatsRequest {
+	obj := &StatsRequest{
+		Header: NewHeader(16),
+	}
+	obj.StatsType = _stats_type
+	return obj
+}
+
+type AggregateStatsRequest struct {
+	*StatsRequest
+	Match   Match
+	TableId uint8
+	OutPort Port
+}
+
+type IAggregateStatsRequest interface {
+	IStatsRequest
+	GetMatch() Match
+	GetTableId() uint8
+	GetOutPort() Port
+}
+
+func (self *AggregateStatsRequest) GetMatch() Match {
+	return self.Match
+}
+
+func (self *AggregateStatsRequest) SetMatch(v Match) {
+	self.Match = v
+}
+
+func (self *AggregateStatsRequest) GetTableId() uint8 {
+	return self.TableId
+}
+
+func (self *AggregateStatsRequest) SetTableId(v uint8) {
+	self.TableId = v
+}
+
+func (self *AggregateStatsRequest) GetOutPort() Port {
+	return self.OutPort
+}
+
+func (self *AggregateStatsRequest) SetOutPort(v Port) {
+	self.OutPort = v
+}
+
+func (self *AggregateStatsRequest) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.StatsRequest.Serialize(encoder); err != nil {
+		return err
+	}
+
+	if err := self.Match.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint8(uint8(self.TableId))
+	encoder.Write(bytes.Repeat([]byte{0}, 1))
+	self.OutPort.Serialize(encoder)
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeAggregateStatsRequest(parent *StatsRequest, decoder *goloxi.Decoder) (*AggregateStatsRequest, error) {
+	_aggregatestatsrequest := &AggregateStatsRequest{StatsRequest: parent}
+	if decoder.Length() < 44 {
+		return nil, fmt.Errorf("AggregateStatsRequest packet too short: %d < 44", decoder.Length())
+	}
+	if err := _aggregatestatsrequest.Match.Decode(decoder); err != nil {
+		return nil, err
+	}
+
+	_aggregatestatsrequest.TableId = uint8(decoder.ReadByte())
+	decoder.Skip(1)
+	_aggregatestatsrequest.OutPort.Decode(decoder)
+	return _aggregatestatsrequest, nil
+}
+
+func NewAggregateStatsRequest() *AggregateStatsRequest {
+	obj := &AggregateStatsRequest{
+		StatsRequest: NewStatsRequest(2),
+	}
+	return obj
+}
+
+type ErrorMsg struct {
+	*Header
+	ErrType uint16
+}
+
+type IErrorMsg interface {
+	IHeader
+	GetErrType() uint16
+}
+
+func (self *ErrorMsg) GetErrType() uint16 {
+	return self.ErrType
+}
+
+func (self *ErrorMsg) SetErrType(v uint16) {
+	self.ErrType = v
+}
+
+func (self *ErrorMsg) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Header.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.ErrType))
+
+	return nil
+}
+
+func DecodeErrorMsg(parent *Header, decoder *goloxi.Decoder) (IErrorMsg, error) {
+	_errormsg := &ErrorMsg{Header: parent}
+	if decoder.Length() < 2 {
+		return nil, fmt.Errorf("ErrorMsg packet too short: %d < 2", decoder.Length())
+	}
+	_errormsg.ErrType = uint16(decoder.ReadUint16())
+
+	switch _errormsg.ErrType {
+	case 0:
+		return DecodeHelloFailedErrorMsg(_errormsg, decoder)
+	case 1:
+		return DecodeBadRequestErrorMsg(_errormsg, decoder)
+	case 2:
+		return DecodeBadActionErrorMsg(_errormsg, decoder)
+	case 3:
+		return DecodeFlowModFailedErrorMsg(_errormsg, decoder)
+	case 4:
+		return DecodePortModFailedErrorMsg(_errormsg, decoder)
+	case 5:
+		return DecodeQueueOpFailedErrorMsg(_errormsg, decoder)
+	default:
+		return nil, fmt.Errorf("Invalid type '%d' for 'ErrorMsg'", _errormsg.ErrType)
+	}
+}
+
+func NewErrorMsg(_err_type uint16) *ErrorMsg {
+	obj := &ErrorMsg{
+		Header: NewHeader(1),
+	}
+	obj.ErrType = _err_type
+	return obj
+}
+
+type BadActionErrorMsg struct {
+	*ErrorMsg
+	Code BadActionCode
+	Data []byte
+}
+
+type IBadActionErrorMsg interface {
+	IErrorMsg
+	GetCode() BadActionCode
+	GetData() []byte
+}
+
+func (self *BadActionErrorMsg) GetCode() BadActionCode {
+	return self.Code
+}
+
+func (self *BadActionErrorMsg) SetCode(v BadActionCode) {
+	self.Code = v
+}
+
+func (self *BadActionErrorMsg) GetData() []byte {
+	return self.Data
+}
+
+func (self *BadActionErrorMsg) SetData(v []byte) {
+	self.Data = v
+}
+
+func (self *BadActionErrorMsg) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ErrorMsg.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Code))
+	encoder.Write(self.Data)
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeBadActionErrorMsg(parent *ErrorMsg, decoder *goloxi.Decoder) (*BadActionErrorMsg, error) {
+	_badactionerrormsg := &BadActionErrorMsg{ErrorMsg: parent}
+	if decoder.Length() < 2 {
+		return nil, fmt.Errorf("BadActionErrorMsg packet too short: %d < 2", decoder.Length())
+	}
+	_badactionerrormsg.Code = BadActionCode(decoder.ReadUint16())
+	_badactionerrormsg.Data = decoder.Read(int(decoder.Length()))
+	return _badactionerrormsg, nil
+}
+
+func NewBadActionErrorMsg() *BadActionErrorMsg {
+	obj := &BadActionErrorMsg{
+		ErrorMsg: NewErrorMsg(2),
+	}
+	return obj
+}
+
+type BadRequestErrorMsg struct {
+	*ErrorMsg
+	Code BadRequestCode
+	Data []byte
+}
+
+type IBadRequestErrorMsg interface {
+	IErrorMsg
+	GetCode() BadRequestCode
+	GetData() []byte
+}
+
+func (self *BadRequestErrorMsg) GetCode() BadRequestCode {
+	return self.Code
+}
+
+func (self *BadRequestErrorMsg) SetCode(v BadRequestCode) {
+	self.Code = v
+}
+
+func (self *BadRequestErrorMsg) GetData() []byte {
+	return self.Data
+}
+
+func (self *BadRequestErrorMsg) SetData(v []byte) {
+	self.Data = v
+}
+
+func (self *BadRequestErrorMsg) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ErrorMsg.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Code))
+	encoder.Write(self.Data)
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeBadRequestErrorMsg(parent *ErrorMsg, decoder *goloxi.Decoder) (*BadRequestErrorMsg, error) {
+	_badrequesterrormsg := &BadRequestErrorMsg{ErrorMsg: parent}
+	if decoder.Length() < 2 {
+		return nil, fmt.Errorf("BadRequestErrorMsg packet too short: %d < 2", decoder.Length())
+	}
+	_badrequesterrormsg.Code = BadRequestCode(decoder.ReadUint16())
+	_badrequesterrormsg.Data = decoder.Read(int(decoder.Length()))
+	return _badrequesterrormsg, nil
+}
+
+func NewBadRequestErrorMsg() *BadRequestErrorMsg {
+	obj := &BadRequestErrorMsg{
+		ErrorMsg: NewErrorMsg(1),
+	}
+	return obj
+}
+
+type BarrierReply struct {
+	*Header
+}
+
+type IBarrierReply interface {
+	IHeader
+}
+
+func (self *BarrierReply) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.Header.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeBarrierReply(parent *Header, decoder *goloxi.Decoder) (*BarrierReply, error) {
+	_barrierreply := &BarrierReply{Header: parent}
+	return _barrierreply, nil
+}
+
+func NewBarrierReply() *BarrierReply {
+	obj := &BarrierReply{
+		Header: NewHeader(19),
+	}
+	return obj
+}
+
+type BarrierRequest struct {
+	*Header
+}
+
+type IBarrierRequest interface {
+	IHeader
+}
+
+func (self *BarrierRequest) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.Header.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeBarrierRequest(parent *Header, decoder *goloxi.Decoder) (*BarrierRequest, error) {
+	_barrierrequest := &BarrierRequest{Header: parent}
+	return _barrierrequest, nil
+}
+
+func NewBarrierRequest() *BarrierRequest {
+	obj := &BarrierRequest{
+		Header: NewHeader(18),
+	}
+	return obj
+}
+
+type Experimenter struct {
+	*Header
+	Experimenter uint32
+}
+
+type IExperimenter interface {
+	IHeader
+	GetExperimenter() uint32
+}
+
+func (self *Experimenter) GetExperimenter() uint32 {
+	return self.Experimenter
+}
+
+func (self *Experimenter) SetExperimenter(v uint32) {
+	self.Experimenter = v
+}
+
+func (self *Experimenter) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Header.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Experimenter))
+
+	return nil
+}
+
+func DecodeExperimenter(parent *Header, decoder *goloxi.Decoder) (IExperimenter, error) {
+	_experimenter := &Experimenter{Header: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("Experimenter packet too short: %d < 4", decoder.Length())
+	}
+	_experimenter.Experimenter = uint32(decoder.ReadUint32())
+
+	switch _experimenter.Experimenter {
+	case 8992:
+		return DecodeNiciraHeader(_experimenter, decoder)
+	case 6035143:
+		return DecodeBsnHeader(_experimenter, decoder)
+	default:
+		return nil, fmt.Errorf("Invalid type '%d' for 'Experimenter'", _experimenter.Experimenter)
+	}
+}
+
+func NewExperimenter(_experimenter uint32) *Experimenter {
+	obj := &Experimenter{
+		Header: NewHeader(4),
+	}
+	obj.Experimenter = _experimenter
+	return obj
+}
+
+type BsnHeader struct {
+	*Experimenter
+	Subtype uint32
+}
+
+type IBsnHeader interface {
+	IExperimenter
+	GetSubtype() uint32
+}
+
+func (self *BsnHeader) GetSubtype() uint32 {
+	return self.Subtype
+}
+
+func (self *BsnHeader) SetSubtype(v uint32) {
+	self.Subtype = v
+}
+
+func (self *BsnHeader) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Experimenter.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Subtype))
+
+	return nil
+}
+
+func DecodeBsnHeader(parent *Experimenter, decoder *goloxi.Decoder) (IBsnHeader, error) {
+	_bsnheader := &BsnHeader{Experimenter: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("BsnHeader packet too short: %d < 4", decoder.Length())
+	}
+	_bsnheader.Subtype = uint32(decoder.ReadUint32())
+
+	switch _bsnheader.Subtype {
+	case 0:
+		return DecodeBsnSetIpMask(_bsnheader, decoder)
+	case 1:
+		return DecodeBsnGetIpMaskRequest(_bsnheader, decoder)
+	case 2:
+		return DecodeBsnGetIpMaskReply(_bsnheader, decoder)
+	case 3:
+		return DecodeBsnSetMirroring(_bsnheader, decoder)
+	case 4:
+		return DecodeBsnGetMirroringRequest(_bsnheader, decoder)
+	case 5:
+		return DecodeBsnGetMirroringReply(_bsnheader, decoder)
+	case 6:
+		return DecodeBsnShellCommand(_bsnheader, decoder)
+	case 7:
+		return DecodeBsnShellOutput(_bsnheader, decoder)
+	case 8:
+		return DecodeBsnShellStatus(_bsnheader, decoder)
+	case 9:
+		return DecodeBsnGetInterfacesRequest(_bsnheader, decoder)
+	case 10:
+		return DecodeBsnGetInterfacesReply(_bsnheader, decoder)
+	case 11:
+		return DecodeBsnSetPktinSuppressionRequest(_bsnheader, decoder)
+	case 12:
+		return DecodeBsnSetL2TableRequest(_bsnheader, decoder)
+	case 13:
+		return DecodeBsnGetL2TableRequest(_bsnheader, decoder)
+	case 14:
+		return DecodeBsnGetL2TableReply(_bsnheader, decoder)
+	case 15:
+		return DecodeBsnVirtualPortCreateRequest(_bsnheader, decoder)
+	case 16:
+		return DecodeBsnVirtualPortCreateReply(_bsnheader, decoder)
+	case 17:
+		return DecodeBsnVirtualPortRemoveRequest(_bsnheader, decoder)
+	case 18:
+		return DecodeBsnBwEnableSetRequest(_bsnheader, decoder)
+	case 19:
+		return DecodeBsnBwEnableGetRequest(_bsnheader, decoder)
+	case 20:
+		return DecodeBsnBwEnableGetReply(_bsnheader, decoder)
+	case 21:
+		return DecodeBsnBwClearDataRequest(_bsnheader, decoder)
+	case 22:
+		return DecodeBsnBwClearDataReply(_bsnheader, decoder)
+	case 23:
+		return DecodeBsnBwEnableSetReply(_bsnheader, decoder)
+	case 24:
+		return DecodeBsnSetL2TableReply(_bsnheader, decoder)
+	case 25:
+		return DecodeBsnSetPktinSuppressionReply(_bsnheader, decoder)
+	case 26:
+		return DecodeBsnVirtualPortRemoveReply(_bsnheader, decoder)
+	case 27:
+		return DecodeBsnHybridGetRequest(_bsnheader, decoder)
+	case 28:
+		return DecodeBsnHybridGetReply(_bsnheader, decoder)
+	case 31:
+		return DecodeBsnPduTxRequest(_bsnheader, decoder)
+	case 32:
+		return DecodeBsnPduTxReply(_bsnheader, decoder)
+	case 33:
+		return DecodeBsnPduRxRequest(_bsnheader, decoder)
+	case 34:
+		return DecodeBsnPduRxReply(_bsnheader, decoder)
+	case 35:
+		return DecodeBsnPduRxTimeout(_bsnheader, decoder)
+	default:
+		return nil, fmt.Errorf("Invalid type '%d' for 'BsnHeader'", _bsnheader.Subtype)
+	}
+}
+
+func NewBsnHeader(_subtype uint32) *BsnHeader {
+	obj := &BsnHeader{
+		Experimenter: NewExperimenter(6035143),
+	}
+	obj.Subtype = _subtype
+	return obj
+}
+
+type BsnBwClearDataReply struct {
+	*BsnHeader
+	Status uint32
+}
+
+type IBsnBwClearDataReply interface {
+	IBsnHeader
+	GetStatus() uint32
+}
+
+func (self *BsnBwClearDataReply) GetStatus() uint32 {
+	return self.Status
+}
+
+func (self *BsnBwClearDataReply) SetStatus(v uint32) {
+	self.Status = v
+}
+
+func (self *BsnBwClearDataReply) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.BsnHeader.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Status))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeBsnBwClearDataReply(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnBwClearDataReply, error) {
+	_bsnbwcleardatareply := &BsnBwClearDataReply{BsnHeader: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("BsnBwClearDataReply packet too short: %d < 4", decoder.Length())
+	}
+	_bsnbwcleardatareply.Status = uint32(decoder.ReadUint32())
+	return _bsnbwcleardatareply, nil
+}
+
+func NewBsnBwClearDataReply() *BsnBwClearDataReply {
+	obj := &BsnBwClearDataReply{
+		BsnHeader: NewBsnHeader(22),
+	}
+	return obj
+}
+
+type BsnBwClearDataRequest struct {
+	*BsnHeader
+}
+
+type IBsnBwClearDataRequest interface {
+	IBsnHeader
+}
+
+func (self *BsnBwClearDataRequest) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.BsnHeader.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeBsnBwClearDataRequest(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnBwClearDataRequest, error) {
+	_bsnbwcleardatarequest := &BsnBwClearDataRequest{BsnHeader: parent}
+	return _bsnbwcleardatarequest, nil
+}
+
+func NewBsnBwClearDataRequest() *BsnBwClearDataRequest {
+	obj := &BsnBwClearDataRequest{
+		BsnHeader: NewBsnHeader(21),
+	}
+	return obj
+}
+
+type BsnBwEnableGetReply struct {
+	*BsnHeader
+	Enabled uint32
+}
+
+type IBsnBwEnableGetReply interface {
+	IBsnHeader
+	GetEnabled() uint32
+}
+
+func (self *BsnBwEnableGetReply) GetEnabled() uint32 {
+	return self.Enabled
+}
+
+func (self *BsnBwEnableGetReply) SetEnabled(v uint32) {
+	self.Enabled = v
+}
+
+func (self *BsnBwEnableGetReply) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.BsnHeader.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Enabled))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeBsnBwEnableGetReply(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnBwEnableGetReply, error) {
+	_bsnbwenablegetreply := &BsnBwEnableGetReply{BsnHeader: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("BsnBwEnableGetReply packet too short: %d < 4", decoder.Length())
+	}
+	_bsnbwenablegetreply.Enabled = uint32(decoder.ReadUint32())
+	return _bsnbwenablegetreply, nil
+}
+
+func NewBsnBwEnableGetReply() *BsnBwEnableGetReply {
+	obj := &BsnBwEnableGetReply{
+		BsnHeader: NewBsnHeader(20),
+	}
+	return obj
+}
+
+type BsnBwEnableGetRequest struct {
+	*BsnHeader
+}
+
+type IBsnBwEnableGetRequest interface {
+	IBsnHeader
+}
+
+func (self *BsnBwEnableGetRequest) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.BsnHeader.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeBsnBwEnableGetRequest(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnBwEnableGetRequest, error) {
+	_bsnbwenablegetrequest := &BsnBwEnableGetRequest{BsnHeader: parent}
+	return _bsnbwenablegetrequest, nil
+}
+
+func NewBsnBwEnableGetRequest() *BsnBwEnableGetRequest {
+	obj := &BsnBwEnableGetRequest{
+		BsnHeader: NewBsnHeader(19),
+	}
+	return obj
+}
+
+type BsnBwEnableSetReply struct {
+	*BsnHeader
+	Enable uint32
+	Status uint32
+}
+
+type IBsnBwEnableSetReply interface {
+	IBsnHeader
+	GetEnable() uint32
+	GetStatus() uint32
+}
+
+func (self *BsnBwEnableSetReply) GetEnable() uint32 {
+	return self.Enable
+}
+
+func (self *BsnBwEnableSetReply) SetEnable(v uint32) {
+	self.Enable = v
+}
+
+func (self *BsnBwEnableSetReply) GetStatus() uint32 {
+	return self.Status
+}
+
+func (self *BsnBwEnableSetReply) SetStatus(v uint32) {
+	self.Status = v
+}
+
+func (self *BsnBwEnableSetReply) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.BsnHeader.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Enable))
+	encoder.PutUint32(uint32(self.Status))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeBsnBwEnableSetReply(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnBwEnableSetReply, error) {
+	_bsnbwenablesetreply := &BsnBwEnableSetReply{BsnHeader: parent}
+	if decoder.Length() < 8 {
+		return nil, fmt.Errorf("BsnBwEnableSetReply packet too short: %d < 8", decoder.Length())
+	}
+	_bsnbwenablesetreply.Enable = uint32(decoder.ReadUint32())
+	_bsnbwenablesetreply.Status = uint32(decoder.ReadUint32())
+	return _bsnbwenablesetreply, nil
+}
+
+func NewBsnBwEnableSetReply() *BsnBwEnableSetReply {
+	obj := &BsnBwEnableSetReply{
+		BsnHeader: NewBsnHeader(23),
+	}
+	return obj
+}
+
+type BsnBwEnableSetRequest struct {
+	*BsnHeader
+	Enable uint32
+}
+
+type IBsnBwEnableSetRequest interface {
+	IBsnHeader
+	GetEnable() uint32
+}
+
+func (self *BsnBwEnableSetRequest) GetEnable() uint32 {
+	return self.Enable
+}
+
+func (self *BsnBwEnableSetRequest) SetEnable(v uint32) {
+	self.Enable = v
+}
+
+func (self *BsnBwEnableSetRequest) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.BsnHeader.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Enable))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeBsnBwEnableSetRequest(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnBwEnableSetRequest, error) {
+	_bsnbwenablesetrequest := &BsnBwEnableSetRequest{BsnHeader: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("BsnBwEnableSetRequest packet too short: %d < 4", decoder.Length())
+	}
+	_bsnbwenablesetrequest.Enable = uint32(decoder.ReadUint32())
+	return _bsnbwenablesetrequest, nil
+}
+
+func NewBsnBwEnableSetRequest() *BsnBwEnableSetRequest {
+	obj := &BsnBwEnableSetRequest{
+		BsnHeader: NewBsnHeader(18),
+	}
+	return obj
+}
+
+type BsnGetInterfacesReply struct {
+	*BsnHeader
+	Interfaces []*BsnInterface
+}
+
+type IBsnGetInterfacesReply interface {
+	IBsnHeader
+	GetInterfaces() []*BsnInterface
+}
+
+func (self *BsnGetInterfacesReply) GetInterfaces() []*BsnInterface {
+	return self.Interfaces
+}
+
+func (self *BsnGetInterfacesReply) SetInterfaces(v []*BsnInterface) {
+	self.Interfaces = v
+}
+
+func (self *BsnGetInterfacesReply) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.BsnHeader.Serialize(encoder); err != nil {
+		return err
+	}
+
+	for _, obj := range self.Interfaces {
+		if err := obj.Serialize(encoder); err != nil {
+			return err
+		}
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeBsnGetInterfacesReply(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnGetInterfacesReply, error) {
+	_bsngetinterfacesreply := &BsnGetInterfacesReply{BsnHeader: parent}
+
+	for decoder.Length() >= 32 {
+		item, err := DecodeBsnInterface(decoder)
+		if err != nil {
+			return nil, err
+		}
+		if item != nil {
+			_bsngetinterfacesreply.Interfaces = append(_bsngetinterfacesreply.Interfaces, item)
+		}
+	}
+	return _bsngetinterfacesreply, nil
+}
+
+func NewBsnGetInterfacesReply() *BsnGetInterfacesReply {
+	obj := &BsnGetInterfacesReply{
+		BsnHeader: NewBsnHeader(10),
+	}
+	return obj
+}
+
+type BsnGetInterfacesRequest struct {
+	*BsnHeader
+}
+
+type IBsnGetInterfacesRequest interface {
+	IBsnHeader
+}
+
+func (self *BsnGetInterfacesRequest) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.BsnHeader.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeBsnGetInterfacesRequest(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnGetInterfacesRequest, error) {
+	_bsngetinterfacesrequest := &BsnGetInterfacesRequest{BsnHeader: parent}
+	return _bsngetinterfacesrequest, nil
+}
+
+func NewBsnGetInterfacesRequest() *BsnGetInterfacesRequest {
+	obj := &BsnGetInterfacesRequest{
+		BsnHeader: NewBsnHeader(9),
+	}
+	return obj
+}
+
+type BsnGetIpMaskReply struct {
+	*BsnHeader
+	Index uint8
+	Mask  uint32
+}
+
+type IBsnGetIpMaskReply interface {
+	IBsnHeader
+	GetIndex() uint8
+	GetMask() uint32
+}
+
+func (self *BsnGetIpMaskReply) GetIndex() uint8 {
+	return self.Index
+}
+
+func (self *BsnGetIpMaskReply) SetIndex(v uint8) {
+	self.Index = v
+}
+
+func (self *BsnGetIpMaskReply) GetMask() uint32 {
+	return self.Mask
+}
+
+func (self *BsnGetIpMaskReply) SetMask(v uint32) {
+	self.Mask = v
+}
+
+func (self *BsnGetIpMaskReply) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.BsnHeader.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint8(uint8(self.Index))
+	encoder.Write(bytes.Repeat([]byte{0}, 3))
+	encoder.PutUint32(uint32(self.Mask))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeBsnGetIpMaskReply(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnGetIpMaskReply, error) {
+	_bsngetipmaskreply := &BsnGetIpMaskReply{BsnHeader: parent}
+	if decoder.Length() < 8 {
+		return nil, fmt.Errorf("BsnGetIpMaskReply packet too short: %d < 8", decoder.Length())
+	}
+	_bsngetipmaskreply.Index = uint8(decoder.ReadByte())
+	decoder.Skip(3)
+	_bsngetipmaskreply.Mask = uint32(decoder.ReadUint32())
+	return _bsngetipmaskreply, nil
+}
+
+func NewBsnGetIpMaskReply() *BsnGetIpMaskReply {
+	obj := &BsnGetIpMaskReply{
+		BsnHeader: NewBsnHeader(2),
+	}
+	return obj
+}
+
+type BsnGetIpMaskRequest struct {
+	*BsnHeader
+	Index uint8
+}
+
+type IBsnGetIpMaskRequest interface {
+	IBsnHeader
+	GetIndex() uint8
+}
+
+func (self *BsnGetIpMaskRequest) GetIndex() uint8 {
+	return self.Index
+}
+
+func (self *BsnGetIpMaskRequest) SetIndex(v uint8) {
+	self.Index = v
+}
+
+func (self *BsnGetIpMaskRequest) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.BsnHeader.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint8(uint8(self.Index))
+	encoder.Write(bytes.Repeat([]byte{0}, 7))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeBsnGetIpMaskRequest(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnGetIpMaskRequest, error) {
+	_bsngetipmaskrequest := &BsnGetIpMaskRequest{BsnHeader: parent}
+	if decoder.Length() < 8 {
+		return nil, fmt.Errorf("BsnGetIpMaskRequest packet too short: %d < 8", decoder.Length())
+	}
+	_bsngetipmaskrequest.Index = uint8(decoder.ReadByte())
+	decoder.Skip(7)
+	return _bsngetipmaskrequest, nil
+}
+
+func NewBsnGetIpMaskRequest() *BsnGetIpMaskRequest {
+	obj := &BsnGetIpMaskRequest{
+		BsnHeader: NewBsnHeader(1),
+	}
+	return obj
+}
+
+type BsnGetL2TableReply struct {
+	*BsnHeader
+	L2TableEnable   uint8
+	L2TablePriority uint16
+}
+
+type IBsnGetL2TableReply interface {
+	IBsnHeader
+	GetL2TableEnable() uint8
+	GetL2TablePriority() uint16
+}
+
+func (self *BsnGetL2TableReply) GetL2TableEnable() uint8 {
+	return self.L2TableEnable
+}
+
+func (self *BsnGetL2TableReply) SetL2TableEnable(v uint8) {
+	self.L2TableEnable = v
+}
+
+func (self *BsnGetL2TableReply) GetL2TablePriority() uint16 {
+	return self.L2TablePriority
+}
+
+func (self *BsnGetL2TableReply) SetL2TablePriority(v uint16) {
+	self.L2TablePriority = v
+}
+
+func (self *BsnGetL2TableReply) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.BsnHeader.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint8(uint8(self.L2TableEnable))
+	encoder.Write(bytes.Repeat([]byte{0}, 1))
+	encoder.PutUint16(uint16(self.L2TablePriority))
+	encoder.Write(bytes.Repeat([]byte{0}, 4))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeBsnGetL2TableReply(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnGetL2TableReply, error) {
+	_bsngetl2tablereply := &BsnGetL2TableReply{BsnHeader: parent}
+	if decoder.Length() < 8 {
+		return nil, fmt.Errorf("BsnGetL2TableReply packet too short: %d < 8", decoder.Length())
+	}
+	_bsngetl2tablereply.L2TableEnable = uint8(decoder.ReadByte())
+	decoder.Skip(1)
+	_bsngetl2tablereply.L2TablePriority = uint16(decoder.ReadUint16())
+	decoder.Skip(4)
+	return _bsngetl2tablereply, nil
+}
+
+func NewBsnGetL2TableReply() *BsnGetL2TableReply {
+	obj := &BsnGetL2TableReply{
+		BsnHeader: NewBsnHeader(14),
+	}
+	return obj
+}
+
+type BsnGetL2TableRequest struct {
+	*BsnHeader
+}
+
+type IBsnGetL2TableRequest interface {
+	IBsnHeader
+}
+
+func (self *BsnGetL2TableRequest) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.BsnHeader.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeBsnGetL2TableRequest(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnGetL2TableRequest, error) {
+	_bsngetl2tablerequest := &BsnGetL2TableRequest{BsnHeader: parent}
+	return _bsngetl2tablerequest, nil
+}
+
+func NewBsnGetL2TableRequest() *BsnGetL2TableRequest {
+	obj := &BsnGetL2TableRequest{
+		BsnHeader: NewBsnHeader(13),
+	}
+	return obj
+}
+
+type BsnGetMirroringReply struct {
+	*BsnHeader
+	ReportMirrorPorts uint8
+}
+
+type IBsnGetMirroringReply interface {
+	IBsnHeader
+	GetReportMirrorPorts() uint8
+}
+
+func (self *BsnGetMirroringReply) GetReportMirrorPorts() uint8 {
+	return self.ReportMirrorPorts
+}
+
+func (self *BsnGetMirroringReply) SetReportMirrorPorts(v uint8) {
+	self.ReportMirrorPorts = v
+}
+
+func (self *BsnGetMirroringReply) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.BsnHeader.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint8(uint8(self.ReportMirrorPorts))
+	encoder.Write(bytes.Repeat([]byte{0}, 3))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeBsnGetMirroringReply(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnGetMirroringReply, error) {
+	_bsngetmirroringreply := &BsnGetMirroringReply{BsnHeader: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("BsnGetMirroringReply packet too short: %d < 4", decoder.Length())
+	}
+	_bsngetmirroringreply.ReportMirrorPorts = uint8(decoder.ReadByte())
+	decoder.Skip(3)
+	return _bsngetmirroringreply, nil
+}
+
+func NewBsnGetMirroringReply() *BsnGetMirroringReply {
+	obj := &BsnGetMirroringReply{
+		BsnHeader: NewBsnHeader(5),
+	}
+	return obj
+}
+
+type BsnGetMirroringRequest struct {
+	*BsnHeader
+	ReportMirrorPorts uint8
+}
+
+type IBsnGetMirroringRequest interface {
+	IBsnHeader
+	GetReportMirrorPorts() uint8
+}
+
+func (self *BsnGetMirroringRequest) GetReportMirrorPorts() uint8 {
+	return self.ReportMirrorPorts
+}
+
+func (self *BsnGetMirroringRequest) SetReportMirrorPorts(v uint8) {
+	self.ReportMirrorPorts = v
+}
+
+func (self *BsnGetMirroringRequest) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.BsnHeader.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint8(uint8(self.ReportMirrorPorts))
+	encoder.Write(bytes.Repeat([]byte{0}, 3))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeBsnGetMirroringRequest(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnGetMirroringRequest, error) {
+	_bsngetmirroringrequest := &BsnGetMirroringRequest{BsnHeader: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("BsnGetMirroringRequest packet too short: %d < 4", decoder.Length())
+	}
+	_bsngetmirroringrequest.ReportMirrorPorts = uint8(decoder.ReadByte())
+	decoder.Skip(3)
+	return _bsngetmirroringrequest, nil
+}
+
+func NewBsnGetMirroringRequest() *BsnGetMirroringRequest {
+	obj := &BsnGetMirroringRequest{
+		BsnHeader: NewBsnHeader(4),
+	}
+	return obj
+}
+
+type BsnHybridGetReply struct {
+	*BsnHeader
+	HybridEnable  uint8
+	HybridVersion uint16
+}
+
+type IBsnHybridGetReply interface {
+	IBsnHeader
+	GetHybridEnable() uint8
+	GetHybridVersion() uint16
+}
+
+func (self *BsnHybridGetReply) GetHybridEnable() uint8 {
+	return self.HybridEnable
+}
+
+func (self *BsnHybridGetReply) SetHybridEnable(v uint8) {
+	self.HybridEnable = v
+}
+
+func (self *BsnHybridGetReply) GetHybridVersion() uint16 {
+	return self.HybridVersion
+}
+
+func (self *BsnHybridGetReply) SetHybridVersion(v uint16) {
+	self.HybridVersion = v
+}
+
+func (self *BsnHybridGetReply) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.BsnHeader.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint8(uint8(self.HybridEnable))
+	encoder.Write(bytes.Repeat([]byte{0}, 1))
+	encoder.PutUint16(uint16(self.HybridVersion))
+	encoder.Write(bytes.Repeat([]byte{0}, 4))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeBsnHybridGetReply(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnHybridGetReply, error) {
+	_bsnhybridgetreply := &BsnHybridGetReply{BsnHeader: parent}
+	if decoder.Length() < 8 {
+		return nil, fmt.Errorf("BsnHybridGetReply packet too short: %d < 8", decoder.Length())
+	}
+	_bsnhybridgetreply.HybridEnable = uint8(decoder.ReadByte())
+	decoder.Skip(1)
+	_bsnhybridgetreply.HybridVersion = uint16(decoder.ReadUint16())
+	decoder.Skip(4)
+	return _bsnhybridgetreply, nil
+}
+
+func NewBsnHybridGetReply() *BsnHybridGetReply {
+	obj := &BsnHybridGetReply{
+		BsnHeader: NewBsnHeader(28),
+	}
+	return obj
+}
+
+type BsnHybridGetRequest struct {
+	*BsnHeader
+}
+
+type IBsnHybridGetRequest interface {
+	IBsnHeader
+}
+
+func (self *BsnHybridGetRequest) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.BsnHeader.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeBsnHybridGetRequest(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnHybridGetRequest, error) {
+	_bsnhybridgetrequest := &BsnHybridGetRequest{BsnHeader: parent}
+	return _bsnhybridgetrequest, nil
+}
+
+func NewBsnHybridGetRequest() *BsnHybridGetRequest {
+	obj := &BsnHybridGetRequest{
+		BsnHeader: NewBsnHeader(27),
+	}
+	return obj
+}
+
+type BsnPduRxReply struct {
+	*BsnHeader
+	Status  uint32
+	PortNo  Port
+	SlotNum uint8
+}
+
+type IBsnPduRxReply interface {
+	IBsnHeader
+	GetStatus() uint32
+	GetPortNo() Port
+	GetSlotNum() uint8
+}
+
+func (self *BsnPduRxReply) GetStatus() uint32 {
+	return self.Status
+}
+
+func (self *BsnPduRxReply) SetStatus(v uint32) {
+	self.Status = v
+}
+
+func (self *BsnPduRxReply) GetPortNo() Port {
+	return self.PortNo
+}
+
+func (self *BsnPduRxReply) SetPortNo(v Port) {
+	self.PortNo = v
+}
+
+func (self *BsnPduRxReply) GetSlotNum() uint8 {
+	return self.SlotNum
+}
+
+func (self *BsnPduRxReply) SetSlotNum(v uint8) {
+	self.SlotNum = v
+}
+
+func (self *BsnPduRxReply) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.BsnHeader.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Status))
+	self.PortNo.Serialize(encoder)
+	encoder.PutUint8(uint8(self.SlotNum))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeBsnPduRxReply(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnPduRxReply, error) {
+	_bsnpdurxreply := &BsnPduRxReply{BsnHeader: parent}
+	if decoder.Length() < 7 {
+		return nil, fmt.Errorf("BsnPduRxReply packet too short: %d < 7", decoder.Length())
+	}
+	_bsnpdurxreply.Status = uint32(decoder.ReadUint32())
+	_bsnpdurxreply.PortNo.Decode(decoder)
+	_bsnpdurxreply.SlotNum = uint8(decoder.ReadByte())
+	return _bsnpdurxreply, nil
+}
+
+func NewBsnPduRxReply() *BsnPduRxReply {
+	obj := &BsnPduRxReply{
+		BsnHeader: NewBsnHeader(34),
+	}
+	return obj
+}
+
+type BsnPduRxRequest struct {
+	*BsnHeader
+	TimeoutMs uint32
+	PortNo    Port
+	SlotNum   uint8
+	Data      []byte
+}
+
+type IBsnPduRxRequest interface {
+	IBsnHeader
+	GetTimeoutMs() uint32
+	GetPortNo() Port
+	GetSlotNum() uint8
+	GetData() []byte
+}
+
+func (self *BsnPduRxRequest) GetTimeoutMs() uint32 {
+	return self.TimeoutMs
+}
+
+func (self *BsnPduRxRequest) SetTimeoutMs(v uint32) {
+	self.TimeoutMs = v
+}
+
+func (self *BsnPduRxRequest) GetPortNo() Port {
+	return self.PortNo
+}
+
+func (self *BsnPduRxRequest) SetPortNo(v Port) {
+	self.PortNo = v
+}
+
+func (self *BsnPduRxRequest) GetSlotNum() uint8 {
+	return self.SlotNum
+}
+
+func (self *BsnPduRxRequest) SetSlotNum(v uint8) {
+	self.SlotNum = v
+}
+
+func (self *BsnPduRxRequest) GetData() []byte {
+	return self.Data
+}
+
+func (self *BsnPduRxRequest) SetData(v []byte) {
+	self.Data = v
+}
+
+func (self *BsnPduRxRequest) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.BsnHeader.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.TimeoutMs))
+	self.PortNo.Serialize(encoder)
+	encoder.PutUint8(uint8(self.SlotNum))
+	encoder.Write(bytes.Repeat([]byte{0}, 3))
+	encoder.Write(self.Data)
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeBsnPduRxRequest(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnPduRxRequest, error) {
+	_bsnpdurxrequest := &BsnPduRxRequest{BsnHeader: parent}
+	if decoder.Length() < 10 {
+		return nil, fmt.Errorf("BsnPduRxRequest packet too short: %d < 10", decoder.Length())
+	}
+	_bsnpdurxrequest.TimeoutMs = uint32(decoder.ReadUint32())
+	_bsnpdurxrequest.PortNo.Decode(decoder)
+	_bsnpdurxrequest.SlotNum = uint8(decoder.ReadByte())
+	decoder.Skip(3)
+	_bsnpdurxrequest.Data = decoder.Read(int(decoder.Length()))
+	return _bsnpdurxrequest, nil
+}
+
+func NewBsnPduRxRequest() *BsnPduRxRequest {
+	obj := &BsnPduRxRequest{
+		BsnHeader: NewBsnHeader(33),
+	}
+	return obj
+}
+
+type BsnPduRxTimeout struct {
+	*BsnHeader
+	PortNo  Port
+	SlotNum uint8
+}
+
+type IBsnPduRxTimeout interface {
+	IBsnHeader
+	GetPortNo() Port
+	GetSlotNum() uint8
+}
+
+func (self *BsnPduRxTimeout) GetPortNo() Port {
+	return self.PortNo
+}
+
+func (self *BsnPduRxTimeout) SetPortNo(v Port) {
+	self.PortNo = v
+}
+
+func (self *BsnPduRxTimeout) GetSlotNum() uint8 {
+	return self.SlotNum
+}
+
+func (self *BsnPduRxTimeout) SetSlotNum(v uint8) {
+	self.SlotNum = v
+}
+
+func (self *BsnPduRxTimeout) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.BsnHeader.Serialize(encoder); err != nil {
+		return err
+	}
+
+	self.PortNo.Serialize(encoder)
+	encoder.PutUint8(uint8(self.SlotNum))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeBsnPduRxTimeout(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnPduRxTimeout, error) {
+	_bsnpdurxtimeout := &BsnPduRxTimeout{BsnHeader: parent}
+	if decoder.Length() < 3 {
+		return nil, fmt.Errorf("BsnPduRxTimeout packet too short: %d < 3", decoder.Length())
+	}
+	_bsnpdurxtimeout.PortNo.Decode(decoder)
+	_bsnpdurxtimeout.SlotNum = uint8(decoder.ReadByte())
+	return _bsnpdurxtimeout, nil
+}
+
+func NewBsnPduRxTimeout() *BsnPduRxTimeout {
+	obj := &BsnPduRxTimeout{
+		BsnHeader: NewBsnHeader(35),
+	}
+	return obj
+}
+
+type BsnPduTxReply struct {
+	*BsnHeader
+	Status  uint32
+	PortNo  Port
+	SlotNum uint8
+}
+
+type IBsnPduTxReply interface {
+	IBsnHeader
+	GetStatus() uint32
+	GetPortNo() Port
+	GetSlotNum() uint8
+}
+
+func (self *BsnPduTxReply) GetStatus() uint32 {
+	return self.Status
+}
+
+func (self *BsnPduTxReply) SetStatus(v uint32) {
+	self.Status = v
+}
+
+func (self *BsnPduTxReply) GetPortNo() Port {
+	return self.PortNo
+}
+
+func (self *BsnPduTxReply) SetPortNo(v Port) {
+	self.PortNo = v
+}
+
+func (self *BsnPduTxReply) GetSlotNum() uint8 {
+	return self.SlotNum
+}
+
+func (self *BsnPduTxReply) SetSlotNum(v uint8) {
+	self.SlotNum = v
+}
+
+func (self *BsnPduTxReply) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.BsnHeader.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Status))
+	self.PortNo.Serialize(encoder)
+	encoder.PutUint8(uint8(self.SlotNum))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeBsnPduTxReply(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnPduTxReply, error) {
+	_bsnpdutxreply := &BsnPduTxReply{BsnHeader: parent}
+	if decoder.Length() < 7 {
+		return nil, fmt.Errorf("BsnPduTxReply packet too short: %d < 7", decoder.Length())
+	}
+	_bsnpdutxreply.Status = uint32(decoder.ReadUint32())
+	_bsnpdutxreply.PortNo.Decode(decoder)
+	_bsnpdutxreply.SlotNum = uint8(decoder.ReadByte())
+	return _bsnpdutxreply, nil
+}
+
+func NewBsnPduTxReply() *BsnPduTxReply {
+	obj := &BsnPduTxReply{
+		BsnHeader: NewBsnHeader(32),
+	}
+	return obj
+}
+
+type BsnPduTxRequest struct {
+	*BsnHeader
+	TxIntervalMs uint32
+	PortNo       Port
+	SlotNum      uint8
+	Data         []byte
+}
+
+type IBsnPduTxRequest interface {
+	IBsnHeader
+	GetTxIntervalMs() uint32
+	GetPortNo() Port
+	GetSlotNum() uint8
+	GetData() []byte
+}
+
+func (self *BsnPduTxRequest) GetTxIntervalMs() uint32 {
+	return self.TxIntervalMs
+}
+
+func (self *BsnPduTxRequest) SetTxIntervalMs(v uint32) {
+	self.TxIntervalMs = v
+}
+
+func (self *BsnPduTxRequest) GetPortNo() Port {
+	return self.PortNo
+}
+
+func (self *BsnPduTxRequest) SetPortNo(v Port) {
+	self.PortNo = v
+}
+
+func (self *BsnPduTxRequest) GetSlotNum() uint8 {
+	return self.SlotNum
+}
+
+func (self *BsnPduTxRequest) SetSlotNum(v uint8) {
+	self.SlotNum = v
+}
+
+func (self *BsnPduTxRequest) GetData() []byte {
+	return self.Data
+}
+
+func (self *BsnPduTxRequest) SetData(v []byte) {
+	self.Data = v
+}
+
+func (self *BsnPduTxRequest) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.BsnHeader.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.TxIntervalMs))
+	self.PortNo.Serialize(encoder)
+	encoder.PutUint8(uint8(self.SlotNum))
+	encoder.Write(bytes.Repeat([]byte{0}, 3))
+	encoder.Write(self.Data)
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeBsnPduTxRequest(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnPduTxRequest, error) {
+	_bsnpdutxrequest := &BsnPduTxRequest{BsnHeader: parent}
+	if decoder.Length() < 10 {
+		return nil, fmt.Errorf("BsnPduTxRequest packet too short: %d < 10", decoder.Length())
+	}
+	_bsnpdutxrequest.TxIntervalMs = uint32(decoder.ReadUint32())
+	_bsnpdutxrequest.PortNo.Decode(decoder)
+	_bsnpdutxrequest.SlotNum = uint8(decoder.ReadByte())
+	decoder.Skip(3)
+	_bsnpdutxrequest.Data = decoder.Read(int(decoder.Length()))
+	return _bsnpdutxrequest, nil
+}
+
+func NewBsnPduTxRequest() *BsnPduTxRequest {
+	obj := &BsnPduTxRequest{
+		BsnHeader: NewBsnHeader(31),
+	}
+	return obj
+}
+
+type BsnSetIpMask struct {
+	*BsnHeader
+	Index uint8
+	Mask  uint32
+}
+
+type IBsnSetIpMask interface {
+	IBsnHeader
+	GetIndex() uint8
+	GetMask() uint32
+}
+
+func (self *BsnSetIpMask) GetIndex() uint8 {
+	return self.Index
+}
+
+func (self *BsnSetIpMask) SetIndex(v uint8) {
+	self.Index = v
+}
+
+func (self *BsnSetIpMask) GetMask() uint32 {
+	return self.Mask
+}
+
+func (self *BsnSetIpMask) SetMask(v uint32) {
+	self.Mask = v
+}
+
+func (self *BsnSetIpMask) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.BsnHeader.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint8(uint8(self.Index))
+	encoder.Write(bytes.Repeat([]byte{0}, 3))
+	encoder.PutUint32(uint32(self.Mask))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeBsnSetIpMask(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnSetIpMask, error) {
+	_bsnsetipmask := &BsnSetIpMask{BsnHeader: parent}
+	if decoder.Length() < 8 {
+		return nil, fmt.Errorf("BsnSetIpMask packet too short: %d < 8", decoder.Length())
+	}
+	_bsnsetipmask.Index = uint8(decoder.ReadByte())
+	decoder.Skip(3)
+	_bsnsetipmask.Mask = uint32(decoder.ReadUint32())
+	return _bsnsetipmask, nil
+}
+
+func NewBsnSetIpMask() *BsnSetIpMask {
+	obj := &BsnSetIpMask{
+		BsnHeader: NewBsnHeader(0),
+	}
+	return obj
+}
+
+type BsnSetL2TableReply struct {
+	*BsnHeader
+	L2TableEnable   uint8
+	L2TablePriority uint16
+	Status          uint32
+}
+
+type IBsnSetL2TableReply interface {
+	IBsnHeader
+	GetL2TableEnable() uint8
+	GetL2TablePriority() uint16
+	GetStatus() uint32
+}
+
+func (self *BsnSetL2TableReply) GetL2TableEnable() uint8 {
+	return self.L2TableEnable
+}
+
+func (self *BsnSetL2TableReply) SetL2TableEnable(v uint8) {
+	self.L2TableEnable = v
+}
+
+func (self *BsnSetL2TableReply) GetL2TablePriority() uint16 {
+	return self.L2TablePriority
+}
+
+func (self *BsnSetL2TableReply) SetL2TablePriority(v uint16) {
+	self.L2TablePriority = v
+}
+
+func (self *BsnSetL2TableReply) GetStatus() uint32 {
+	return self.Status
+}
+
+func (self *BsnSetL2TableReply) SetStatus(v uint32) {
+	self.Status = v
+}
+
+func (self *BsnSetL2TableReply) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.BsnHeader.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint8(uint8(self.L2TableEnable))
+	encoder.Write(bytes.Repeat([]byte{0}, 1))
+	encoder.PutUint16(uint16(self.L2TablePriority))
+	encoder.PutUint32(uint32(self.Status))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeBsnSetL2TableReply(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnSetL2TableReply, error) {
+	_bsnsetl2tablereply := &BsnSetL2TableReply{BsnHeader: parent}
+	if decoder.Length() < 8 {
+		return nil, fmt.Errorf("BsnSetL2TableReply packet too short: %d < 8", decoder.Length())
+	}
+	_bsnsetl2tablereply.L2TableEnable = uint8(decoder.ReadByte())
+	decoder.Skip(1)
+	_bsnsetl2tablereply.L2TablePriority = uint16(decoder.ReadUint16())
+	_bsnsetl2tablereply.Status = uint32(decoder.ReadUint32())
+	return _bsnsetl2tablereply, nil
+}
+
+func NewBsnSetL2TableReply() *BsnSetL2TableReply {
+	obj := &BsnSetL2TableReply{
+		BsnHeader: NewBsnHeader(24),
+	}
+	return obj
+}
+
+type BsnSetL2TableRequest struct {
+	*BsnHeader
+	L2TableEnable   uint8
+	L2TablePriority uint16
+}
+
+type IBsnSetL2TableRequest interface {
+	IBsnHeader
+	GetL2TableEnable() uint8
+	GetL2TablePriority() uint16
+}
+
+func (self *BsnSetL2TableRequest) GetL2TableEnable() uint8 {
+	return self.L2TableEnable
+}
+
+func (self *BsnSetL2TableRequest) SetL2TableEnable(v uint8) {
+	self.L2TableEnable = v
+}
+
+func (self *BsnSetL2TableRequest) GetL2TablePriority() uint16 {
+	return self.L2TablePriority
+}
+
+func (self *BsnSetL2TableRequest) SetL2TablePriority(v uint16) {
+	self.L2TablePriority = v
+}
+
+func (self *BsnSetL2TableRequest) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.BsnHeader.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint8(uint8(self.L2TableEnable))
+	encoder.Write(bytes.Repeat([]byte{0}, 1))
+	encoder.PutUint16(uint16(self.L2TablePriority))
+	encoder.Write(bytes.Repeat([]byte{0}, 4))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeBsnSetL2TableRequest(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnSetL2TableRequest, error) {
+	_bsnsetl2tablerequest := &BsnSetL2TableRequest{BsnHeader: parent}
+	if decoder.Length() < 8 {
+		return nil, fmt.Errorf("BsnSetL2TableRequest packet too short: %d < 8", decoder.Length())
+	}
+	_bsnsetl2tablerequest.L2TableEnable = uint8(decoder.ReadByte())
+	decoder.Skip(1)
+	_bsnsetl2tablerequest.L2TablePriority = uint16(decoder.ReadUint16())
+	decoder.Skip(4)
+	return _bsnsetl2tablerequest, nil
+}
+
+func NewBsnSetL2TableRequest() *BsnSetL2TableRequest {
+	obj := &BsnSetL2TableRequest{
+		BsnHeader: NewBsnHeader(12),
+	}
+	return obj
+}
+
+type BsnSetMirroring struct {
+	*BsnHeader
+	ReportMirrorPorts uint8
+}
+
+type IBsnSetMirroring interface {
+	IBsnHeader
+	GetReportMirrorPorts() uint8
+}
+
+func (self *BsnSetMirroring) GetReportMirrorPorts() uint8 {
+	return self.ReportMirrorPorts
+}
+
+func (self *BsnSetMirroring) SetReportMirrorPorts(v uint8) {
+	self.ReportMirrorPorts = v
+}
+
+func (self *BsnSetMirroring) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.BsnHeader.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint8(uint8(self.ReportMirrorPorts))
+	encoder.Write(bytes.Repeat([]byte{0}, 3))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeBsnSetMirroring(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnSetMirroring, error) {
+	_bsnsetmirroring := &BsnSetMirroring{BsnHeader: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("BsnSetMirroring packet too short: %d < 4", decoder.Length())
+	}
+	_bsnsetmirroring.ReportMirrorPorts = uint8(decoder.ReadByte())
+	decoder.Skip(3)
+	return _bsnsetmirroring, nil
+}
+
+func NewBsnSetMirroring() *BsnSetMirroring {
+	obj := &BsnSetMirroring{
+		BsnHeader: NewBsnHeader(3),
+	}
+	return obj
+}
+
+type BsnSetPktinSuppressionReply struct {
+	*BsnHeader
+	Status uint32
+}
+
+type IBsnSetPktinSuppressionReply interface {
+	IBsnHeader
+	GetStatus() uint32
+}
+
+func (self *BsnSetPktinSuppressionReply) GetStatus() uint32 {
+	return self.Status
+}
+
+func (self *BsnSetPktinSuppressionReply) SetStatus(v uint32) {
+	self.Status = v
+}
+
+func (self *BsnSetPktinSuppressionReply) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.BsnHeader.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Status))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeBsnSetPktinSuppressionReply(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnSetPktinSuppressionReply, error) {
+	_bsnsetpktinsuppressionreply := &BsnSetPktinSuppressionReply{BsnHeader: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("BsnSetPktinSuppressionReply packet too short: %d < 4", decoder.Length())
+	}
+	_bsnsetpktinsuppressionreply.Status = uint32(decoder.ReadUint32())
+	return _bsnsetpktinsuppressionreply, nil
+}
+
+func NewBsnSetPktinSuppressionReply() *BsnSetPktinSuppressionReply {
+	obj := &BsnSetPktinSuppressionReply{
+		BsnHeader: NewBsnHeader(25),
+	}
+	return obj
+}
+
+type BsnSetPktinSuppressionRequest struct {
+	*BsnHeader
+	Enabled     uint8
+	IdleTimeout uint16
+	HardTimeout uint16
+	Priority    uint16
+	Cookie      uint64
+}
+
+type IBsnSetPktinSuppressionRequest interface {
+	IBsnHeader
+	GetEnabled() uint8
+	GetIdleTimeout() uint16
+	GetHardTimeout() uint16
+	GetPriority() uint16
+	GetCookie() uint64
+}
+
+func (self *BsnSetPktinSuppressionRequest) GetEnabled() uint8 {
+	return self.Enabled
+}
+
+func (self *BsnSetPktinSuppressionRequest) SetEnabled(v uint8) {
+	self.Enabled = v
+}
+
+func (self *BsnSetPktinSuppressionRequest) GetIdleTimeout() uint16 {
+	return self.IdleTimeout
+}
+
+func (self *BsnSetPktinSuppressionRequest) SetIdleTimeout(v uint16) {
+	self.IdleTimeout = v
+}
+
+func (self *BsnSetPktinSuppressionRequest) GetHardTimeout() uint16 {
+	return self.HardTimeout
+}
+
+func (self *BsnSetPktinSuppressionRequest) SetHardTimeout(v uint16) {
+	self.HardTimeout = v
+}
+
+func (self *BsnSetPktinSuppressionRequest) GetPriority() uint16 {
+	return self.Priority
+}
+
+func (self *BsnSetPktinSuppressionRequest) SetPriority(v uint16) {
+	self.Priority = v
+}
+
+func (self *BsnSetPktinSuppressionRequest) GetCookie() uint64 {
+	return self.Cookie
+}
+
+func (self *BsnSetPktinSuppressionRequest) SetCookie(v uint64) {
+	self.Cookie = v
+}
+
+func (self *BsnSetPktinSuppressionRequest) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.BsnHeader.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint8(uint8(self.Enabled))
+	encoder.Write(bytes.Repeat([]byte{0}, 1))
+	encoder.PutUint16(uint16(self.IdleTimeout))
+	encoder.PutUint16(uint16(self.HardTimeout))
+	encoder.PutUint16(uint16(self.Priority))
+	encoder.PutUint64(uint64(self.Cookie))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeBsnSetPktinSuppressionRequest(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnSetPktinSuppressionRequest, error) {
+	_bsnsetpktinsuppressionrequest := &BsnSetPktinSuppressionRequest{BsnHeader: parent}
+	if decoder.Length() < 16 {
+		return nil, fmt.Errorf("BsnSetPktinSuppressionRequest packet too short: %d < 16", decoder.Length())
+	}
+	_bsnsetpktinsuppressionrequest.Enabled = uint8(decoder.ReadByte())
+	decoder.Skip(1)
+	_bsnsetpktinsuppressionrequest.IdleTimeout = uint16(decoder.ReadUint16())
+	_bsnsetpktinsuppressionrequest.HardTimeout = uint16(decoder.ReadUint16())
+	_bsnsetpktinsuppressionrequest.Priority = uint16(decoder.ReadUint16())
+	_bsnsetpktinsuppressionrequest.Cookie = uint64(decoder.ReadUint64())
+	return _bsnsetpktinsuppressionrequest, nil
+}
+
+func NewBsnSetPktinSuppressionRequest() *BsnSetPktinSuppressionRequest {
+	obj := &BsnSetPktinSuppressionRequest{
+		BsnHeader: NewBsnHeader(11),
+	}
+	return obj
+}
+
+type BsnShellCommand struct {
+	*BsnHeader
+	Service uint32
+	Data    []byte
+}
+
+type IBsnShellCommand interface {
+	IBsnHeader
+	GetService() uint32
+	GetData() []byte
+}
+
+func (self *BsnShellCommand) GetService() uint32 {
+	return self.Service
+}
+
+func (self *BsnShellCommand) SetService(v uint32) {
+	self.Service = v
+}
+
+func (self *BsnShellCommand) GetData() []byte {
+	return self.Data
+}
+
+func (self *BsnShellCommand) SetData(v []byte) {
+	self.Data = v
+}
+
+func (self *BsnShellCommand) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.BsnHeader.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Service))
+	encoder.Write(self.Data)
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeBsnShellCommand(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnShellCommand, error) {
+	_bsnshellcommand := &BsnShellCommand{BsnHeader: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("BsnShellCommand packet too short: %d < 4", decoder.Length())
+	}
+	_bsnshellcommand.Service = uint32(decoder.ReadUint32())
+	_bsnshellcommand.Data = decoder.Read(int(decoder.Length()))
+	return _bsnshellcommand, nil
+}
+
+func NewBsnShellCommand() *BsnShellCommand {
+	obj := &BsnShellCommand{
+		BsnHeader: NewBsnHeader(6),
+	}
+	return obj
+}
+
+type BsnShellOutput struct {
+	*BsnHeader
+	Data []byte
+}
+
+type IBsnShellOutput interface {
+	IBsnHeader
+	GetData() []byte
+}
+
+func (self *BsnShellOutput) GetData() []byte {
+	return self.Data
+}
+
+func (self *BsnShellOutput) SetData(v []byte) {
+	self.Data = v
+}
+
+func (self *BsnShellOutput) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.BsnHeader.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Data)
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeBsnShellOutput(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnShellOutput, error) {
+	_bsnshelloutput := &BsnShellOutput{BsnHeader: parent}
+	_bsnshelloutput.Data = decoder.Read(int(decoder.Length()))
+	return _bsnshelloutput, nil
+}
+
+func NewBsnShellOutput() *BsnShellOutput {
+	obj := &BsnShellOutput{
+		BsnHeader: NewBsnHeader(7),
+	}
+	return obj
+}
+
+type BsnShellStatus struct {
+	*BsnHeader
+	Status uint32
+}
+
+type IBsnShellStatus interface {
+	IBsnHeader
+	GetStatus() uint32
+}
+
+func (self *BsnShellStatus) GetStatus() uint32 {
+	return self.Status
+}
+
+func (self *BsnShellStatus) SetStatus(v uint32) {
+	self.Status = v
+}
+
+func (self *BsnShellStatus) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.BsnHeader.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Status))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeBsnShellStatus(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnShellStatus, error) {
+	_bsnshellstatus := &BsnShellStatus{BsnHeader: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("BsnShellStatus packet too short: %d < 4", decoder.Length())
+	}
+	_bsnshellstatus.Status = uint32(decoder.ReadUint32())
+	return _bsnshellstatus, nil
+}
+
+func NewBsnShellStatus() *BsnShellStatus {
+	obj := &BsnShellStatus{
+		BsnHeader: NewBsnHeader(8),
+	}
+	return obj
+}
+
+type ExperimenterStatsReply struct {
+	*StatsReply
+	Experimenter uint32
+}
+
+type IExperimenterStatsReply interface {
+	IStatsReply
+	GetExperimenter() uint32
+}
+
+func (self *ExperimenterStatsReply) GetExperimenter() uint32 {
+	return self.Experimenter
+}
+
+func (self *ExperimenterStatsReply) SetExperimenter(v uint32) {
+	self.Experimenter = v
+}
+
+func (self *ExperimenterStatsReply) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.StatsReply.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Experimenter))
+
+	return nil
+}
+
+func DecodeExperimenterStatsReply(parent *StatsReply, decoder *goloxi.Decoder) (IExperimenterStatsReply, error) {
+	_experimenterstatsreply := &ExperimenterStatsReply{StatsReply: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("ExperimenterStatsReply packet too short: %d < 4", decoder.Length())
+	}
+	_experimenterstatsreply.Experimenter = uint32(decoder.ReadUint32())
+
+	switch _experimenterstatsreply.Experimenter {
+	case 8992:
+		return DecodeNiciraStatsReply(_experimenterstatsreply, decoder)
+	case 6035143:
+		return DecodeBsnStatsReply(_experimenterstatsreply, decoder)
+	default:
+		return nil, fmt.Errorf("Invalid type '%d' for 'ExperimenterStatsReply'", _experimenterstatsreply.Experimenter)
+	}
+}
+
+func NewExperimenterStatsReply(_experimenter uint32) *ExperimenterStatsReply {
+	obj := &ExperimenterStatsReply{
+		StatsReply: NewStatsReply(65535),
+	}
+	obj.Experimenter = _experimenter
+	return obj
+}
+
+type BsnStatsReply struct {
+	*ExperimenterStatsReply
+	Subtype uint32
+}
+
+type IBsnStatsReply interface {
+	IExperimenterStatsReply
+	GetSubtype() uint32
+}
+
+func (self *BsnStatsReply) GetSubtype() uint32 {
+	return self.Subtype
+}
+
+func (self *BsnStatsReply) SetSubtype(v uint32) {
+	self.Subtype = v
+}
+
+func (self *BsnStatsReply) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.ExperimenterStatsReply.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Subtype))
+
+	return nil
+}
+
+func DecodeBsnStatsReply(parent *ExperimenterStatsReply, decoder *goloxi.Decoder) (IBsnStatsReply, error) {
+	_bsnstatsreply := &BsnStatsReply{ExperimenterStatsReply: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("BsnStatsReply packet too short: %d < 4", decoder.Length())
+	}
+	_bsnstatsreply.Subtype = uint32(decoder.ReadUint32())
+	return _bsnstatsreply, nil
+}
+
+func NewBsnStatsReply(_subtype uint32) *BsnStatsReply {
+	obj := &BsnStatsReply{
+		ExperimenterStatsReply: NewExperimenterStatsReply(6035143),
+	}
+	obj.Subtype = _subtype
+	return obj
+}
+
+type ExperimenterStatsRequest struct {
+	*StatsRequest
+	Experimenter uint32
+}
+
+type IExperimenterStatsRequest interface {
+	IStatsRequest
+	GetExperimenter() uint32
+}
+
+func (self *ExperimenterStatsRequest) GetExperimenter() uint32 {
+	return self.Experimenter
+}
+
+func (self *ExperimenterStatsRequest) SetExperimenter(v uint32) {
+	self.Experimenter = v
+}
+
+func (self *ExperimenterStatsRequest) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.StatsRequest.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Experimenter))
+
+	return nil
+}
+
+func DecodeExperimenterStatsRequest(parent *StatsRequest, decoder *goloxi.Decoder) (IExperimenterStatsRequest, error) {
+	_experimenterstatsrequest := &ExperimenterStatsRequest{StatsRequest: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("ExperimenterStatsRequest packet too short: %d < 4", decoder.Length())
+	}
+	_experimenterstatsrequest.Experimenter = uint32(decoder.ReadUint32())
+
+	switch _experimenterstatsrequest.Experimenter {
+	case 8992:
+		return DecodeNiciraFlowStatsRequest(_experimenterstatsrequest, decoder)
+	case 6035143:
+		return DecodeBsnStatsRequest(_experimenterstatsrequest, decoder)
+	default:
+		return nil, fmt.Errorf("Invalid type '%d' for 'ExperimenterStatsRequest'", _experimenterstatsrequest.Experimenter)
+	}
+}
+
+func NewExperimenterStatsRequest(_experimenter uint32) *ExperimenterStatsRequest {
+	obj := &ExperimenterStatsRequest{
+		StatsRequest: NewStatsRequest(65535),
+	}
+	obj.Experimenter = _experimenter
+	return obj
+}
+
+type BsnStatsRequest struct {
+	*ExperimenterStatsRequest
+	Subtype uint32
+}
+
+type IBsnStatsRequest interface {
+	IExperimenterStatsRequest
+	GetSubtype() uint32
+}
+
+func (self *BsnStatsRequest) GetSubtype() uint32 {
+	return self.Subtype
+}
+
+func (self *BsnStatsRequest) SetSubtype(v uint32) {
+	self.Subtype = v
+}
+
+func (self *BsnStatsRequest) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.ExperimenterStatsRequest.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Subtype))
+
+	return nil
+}
+
+func DecodeBsnStatsRequest(parent *ExperimenterStatsRequest, decoder *goloxi.Decoder) (IBsnStatsRequest, error) {
+	_bsnstatsrequest := &BsnStatsRequest{ExperimenterStatsRequest: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("BsnStatsRequest packet too short: %d < 4", decoder.Length())
+	}
+	_bsnstatsrequest.Subtype = uint32(decoder.ReadUint32())
+	return _bsnstatsrequest, nil
+}
+
+func NewBsnStatsRequest(_subtype uint32) *BsnStatsRequest {
+	obj := &BsnStatsRequest{
+		ExperimenterStatsRequest: NewExperimenterStatsRequest(6035143),
+	}
+	obj.Subtype = _subtype
+	return obj
+}
+
+type BsnVirtualPortCreateReply struct {
+	*BsnHeader
+	Status  uint32
+	VportNo uint32
+}
+
+type IBsnVirtualPortCreateReply interface {
+	IBsnHeader
+	GetStatus() uint32
+	GetVportNo() uint32
+}
+
+func (self *BsnVirtualPortCreateReply) GetStatus() uint32 {
+	return self.Status
+}
+
+func (self *BsnVirtualPortCreateReply) SetStatus(v uint32) {
+	self.Status = v
+}
+
+func (self *BsnVirtualPortCreateReply) GetVportNo() uint32 {
+	return self.VportNo
+}
+
+func (self *BsnVirtualPortCreateReply) SetVportNo(v uint32) {
+	self.VportNo = v
+}
+
+func (self *BsnVirtualPortCreateReply) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.BsnHeader.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Status))
+	encoder.PutUint32(uint32(self.VportNo))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeBsnVirtualPortCreateReply(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnVirtualPortCreateReply, error) {
+	_bsnvirtualportcreatereply := &BsnVirtualPortCreateReply{BsnHeader: parent}
+	if decoder.Length() < 8 {
+		return nil, fmt.Errorf("BsnVirtualPortCreateReply packet too short: %d < 8", decoder.Length())
+	}
+	_bsnvirtualportcreatereply.Status = uint32(decoder.ReadUint32())
+	_bsnvirtualportcreatereply.VportNo = uint32(decoder.ReadUint32())
+	return _bsnvirtualportcreatereply, nil
+}
+
+func NewBsnVirtualPortCreateReply() *BsnVirtualPortCreateReply {
+	obj := &BsnVirtualPortCreateReply{
+		BsnHeader: NewBsnHeader(16),
+	}
+	return obj
+}
+
+type BsnVirtualPortCreateRequest struct {
+	*BsnHeader
+	Vport BSNVport
+}
+
+type IBsnVirtualPortCreateRequest interface {
+	IBsnHeader
+	GetVport() BSNVport
+}
+
+func (self *BsnVirtualPortCreateRequest) GetVport() BSNVport {
+	return self.Vport
+}
+
+func (self *BsnVirtualPortCreateRequest) SetVport(v BSNVport) {
+	self.Vport = v
+}
+
+func (self *BsnVirtualPortCreateRequest) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.BsnHeader.Serialize(encoder); err != nil {
+		return err
+	}
+
+	if err := self.Vport.Serialize(encoder); err != nil {
+		return err
+	}
+
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeBsnVirtualPortCreateRequest(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnVirtualPortCreateRequest, error) {
+	_bsnvirtualportcreaterequest := &BsnVirtualPortCreateRequest{BsnHeader: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("BsnVirtualPortCreateRequest packet too short: %d < 4", decoder.Length())
+	}
+	if err := _bsnvirtualportcreaterequest.Vport.Decode(decoder); err != nil {
+		return nil, err
+	}
+
+	return _bsnvirtualportcreaterequest, nil
+}
+
+func NewBsnVirtualPortCreateRequest() *BsnVirtualPortCreateRequest {
+	obj := &BsnVirtualPortCreateRequest{
+		BsnHeader: NewBsnHeader(15),
+	}
+	return obj
+}
+
+type BsnVirtualPortRemoveReply struct {
+	*BsnHeader
+	Status uint32
+}
+
+type IBsnVirtualPortRemoveReply interface {
+	IBsnHeader
+	GetStatus() uint32
+}
+
+func (self *BsnVirtualPortRemoveReply) GetStatus() uint32 {
+	return self.Status
+}
+
+func (self *BsnVirtualPortRemoveReply) SetStatus(v uint32) {
+	self.Status = v
+}
+
+func (self *BsnVirtualPortRemoveReply) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.BsnHeader.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Status))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeBsnVirtualPortRemoveReply(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnVirtualPortRemoveReply, error) {
+	_bsnvirtualportremovereply := &BsnVirtualPortRemoveReply{BsnHeader: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("BsnVirtualPortRemoveReply packet too short: %d < 4", decoder.Length())
+	}
+	_bsnvirtualportremovereply.Status = uint32(decoder.ReadUint32())
+	return _bsnvirtualportremovereply, nil
+}
+
+func NewBsnVirtualPortRemoveReply() *BsnVirtualPortRemoveReply {
+	obj := &BsnVirtualPortRemoveReply{
+		BsnHeader: NewBsnHeader(26),
+	}
+	return obj
+}
+
+type BsnVirtualPortRemoveRequest struct {
+	*BsnHeader
+	VportNo uint32
+}
+
+type IBsnVirtualPortRemoveRequest interface {
+	IBsnHeader
+	GetVportNo() uint32
+}
+
+func (self *BsnVirtualPortRemoveRequest) GetVportNo() uint32 {
+	return self.VportNo
+}
+
+func (self *BsnVirtualPortRemoveRequest) SetVportNo(v uint32) {
+	self.VportNo = v
+}
+
+func (self *BsnVirtualPortRemoveRequest) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.BsnHeader.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.VportNo))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeBsnVirtualPortRemoveRequest(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnVirtualPortRemoveRequest, error) {
+	_bsnvirtualportremoverequest := &BsnVirtualPortRemoveRequest{BsnHeader: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("BsnVirtualPortRemoveRequest packet too short: %d < 4", decoder.Length())
+	}
+	_bsnvirtualportremoverequest.VportNo = uint32(decoder.ReadUint32())
+	return _bsnvirtualportremoverequest, nil
+}
+
+func NewBsnVirtualPortRemoveRequest() *BsnVirtualPortRemoveRequest {
+	obj := &BsnVirtualPortRemoveRequest{
+		BsnHeader: NewBsnHeader(17),
+	}
+	return obj
+}
+
+type DescStatsReply struct {
+	*StatsReply
+	MfrDesc   string
+	HwDesc    string
+	SwDesc    string
+	SerialNum string
+	DpDesc    string
+}
+
+type IDescStatsReply interface {
+	IStatsReply
+	GetMfrDesc() string
+	GetHwDesc() string
+	GetSwDesc() string
+	GetSerialNum() string
+	GetDpDesc() string
+}
+
+func (self *DescStatsReply) GetMfrDesc() string {
+	return self.MfrDesc
+}
+
+func (self *DescStatsReply) SetMfrDesc(v string) {
+	self.MfrDesc = v
+}
+
+func (self *DescStatsReply) GetHwDesc() string {
+	return self.HwDesc
+}
+
+func (self *DescStatsReply) SetHwDesc(v string) {
+	self.HwDesc = v
+}
+
+func (self *DescStatsReply) GetSwDesc() string {
+	return self.SwDesc
+}
+
+func (self *DescStatsReply) SetSwDesc(v string) {
+	self.SwDesc = v
+}
+
+func (self *DescStatsReply) GetSerialNum() string {
+	return self.SerialNum
+}
+
+func (self *DescStatsReply) SetSerialNum(v string) {
+	self.SerialNum = v
+}
+
+func (self *DescStatsReply) GetDpDesc() string {
+	return self.DpDesc
+}
+
+func (self *DescStatsReply) SetDpDesc(v string) {
+	self.DpDesc = v
+}
+
+func (self *DescStatsReply) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.StatsReply.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write([]byte(self.MfrDesc))
+	encoder.Write([]byte(self.HwDesc))
+	encoder.Write([]byte(self.SwDesc))
+	encoder.Write([]byte(self.SerialNum))
+	encoder.Write([]byte(self.DpDesc))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeDescStatsReply(parent *StatsReply, decoder *goloxi.Decoder) (*DescStatsReply, error) {
+	_descstatsreply := &DescStatsReply{StatsReply: parent}
+	if decoder.Length() < 1056 {
+		return nil, fmt.Errorf("DescStatsReply packet too short: %d < 1056", decoder.Length())
+	}
+	_descstatsreply.MfrDesc = string(bytes.Trim(decoder.Read(256), "\x00"))
+	_descstatsreply.HwDesc = string(bytes.Trim(decoder.Read(256), "\x00"))
+	_descstatsreply.SwDesc = string(bytes.Trim(decoder.Read(256), "\x00"))
+	_descstatsreply.SerialNum = string(bytes.Trim(decoder.Read(32), "\x00"))
+	_descstatsreply.DpDesc = string(bytes.Trim(decoder.Read(256), "\x00"))
+	return _descstatsreply, nil
+}
+
+func NewDescStatsReply() *DescStatsReply {
+	obj := &DescStatsReply{
+		StatsReply: NewStatsReply(0),
+	}
+	return obj
+}
+
+type DescStatsRequest struct {
+	*StatsRequest
+}
+
+type IDescStatsRequest interface {
+	IStatsRequest
+}
+
+func (self *DescStatsRequest) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.StatsRequest.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeDescStatsRequest(parent *StatsRequest, decoder *goloxi.Decoder) (*DescStatsRequest, error) {
+	_descstatsrequest := &DescStatsRequest{StatsRequest: parent}
+	return _descstatsrequest, nil
+}
+
+func NewDescStatsRequest() *DescStatsRequest {
+	obj := &DescStatsRequest{
+		StatsRequest: NewStatsRequest(0),
+	}
+	return obj
+}
+
+type EchoReply struct {
+	*Header
+	Data []byte
+}
+
+type IEchoReply interface {
+	IHeader
+	GetData() []byte
+}
+
+func (self *EchoReply) GetData() []byte {
+	return self.Data
+}
+
+func (self *EchoReply) SetData(v []byte) {
+	self.Data = v
+}
+
+func (self *EchoReply) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.Header.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Data)
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeEchoReply(parent *Header, decoder *goloxi.Decoder) (*EchoReply, error) {
+	_echoreply := &EchoReply{Header: parent}
+	_echoreply.Data = decoder.Read(int(decoder.Length()))
+	return _echoreply, nil
+}
+
+func NewEchoReply() *EchoReply {
+	obj := &EchoReply{
+		Header: NewHeader(3),
+	}
+	return obj
+}
+
+type EchoRequest struct {
+	*Header
+	Data []byte
+}
+
+type IEchoRequest interface {
+	IHeader
+	GetData() []byte
+}
+
+func (self *EchoRequest) GetData() []byte {
+	return self.Data
+}
+
+func (self *EchoRequest) SetData(v []byte) {
+	self.Data = v
+}
+
+func (self *EchoRequest) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.Header.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Data)
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeEchoRequest(parent *Header, decoder *goloxi.Decoder) (*EchoRequest, error) {
+	_echorequest := &EchoRequest{Header: parent}
+	_echorequest.Data = decoder.Read(int(decoder.Length()))
+	return _echorequest, nil
+}
+
+func NewEchoRequest() *EchoRequest {
+	obj := &EchoRequest{
+		Header: NewHeader(2),
+	}
+	return obj
+}
+
+type FeaturesReply struct {
+	*Header
+	DatapathId   uint64
+	NBuffers     uint32
+	NTables      uint8
+	Capabilities Capabilities
+	Actions      uint32
+	Ports        []*PortDesc
+}
+
+type IFeaturesReply interface {
+	IHeader
+	GetDatapathId() uint64
+	GetNBuffers() uint32
+	GetNTables() uint8
+	GetCapabilities() Capabilities
+	GetActions() uint32
+	GetPorts() []*PortDesc
+}
+
+func (self *FeaturesReply) GetDatapathId() uint64 {
+	return self.DatapathId
+}
+
+func (self *FeaturesReply) SetDatapathId(v uint64) {
+	self.DatapathId = v
+}
+
+func (self *FeaturesReply) GetNBuffers() uint32 {
+	return self.NBuffers
+}
+
+func (self *FeaturesReply) SetNBuffers(v uint32) {
+	self.NBuffers = v
+}
+
+func (self *FeaturesReply) GetNTables() uint8 {
+	return self.NTables
+}
+
+func (self *FeaturesReply) SetNTables(v uint8) {
+	self.NTables = v
+}
+
+func (self *FeaturesReply) GetCapabilities() Capabilities {
+	return self.Capabilities
+}
+
+func (self *FeaturesReply) SetCapabilities(v Capabilities) {
+	self.Capabilities = v
+}
+
+func (self *FeaturesReply) GetActions() uint32 {
+	return self.Actions
+}
+
+func (self *FeaturesReply) SetActions(v uint32) {
+	self.Actions = v
+}
+
+func (self *FeaturesReply) GetPorts() []*PortDesc {
+	return self.Ports
+}
+
+func (self *FeaturesReply) SetPorts(v []*PortDesc) {
+	self.Ports = v
+}
+
+func (self *FeaturesReply) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.Header.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint64(uint64(self.DatapathId))
+	encoder.PutUint32(uint32(self.NBuffers))
+	encoder.PutUint8(uint8(self.NTables))
+	encoder.Write(bytes.Repeat([]byte{0}, 3))
+	encoder.PutUint32(uint32(self.Capabilities))
+	encoder.PutUint32(uint32(self.Actions))
+	for _, obj := range self.Ports {
+		if err := obj.Serialize(encoder); err != nil {
+			return err
+		}
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeFeaturesReply(parent *Header, decoder *goloxi.Decoder) (*FeaturesReply, error) {
+	_featuresreply := &FeaturesReply{Header: parent}
+	if decoder.Length() < 24 {
+		return nil, fmt.Errorf("FeaturesReply packet too short: %d < 24", decoder.Length())
+	}
+	_featuresreply.DatapathId = uint64(decoder.ReadUint64())
+	_featuresreply.NBuffers = uint32(decoder.ReadUint32())
+	_featuresreply.NTables = uint8(decoder.ReadByte())
+	decoder.Skip(3)
+	_featuresreply.Capabilities = Capabilities(decoder.ReadUint32())
+	_featuresreply.Actions = uint32(decoder.ReadUint32())
+
+	for decoder.Length() >= 48 {
+		item := &PortDesc{}
+		if err := item.Decode(decoder); err != nil {
+			return nil, err
+		}
+		if item != nil {
+			_featuresreply.Ports = append(_featuresreply.Ports, item)
+		}
+	}
+	return _featuresreply, nil
+}
+
+func NewFeaturesReply() *FeaturesReply {
+	obj := &FeaturesReply{
+		Header: NewHeader(6),
+	}
+	return obj
+}
+
+type FeaturesRequest struct {
+	*Header
+}
+
+type IFeaturesRequest interface {
+	IHeader
+}
+
+func (self *FeaturesRequest) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.Header.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeFeaturesRequest(parent *Header, decoder *goloxi.Decoder) (*FeaturesRequest, error) {
+	_featuresrequest := &FeaturesRequest{Header: parent}
+	return _featuresrequest, nil
+}
+
+func NewFeaturesRequest() *FeaturesRequest {
+	obj := &FeaturesRequest{
+		Header: NewHeader(5),
+	}
+	return obj
+}
+
+type FlowMod struct {
+	*Header
+	Match       Match
+	Cookie      uint64
+	Command     FmCmd
+	IdleTimeout uint16
+	HardTimeout uint16
+	Priority    uint16
+	BufferId    uint32
+	OutPort     Port
+	Flags       FlowModFlags
+	Actions     []goloxi.IAction
+}
+
+type IFlowMod interface {
+	IHeader
+	GetMatch() Match
+	GetCookie() uint64
+	GetCommand() FmCmd
+	GetIdleTimeout() uint16
+	GetHardTimeout() uint16
+	GetPriority() uint16
+	GetBufferId() uint32
+	GetOutPort() Port
+	GetFlags() FlowModFlags
+	GetActions() []goloxi.IAction
+}
+
+func (self *FlowMod) GetMatch() Match {
+	return self.Match
+}
+
+func (self *FlowMod) SetMatch(v Match) {
+	self.Match = v
+}
+
+func (self *FlowMod) GetCookie() uint64 {
+	return self.Cookie
+}
+
+func (self *FlowMod) SetCookie(v uint64) {
+	self.Cookie = v
+}
+
+func (self *FlowMod) GetCommand() FmCmd {
+	return self.Command
+}
+
+func (self *FlowMod) SetCommand(v FmCmd) {
+	self.Command = v
+}
+
+func (self *FlowMod) GetIdleTimeout() uint16 {
+	return self.IdleTimeout
+}
+
+func (self *FlowMod) SetIdleTimeout(v uint16) {
+	self.IdleTimeout = v
+}
+
+func (self *FlowMod) GetHardTimeout() uint16 {
+	return self.HardTimeout
+}
+
+func (self *FlowMod) SetHardTimeout(v uint16) {
+	self.HardTimeout = v
+}
+
+func (self *FlowMod) GetPriority() uint16 {
+	return self.Priority
+}
+
+func (self *FlowMod) SetPriority(v uint16) {
+	self.Priority = v
+}
+
+func (self *FlowMod) GetBufferId() uint32 {
+	return self.BufferId
+}
+
+func (self *FlowMod) SetBufferId(v uint32) {
+	self.BufferId = v
+}
+
+func (self *FlowMod) GetOutPort() Port {
+	return self.OutPort
+}
+
+func (self *FlowMod) SetOutPort(v Port) {
+	self.OutPort = v
+}
+
+func (self *FlowMod) GetFlags() FlowModFlags {
+	return self.Flags
+}
+
+func (self *FlowMod) SetFlags(v FlowModFlags) {
+	self.Flags = v
+}
+
+func (self *FlowMod) GetActions() []goloxi.IAction {
+	return self.Actions
+}
+
+func (self *FlowMod) SetActions(v []goloxi.IAction) {
+	self.Actions = v
+}
+
+func (self *FlowMod) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Header.Serialize(encoder); err != nil {
+		return err
+	}
+
+	if err := self.Match.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint64(uint64(self.Cookie))
+	self.Command.Serialize(encoder)
+	encoder.PutUint16(uint16(self.IdleTimeout))
+	encoder.PutUint16(uint16(self.HardTimeout))
+	encoder.PutUint16(uint16(self.Priority))
+	encoder.PutUint32(uint32(self.BufferId))
+	self.OutPort.Serialize(encoder)
+	encoder.PutUint16(uint16(self.Flags))
+	for _, obj := range self.Actions {
+		if err := obj.Serialize(encoder); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func DecodeFlowMod(parent *Header, decoder *goloxi.Decoder) (IFlowMod, error) {
+	_flowmod := &FlowMod{Header: parent}
+	if decoder.Length() < 64 {
+		return nil, fmt.Errorf("FlowMod packet too short: %d < 64", decoder.Length())
+	}
+	if err := _flowmod.Match.Decode(decoder); err != nil {
+		return nil, err
+	}
+
+	_flowmod.Cookie = uint64(decoder.ReadUint64())
+	_flowmod.Command.Decode(decoder)
+	_flowmod.IdleTimeout = uint16(decoder.ReadUint16())
+	_flowmod.HardTimeout = uint16(decoder.ReadUint16())
+	_flowmod.Priority = uint16(decoder.ReadUint16())
+	_flowmod.BufferId = uint32(decoder.ReadUint32())
+	_flowmod.OutPort.Decode(decoder)
+	_flowmod.Flags = FlowModFlags(decoder.ReadUint16())
+
+	for decoder.Length() >= 8 {
+		item, err := DecodeAction(decoder)
+		if err != nil {
+			return nil, err
+		}
+		if item != nil {
+			_flowmod.Actions = append(_flowmod.Actions, item)
+		}
+	}
+
+	switch _flowmod.Command {
+	case 0:
+		return DecodeFlowAdd(_flowmod, decoder)
+	case 1:
+		return DecodeFlowModify(_flowmod, decoder)
+	case 2:
+		return DecodeFlowModifyStrict(_flowmod, decoder)
+	case 3:
+		return DecodeFlowDelete(_flowmod, decoder)
+	case 4:
+		return DecodeFlowDeleteStrict(_flowmod, decoder)
+	default:
+		return nil, fmt.Errorf("Invalid type '%d' for 'FlowMod'", _flowmod.Command)
+	}
+}
+
+func NewFlowMod(__command FmCmd) *FlowMod {
+	obj := &FlowMod{
+		Header: NewHeader(14),
+	}
+	obj.Command = __command
+	return obj
+}
+
+type FlowAdd struct {
+	*FlowMod
+}
+
+type IFlowAdd interface {
+	IFlowMod
+}
+
+func (self *FlowAdd) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.FlowMod.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeFlowAdd(parent *FlowMod, decoder *goloxi.Decoder) (*FlowAdd, error) {
+	_flowadd := &FlowAdd{FlowMod: parent}
+	return _flowadd, nil
+}
+
+func NewFlowAdd() *FlowAdd {
+	obj := &FlowAdd{
+		FlowMod: NewFlowMod(0),
+	}
+	return obj
+}
+
+type FlowDelete struct {
+	*FlowMod
+}
+
+type IFlowDelete interface {
+	IFlowMod
+}
+
+func (self *FlowDelete) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.FlowMod.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeFlowDelete(parent *FlowMod, decoder *goloxi.Decoder) (*FlowDelete, error) {
+	_flowdelete := &FlowDelete{FlowMod: parent}
+	return _flowdelete, nil
+}
+
+func NewFlowDelete() *FlowDelete {
+	obj := &FlowDelete{
+		FlowMod: NewFlowMod(3),
+	}
+	return obj
+}
+
+type FlowDeleteStrict struct {
+	*FlowMod
+}
+
+type IFlowDeleteStrict interface {
+	IFlowMod
+}
+
+func (self *FlowDeleteStrict) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.FlowMod.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeFlowDeleteStrict(parent *FlowMod, decoder *goloxi.Decoder) (*FlowDeleteStrict, error) {
+	_flowdeletestrict := &FlowDeleteStrict{FlowMod: parent}
+	return _flowdeletestrict, nil
+}
+
+func NewFlowDeleteStrict() *FlowDeleteStrict {
+	obj := &FlowDeleteStrict{
+		FlowMod: NewFlowMod(4),
+	}
+	return obj
+}
+
+type FlowModFailedErrorMsg struct {
+	*ErrorMsg
+	Code FlowModFailedCode
+	Data []byte
+}
+
+type IFlowModFailedErrorMsg interface {
+	IErrorMsg
+	GetCode() FlowModFailedCode
+	GetData() []byte
+}
+
+func (self *FlowModFailedErrorMsg) GetCode() FlowModFailedCode {
+	return self.Code
+}
+
+func (self *FlowModFailedErrorMsg) SetCode(v FlowModFailedCode) {
+	self.Code = v
+}
+
+func (self *FlowModFailedErrorMsg) GetData() []byte {
+	return self.Data
+}
+
+func (self *FlowModFailedErrorMsg) SetData(v []byte) {
+	self.Data = v
+}
+
+func (self *FlowModFailedErrorMsg) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ErrorMsg.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Code))
+	encoder.Write(self.Data)
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeFlowModFailedErrorMsg(parent *ErrorMsg, decoder *goloxi.Decoder) (*FlowModFailedErrorMsg, error) {
+	_flowmodfailederrormsg := &FlowModFailedErrorMsg{ErrorMsg: parent}
+	if decoder.Length() < 2 {
+		return nil, fmt.Errorf("FlowModFailedErrorMsg packet too short: %d < 2", decoder.Length())
+	}
+	_flowmodfailederrormsg.Code = FlowModFailedCode(decoder.ReadUint16())
+	_flowmodfailederrormsg.Data = decoder.Read(int(decoder.Length()))
+	return _flowmodfailederrormsg, nil
+}
+
+func NewFlowModFailedErrorMsg() *FlowModFailedErrorMsg {
+	obj := &FlowModFailedErrorMsg{
+		ErrorMsg: NewErrorMsg(3),
+	}
+	return obj
+}
+
+type FlowModify struct {
+	*FlowMod
+}
+
+type IFlowModify interface {
+	IFlowMod
+}
+
+func (self *FlowModify) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.FlowMod.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeFlowModify(parent *FlowMod, decoder *goloxi.Decoder) (*FlowModify, error) {
+	_flowmodify := &FlowModify{FlowMod: parent}
+	return _flowmodify, nil
+}
+
+func NewFlowModify() *FlowModify {
+	obj := &FlowModify{
+		FlowMod: NewFlowMod(1),
+	}
+	return obj
+}
+
+type FlowModifyStrict struct {
+	*FlowMod
+}
+
+type IFlowModifyStrict interface {
+	IFlowMod
+}
+
+func (self *FlowModifyStrict) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.FlowMod.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeFlowModifyStrict(parent *FlowMod, decoder *goloxi.Decoder) (*FlowModifyStrict, error) {
+	_flowmodifystrict := &FlowModifyStrict{FlowMod: parent}
+	return _flowmodifystrict, nil
+}
+
+func NewFlowModifyStrict() *FlowModifyStrict {
+	obj := &FlowModifyStrict{
+		FlowMod: NewFlowMod(2),
+	}
+	return obj
+}
+
+type FlowRemoved struct {
+	*Header
+	Match        Match
+	Cookie       uint64
+	Priority     uint16
+	Reason       FlowRemovedReason
+	DurationSec  uint32
+	DurationNsec uint32
+	IdleTimeout  uint16
+	PacketCount  uint64
+	ByteCount    uint64
+}
+
+type IFlowRemoved interface {
+	IHeader
+	GetMatch() Match
+	GetCookie() uint64
+	GetPriority() uint16
+	GetReason() FlowRemovedReason
+	GetDurationSec() uint32
+	GetDurationNsec() uint32
+	GetIdleTimeout() uint16
+	GetPacketCount() uint64
+	GetByteCount() uint64
+}
+
+func (self *FlowRemoved) GetMatch() Match {
+	return self.Match
+}
+
+func (self *FlowRemoved) SetMatch(v Match) {
+	self.Match = v
+}
+
+func (self *FlowRemoved) GetCookie() uint64 {
+	return self.Cookie
+}
+
+func (self *FlowRemoved) SetCookie(v uint64) {
+	self.Cookie = v
+}
+
+func (self *FlowRemoved) GetPriority() uint16 {
+	return self.Priority
+}
+
+func (self *FlowRemoved) SetPriority(v uint16) {
+	self.Priority = v
+}
+
+func (self *FlowRemoved) GetReason() FlowRemovedReason {
+	return self.Reason
+}
+
+func (self *FlowRemoved) SetReason(v FlowRemovedReason) {
+	self.Reason = v
+}
+
+func (self *FlowRemoved) GetDurationSec() uint32 {
+	return self.DurationSec
+}
+
+func (self *FlowRemoved) SetDurationSec(v uint32) {
+	self.DurationSec = v
+}
+
+func (self *FlowRemoved) GetDurationNsec() uint32 {
+	return self.DurationNsec
+}
+
+func (self *FlowRemoved) SetDurationNsec(v uint32) {
+	self.DurationNsec = v
+}
+
+func (self *FlowRemoved) GetIdleTimeout() uint16 {
+	return self.IdleTimeout
+}
+
+func (self *FlowRemoved) SetIdleTimeout(v uint16) {
+	self.IdleTimeout = v
+}
+
+func (self *FlowRemoved) GetPacketCount() uint64 {
+	return self.PacketCount
+}
+
+func (self *FlowRemoved) SetPacketCount(v uint64) {
+	self.PacketCount = v
+}
+
+func (self *FlowRemoved) GetByteCount() uint64 {
+	return self.ByteCount
+}
+
+func (self *FlowRemoved) SetByteCount(v uint64) {
+	self.ByteCount = v
+}
+
+func (self *FlowRemoved) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.Header.Serialize(encoder); err != nil {
+		return err
+	}
+
+	if err := self.Match.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint64(uint64(self.Cookie))
+	encoder.PutUint16(uint16(self.Priority))
+	encoder.PutUint8(uint8(self.Reason))
+	encoder.Write(bytes.Repeat([]byte{0}, 1))
+	encoder.PutUint32(uint32(self.DurationSec))
+	encoder.PutUint32(uint32(self.DurationNsec))
+	encoder.PutUint16(uint16(self.IdleTimeout))
+	encoder.Write(bytes.Repeat([]byte{0}, 2))
+	encoder.PutUint64(uint64(self.PacketCount))
+	encoder.PutUint64(uint64(self.ByteCount))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeFlowRemoved(parent *Header, decoder *goloxi.Decoder) (*FlowRemoved, error) {
+	_flowremoved := &FlowRemoved{Header: parent}
+	if decoder.Length() < 80 {
+		return nil, fmt.Errorf("FlowRemoved packet too short: %d < 80", decoder.Length())
+	}
+	if err := _flowremoved.Match.Decode(decoder); err != nil {
+		return nil, err
+	}
+
+	_flowremoved.Cookie = uint64(decoder.ReadUint64())
+	_flowremoved.Priority = uint16(decoder.ReadUint16())
+	_flowremoved.Reason = FlowRemovedReason(decoder.ReadByte())
+	decoder.Skip(1)
+	_flowremoved.DurationSec = uint32(decoder.ReadUint32())
+	_flowremoved.DurationNsec = uint32(decoder.ReadUint32())
+	_flowremoved.IdleTimeout = uint16(decoder.ReadUint16())
+	decoder.Skip(2)
+	_flowremoved.PacketCount = uint64(decoder.ReadUint64())
+	_flowremoved.ByteCount = uint64(decoder.ReadUint64())
+	return _flowremoved, nil
+}
+
+func NewFlowRemoved() *FlowRemoved {
+	obj := &FlowRemoved{
+		Header: NewHeader(11),
+	}
+	return obj
+}
+
+type FlowStatsReply struct {
+	*StatsReply
+	Entries []*FlowStatsEntry
+}
+
+type IFlowStatsReply interface {
+	IStatsReply
+	GetEntries() []*FlowStatsEntry
+}
+
+func (self *FlowStatsReply) GetEntries() []*FlowStatsEntry {
+	return self.Entries
+}
+
+func (self *FlowStatsReply) SetEntries(v []*FlowStatsEntry) {
+	self.Entries = v
+}
+
+func (self *FlowStatsReply) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.StatsReply.Serialize(encoder); err != nil {
+		return err
+	}
+
+	for _, obj := range self.Entries {
+		if err := obj.Serialize(encoder); err != nil {
+			return err
+		}
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeFlowStatsReply(parent *StatsReply, decoder *goloxi.Decoder) (*FlowStatsReply, error) {
+	_flowstatsreply := &FlowStatsReply{StatsReply: parent}
+
+	for decoder.Length() >= 88 {
+		item, err := DecodeFlowStatsEntry(decoder)
+		if err != nil {
+			return nil, err
+		}
+		if item != nil {
+			_flowstatsreply.Entries = append(_flowstatsreply.Entries, item)
+		}
+	}
+	return _flowstatsreply, nil
+}
+
+func NewFlowStatsReply() *FlowStatsReply {
+	obj := &FlowStatsReply{
+		StatsReply: NewStatsReply(1),
+	}
+	return obj
+}
+
+type FlowStatsRequest struct {
+	*StatsRequest
+	Match   Match
+	TableId uint8
+	OutPort Port
+}
+
+type IFlowStatsRequest interface {
+	IStatsRequest
+	GetMatch() Match
+	GetTableId() uint8
+	GetOutPort() Port
+}
+
+func (self *FlowStatsRequest) GetMatch() Match {
+	return self.Match
+}
+
+func (self *FlowStatsRequest) SetMatch(v Match) {
+	self.Match = v
+}
+
+func (self *FlowStatsRequest) GetTableId() uint8 {
+	return self.TableId
+}
+
+func (self *FlowStatsRequest) SetTableId(v uint8) {
+	self.TableId = v
+}
+
+func (self *FlowStatsRequest) GetOutPort() Port {
+	return self.OutPort
+}
+
+func (self *FlowStatsRequest) SetOutPort(v Port) {
+	self.OutPort = v
+}
+
+func (self *FlowStatsRequest) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.StatsRequest.Serialize(encoder); err != nil {
+		return err
+	}
+
+	if err := self.Match.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint8(uint8(self.TableId))
+	encoder.Write(bytes.Repeat([]byte{0}, 1))
+	self.OutPort.Serialize(encoder)
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeFlowStatsRequest(parent *StatsRequest, decoder *goloxi.Decoder) (*FlowStatsRequest, error) {
+	_flowstatsrequest := &FlowStatsRequest{StatsRequest: parent}
+	if decoder.Length() < 44 {
+		return nil, fmt.Errorf("FlowStatsRequest packet too short: %d < 44", decoder.Length())
+	}
+	if err := _flowstatsrequest.Match.Decode(decoder); err != nil {
+		return nil, err
+	}
+
+	_flowstatsrequest.TableId = uint8(decoder.ReadByte())
+	decoder.Skip(1)
+	_flowstatsrequest.OutPort.Decode(decoder)
+	return _flowstatsrequest, nil
+}
+
+func NewFlowStatsRequest() *FlowStatsRequest {
+	obj := &FlowStatsRequest{
+		StatsRequest: NewStatsRequest(1),
+	}
+	return obj
+}
+
+type GetConfigReply struct {
+	*Header
+	Flags       ConfigFlags
+	MissSendLen uint16
+}
+
+type IGetConfigReply interface {
+	IHeader
+	GetFlags() ConfigFlags
+	GetMissSendLen() uint16
+}
+
+func (self *GetConfigReply) GetFlags() ConfigFlags {
+	return self.Flags
+}
+
+func (self *GetConfigReply) SetFlags(v ConfigFlags) {
+	self.Flags = v
+}
+
+func (self *GetConfigReply) GetMissSendLen() uint16 {
+	return self.MissSendLen
+}
+
+func (self *GetConfigReply) SetMissSendLen(v uint16) {
+	self.MissSendLen = v
+}
+
+func (self *GetConfigReply) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.Header.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Flags))
+	encoder.PutUint16(uint16(self.MissSendLen))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeGetConfigReply(parent *Header, decoder *goloxi.Decoder) (*GetConfigReply, error) {
+	_getconfigreply := &GetConfigReply{Header: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("GetConfigReply packet too short: %d < 4", decoder.Length())
+	}
+	_getconfigreply.Flags = ConfigFlags(decoder.ReadUint16())
+	_getconfigreply.MissSendLen = uint16(decoder.ReadUint16())
+	return _getconfigreply, nil
+}
+
+func NewGetConfigReply() *GetConfigReply {
+	obj := &GetConfigReply{
+		Header: NewHeader(8),
+	}
+	return obj
+}
+
+type GetConfigRequest struct {
+	*Header
+}
+
+type IGetConfigRequest interface {
+	IHeader
+}
+
+func (self *GetConfigRequest) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.Header.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeGetConfigRequest(parent *Header, decoder *goloxi.Decoder) (*GetConfigRequest, error) {
+	_getconfigrequest := &GetConfigRequest{Header: parent}
+	return _getconfigrequest, nil
+}
+
+func NewGetConfigRequest() *GetConfigRequest {
+	obj := &GetConfigRequest{
+		Header: NewHeader(7),
+	}
+	return obj
+}
+
+type Hello struct {
+	*Header
+}
+
+type IHello interface {
+	IHeader
+}
+
+func (self *Hello) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.Header.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeHello(parent *Header, decoder *goloxi.Decoder) (*Hello, error) {
+	_hello := &Hello{Header: parent}
+	return _hello, nil
+}
+
+func NewHello() *Hello {
+	obj := &Hello{
+		Header: NewHeader(0),
+	}
+	return obj
+}
+
+type HelloFailedErrorMsg struct {
+	*ErrorMsg
+	Code HelloFailedCode
+	Data []byte
+}
+
+type IHelloFailedErrorMsg interface {
+	IErrorMsg
+	GetCode() HelloFailedCode
+	GetData() []byte
+}
+
+func (self *HelloFailedErrorMsg) GetCode() HelloFailedCode {
+	return self.Code
+}
+
+func (self *HelloFailedErrorMsg) SetCode(v HelloFailedCode) {
+	self.Code = v
+}
+
+func (self *HelloFailedErrorMsg) GetData() []byte {
+	return self.Data
+}
+
+func (self *HelloFailedErrorMsg) SetData(v []byte) {
+	self.Data = v
+}
+
+func (self *HelloFailedErrorMsg) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ErrorMsg.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Code))
+	encoder.Write(self.Data)
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeHelloFailedErrorMsg(parent *ErrorMsg, decoder *goloxi.Decoder) (*HelloFailedErrorMsg, error) {
+	_hellofailederrormsg := &HelloFailedErrorMsg{ErrorMsg: parent}
+	if decoder.Length() < 2 {
+		return nil, fmt.Errorf("HelloFailedErrorMsg packet too short: %d < 2", decoder.Length())
+	}
+	_hellofailederrormsg.Code = HelloFailedCode(decoder.ReadUint16())
+	_hellofailederrormsg.Data = decoder.Read(int(decoder.Length()))
+	return _hellofailederrormsg, nil
+}
+
+func NewHelloFailedErrorMsg() *HelloFailedErrorMsg {
+	obj := &HelloFailedErrorMsg{
+		ErrorMsg: NewErrorMsg(0),
+	}
+	return obj
+}
+
+type NiciraHeader struct {
+	*Experimenter
+	Subtype uint32
+}
+
+type INiciraHeader interface {
+	IExperimenter
+	GetSubtype() uint32
+}
+
+func (self *NiciraHeader) GetSubtype() uint32 {
+	return self.Subtype
+}
+
+func (self *NiciraHeader) SetSubtype(v uint32) {
+	self.Subtype = v
+}
+
+func (self *NiciraHeader) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Experimenter.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Subtype))
+
+	return nil
+}
+
+func DecodeNiciraHeader(parent *Experimenter, decoder *goloxi.Decoder) (INiciraHeader, error) {
+	_niciraheader := &NiciraHeader{Experimenter: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("NiciraHeader packet too short: %d < 4", decoder.Length())
+	}
+	_niciraheader.Subtype = uint32(decoder.ReadUint32())
+
+	switch _niciraheader.Subtype {
+	case 10:
+		return DecodeNiciraControllerRoleRequest(_niciraheader, decoder)
+	case 11:
+		return DecodeNiciraControllerRoleReply(_niciraheader, decoder)
+	default:
+		return nil, fmt.Errorf("Invalid type '%d' for 'NiciraHeader'", _niciraheader.Subtype)
+	}
+}
+
+func NewNiciraHeader(_subtype uint32) *NiciraHeader {
+	obj := &NiciraHeader{
+		Experimenter: NewExperimenter(8992),
+	}
+	obj.Subtype = _subtype
+	return obj
+}
+
+type NiciraControllerRoleReply struct {
+	*NiciraHeader
+	Role NiciraControllerRole
+}
+
+type INiciraControllerRoleReply interface {
+	INiciraHeader
+	GetRole() NiciraControllerRole
+}
+
+func (self *NiciraControllerRoleReply) GetRole() NiciraControllerRole {
+	return self.Role
+}
+
+func (self *NiciraControllerRoleReply) SetRole(v NiciraControllerRole) {
+	self.Role = v
+}
+
+func (self *NiciraControllerRoleReply) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.NiciraHeader.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Role))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeNiciraControllerRoleReply(parent *NiciraHeader, decoder *goloxi.Decoder) (*NiciraControllerRoleReply, error) {
+	_niciracontrollerrolereply := &NiciraControllerRoleReply{NiciraHeader: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("NiciraControllerRoleReply packet too short: %d < 4", decoder.Length())
+	}
+	_niciracontrollerrolereply.Role = NiciraControllerRole(decoder.ReadUint32())
+	return _niciracontrollerrolereply, nil
+}
+
+func NewNiciraControllerRoleReply() *NiciraControllerRoleReply {
+	obj := &NiciraControllerRoleReply{
+		NiciraHeader: NewNiciraHeader(11),
+	}
+	return obj
+}
+
+type NiciraControllerRoleRequest struct {
+	*NiciraHeader
+	Role NiciraControllerRole
+}
+
+type INiciraControllerRoleRequest interface {
+	INiciraHeader
+	GetRole() NiciraControllerRole
+}
+
+func (self *NiciraControllerRoleRequest) GetRole() NiciraControllerRole {
+	return self.Role
+}
+
+func (self *NiciraControllerRoleRequest) SetRole(v NiciraControllerRole) {
+	self.Role = v
+}
+
+func (self *NiciraControllerRoleRequest) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.NiciraHeader.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Role))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeNiciraControllerRoleRequest(parent *NiciraHeader, decoder *goloxi.Decoder) (*NiciraControllerRoleRequest, error) {
+	_niciracontrollerrolerequest := &NiciraControllerRoleRequest{NiciraHeader: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("NiciraControllerRoleRequest packet too short: %d < 4", decoder.Length())
+	}
+	_niciracontrollerrolerequest.Role = NiciraControllerRole(decoder.ReadUint32())
+	return _niciracontrollerrolerequest, nil
+}
+
+func NewNiciraControllerRoleRequest() *NiciraControllerRoleRequest {
+	obj := &NiciraControllerRoleRequest{
+		NiciraHeader: NewNiciraHeader(10),
+	}
+	return obj
+}
+
+type NiciraStatsReply struct {
+	*ExperimenterStatsReply
+	Subtype uint32
+}
+
+type INiciraStatsReply interface {
+	IExperimenterStatsReply
+	GetSubtype() uint32
+}
+
+func (self *NiciraStatsReply) GetSubtype() uint32 {
+	return self.Subtype
+}
+
+func (self *NiciraStatsReply) SetSubtype(v uint32) {
+	self.Subtype = v
+}
+
+func (self *NiciraStatsReply) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.ExperimenterStatsReply.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Subtype))
+
+	return nil
+}
+
+func DecodeNiciraStatsReply(parent *ExperimenterStatsReply, decoder *goloxi.Decoder) (INiciraStatsReply, error) {
+	_nicirastatsreply := &NiciraStatsReply{ExperimenterStatsReply: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("NiciraStatsReply packet too short: %d < 4", decoder.Length())
+	}
+	_nicirastatsreply.Subtype = uint32(decoder.ReadUint32())
+
+	switch _nicirastatsreply.Subtype {
+	case 0:
+		return DecodeNiciraFlowStatsReply(_nicirastatsreply, decoder)
+	case 2:
+		return DecodeNiciraFlowMonitorReply(_nicirastatsreply, decoder)
+	default:
+		return nil, fmt.Errorf("Invalid type '%d' for 'NiciraStatsReply'", _nicirastatsreply.Subtype)
+	}
+}
+
+func NewNiciraStatsReply(_subtype uint32) *NiciraStatsReply {
+	obj := &NiciraStatsReply{
+		ExperimenterStatsReply: NewExperimenterStatsReply(8992),
+	}
+	obj.Subtype = _subtype
+	return obj
+}
+
+type NiciraFlowMonitorReply struct {
+	*NiciraStatsReply
+	Updates []INiciraFlowUpdateEvent
+}
+
+type INiciraFlowMonitorReply interface {
+	INiciraStatsReply
+	GetUpdates() []INiciraFlowUpdateEvent
+}
+
+func (self *NiciraFlowMonitorReply) GetUpdates() []INiciraFlowUpdateEvent {
+	return self.Updates
+}
+
+func (self *NiciraFlowMonitorReply) SetUpdates(v []INiciraFlowUpdateEvent) {
+	self.Updates = v
+}
+
+func (self *NiciraFlowMonitorReply) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.NiciraStatsReply.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(bytes.Repeat([]byte{0}, 4))
+	for _, obj := range self.Updates {
+		if err := obj.Serialize(encoder); err != nil {
+			return err
+		}
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeNiciraFlowMonitorReply(parent *NiciraStatsReply, decoder *goloxi.Decoder) (*NiciraFlowMonitorReply, error) {
+	_niciraflowmonitorreply := &NiciraFlowMonitorReply{NiciraStatsReply: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("NiciraFlowMonitorReply packet too short: %d < 4", decoder.Length())
+	}
+	decoder.Skip(4)
+
+	for decoder.Length() >= 4 {
+		item, err := DecodeNiciraFlowUpdateEvent(decoder)
+		if err != nil {
+			return nil, err
+		}
+		if item != nil {
+			_niciraflowmonitorreply.Updates = append(_niciraflowmonitorreply.Updates, item)
+		}
+	}
+	return _niciraflowmonitorreply, nil
+}
+
+func NewNiciraFlowMonitorReply() *NiciraFlowMonitorReply {
+	obj := &NiciraFlowMonitorReply{
+		NiciraStatsReply: NewNiciraStatsReply(2),
+	}
+	return obj
+}
+
+type NiciraFlowMonitorRequest struct {
+	*ExperimenterStatsRequest
+	Subtype      uint32
+	MonitorId    uint32
+	MonitorFlags NxFlowMonitorFlags
+	OutPort      Port
+	MatchLen     uint16
+	TableId      uint8
+	Match        NiciraMatch
+}
+
+type INiciraFlowMonitorRequest interface {
+	IExperimenterStatsRequest
+	GetSubtype() uint32
+	GetMonitorId() uint32
+	GetMonitorFlags() NxFlowMonitorFlags
+	GetOutPort() Port
+	GetMatchLen() uint16
+	GetTableId() uint8
+	GetMatch() NiciraMatch
+}
+
+func (self *NiciraFlowMonitorRequest) GetSubtype() uint32 {
+	return self.Subtype
+}
+
+func (self *NiciraFlowMonitorRequest) SetSubtype(v uint32) {
+	self.Subtype = v
+}
+
+func (self *NiciraFlowMonitorRequest) GetMonitorId() uint32 {
+	return self.MonitorId
+}
+
+func (self *NiciraFlowMonitorRequest) SetMonitorId(v uint32) {
+	self.MonitorId = v
+}
+
+func (self *NiciraFlowMonitorRequest) GetMonitorFlags() NxFlowMonitorFlags {
+	return self.MonitorFlags
+}
+
+func (self *NiciraFlowMonitorRequest) SetMonitorFlags(v NxFlowMonitorFlags) {
+	self.MonitorFlags = v
+}
+
+func (self *NiciraFlowMonitorRequest) GetOutPort() Port {
+	return self.OutPort
+}
+
+func (self *NiciraFlowMonitorRequest) SetOutPort(v Port) {
+	self.OutPort = v
+}
+
+func (self *NiciraFlowMonitorRequest) GetMatchLen() uint16 {
+	return self.MatchLen
+}
+
+func (self *NiciraFlowMonitorRequest) SetMatchLen(v uint16) {
+	self.MatchLen = v
+}
+
+func (self *NiciraFlowMonitorRequest) GetTableId() uint8 {
+	return self.TableId
+}
+
+func (self *NiciraFlowMonitorRequest) SetTableId(v uint8) {
+	self.TableId = v
+}
+
+func (self *NiciraFlowMonitorRequest) GetMatch() NiciraMatch {
+	return self.Match
+}
+
+func (self *NiciraFlowMonitorRequest) SetMatch(v NiciraMatch) {
+	self.Match = v
+}
+
+func (self *NiciraFlowMonitorRequest) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ExperimenterStatsRequest.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Subtype))
+	encoder.Write(bytes.Repeat([]byte{0}, 4))
+	encoder.PutUint32(uint32(self.MonitorId))
+	encoder.PutUint16(uint16(self.MonitorFlags))
+	self.OutPort.Serialize(encoder)
+	encoder.PutUint16(uint16(self.MatchLen))
+	encoder.PutUint8(uint8(self.TableId))
+	encoder.Write(bytes.Repeat([]byte{0}, 5))
+	if err := self.Match.Serialize(encoder); err != nil {
+		return err
+	}
+
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeNiciraFlowMonitorRequest(parent *ExperimenterStatsRequest, decoder *goloxi.Decoder) (*NiciraFlowMonitorRequest, error) {
+	_niciraflowmonitorrequest := &NiciraFlowMonitorRequest{ExperimenterStatsRequest: parent}
+	if decoder.Length() < 24 {
+		return nil, fmt.Errorf("NiciraFlowMonitorRequest packet too short: %d < 24", decoder.Length())
+	}
+	_niciraflowmonitorrequest.Subtype = uint32(decoder.ReadUint32())
+	decoder.Skip(4)
+	_niciraflowmonitorrequest.MonitorId = uint32(decoder.ReadUint32())
+	_niciraflowmonitorrequest.MonitorFlags = NxFlowMonitorFlags(decoder.ReadUint16())
+	_niciraflowmonitorrequest.OutPort.Decode(decoder)
+	_niciraflowmonitorrequest.MatchLen = uint16(decoder.ReadUint16())
+	_niciraflowmonitorrequest.TableId = uint8(decoder.ReadByte())
+	decoder.Skip(5)
+	if err := _niciraflowmonitorrequest.Match.Decode(decoder); err != nil {
+		return nil, err
+	}
+
+	decoder.SkipAlign()
+	return _niciraflowmonitorrequest, nil
+}
+
+func NewNiciraFlowMonitorRequest() *NiciraFlowMonitorRequest {
+	obj := &NiciraFlowMonitorRequest{
+		ExperimenterStatsRequest: NewExperimenterStatsRequest(8992),
+	}
+	return obj
+}
+
+type NiciraFlowStatsReply struct {
+	*NiciraStatsReply
+	Stats []*NiciraFlowStats
+}
+
+type INiciraFlowStatsReply interface {
+	INiciraStatsReply
+	GetStats() []*NiciraFlowStats
+}
+
+func (self *NiciraFlowStatsReply) GetStats() []*NiciraFlowStats {
+	return self.Stats
+}
+
+func (self *NiciraFlowStatsReply) SetStats(v []*NiciraFlowStats) {
+	self.Stats = v
+}
+
+func (self *NiciraFlowStatsReply) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.NiciraStatsReply.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(bytes.Repeat([]byte{0}, 4))
+	for _, obj := range self.Stats {
+		if err := obj.Serialize(encoder); err != nil {
+			return err
+		}
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeNiciraFlowStatsReply(parent *NiciraStatsReply, decoder *goloxi.Decoder) (*NiciraFlowStatsReply, error) {
+	_niciraflowstatsreply := &NiciraFlowStatsReply{NiciraStatsReply: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("NiciraFlowStatsReply packet too short: %d < 4", decoder.Length())
+	}
+	decoder.Skip(4)
+
+	for decoder.Length() >= 48 {
+		item, err := DecodeNiciraFlowStats(decoder)
+		if err != nil {
+			return nil, err
+		}
+		if item != nil {
+			_niciraflowstatsreply.Stats = append(_niciraflowstatsreply.Stats, item)
+		}
+	}
+	return _niciraflowstatsreply, nil
+}
+
+func NewNiciraFlowStatsReply() *NiciraFlowStatsReply {
+	obj := &NiciraFlowStatsReply{
+		NiciraStatsReply: NewNiciraStatsReply(0),
+	}
+	return obj
+}
+
+type NiciraFlowStatsRequest struct {
+	*ExperimenterStatsRequest
+	Subtype  uint32
+	OutPort  Port
+	MatchLen uint16
+	TableId  uint8
+}
+
+type INiciraFlowStatsRequest interface {
+	IExperimenterStatsRequest
+	GetSubtype() uint32
+	GetOutPort() Port
+	GetMatchLen() uint16
+	GetTableId() uint8
+}
+
+func (self *NiciraFlowStatsRequest) GetSubtype() uint32 {
+	return self.Subtype
+}
+
+func (self *NiciraFlowStatsRequest) SetSubtype(v uint32) {
+	self.Subtype = v
+}
+
+func (self *NiciraFlowStatsRequest) GetOutPort() Port {
+	return self.OutPort
+}
+
+func (self *NiciraFlowStatsRequest) SetOutPort(v Port) {
+	self.OutPort = v
+}
+
+func (self *NiciraFlowStatsRequest) GetMatchLen() uint16 {
+	return self.MatchLen
+}
+
+func (self *NiciraFlowStatsRequest) SetMatchLen(v uint16) {
+	self.MatchLen = v
+}
+
+func (self *NiciraFlowStatsRequest) GetTableId() uint8 {
+	return self.TableId
+}
+
+func (self *NiciraFlowStatsRequest) SetTableId(v uint8) {
+	self.TableId = v
+}
+
+func (self *NiciraFlowStatsRequest) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ExperimenterStatsRequest.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Subtype))
+	encoder.Write(bytes.Repeat([]byte{0}, 4))
+	self.OutPort.Serialize(encoder)
+	encoder.PutUint16(uint16(self.MatchLen))
+	encoder.PutUint8(uint8(self.TableId))
+	encoder.Write(bytes.Repeat([]byte{0}, 3))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeNiciraFlowStatsRequest(parent *ExperimenterStatsRequest, decoder *goloxi.Decoder) (*NiciraFlowStatsRequest, error) {
+	_niciraflowstatsrequest := &NiciraFlowStatsRequest{ExperimenterStatsRequest: parent}
+	if decoder.Length() < 16 {
+		return nil, fmt.Errorf("NiciraFlowStatsRequest packet too short: %d < 16", decoder.Length())
+	}
+	_niciraflowstatsrequest.Subtype = uint32(decoder.ReadUint32())
+	decoder.Skip(4)
+	_niciraflowstatsrequest.OutPort.Decode(decoder)
+	_niciraflowstatsrequest.MatchLen = uint16(decoder.ReadUint16())
+	_niciraflowstatsrequest.TableId = uint8(decoder.ReadByte())
+	decoder.Skip(3)
+	return _niciraflowstatsrequest, nil
+}
+
+func NewNiciraFlowStatsRequest() *NiciraFlowStatsRequest {
+	obj := &NiciraFlowStatsRequest{
+		ExperimenterStatsRequest: NewExperimenterStatsRequest(8992),
+	}
+	return obj
+}
+
+type PacketIn struct {
+	*Header
+	BufferId uint32
+	TotalLen uint16
+	InPort   Port
+	Reason   uint8
+	Data     []byte
+}
+
+type IPacketIn interface {
+	IHeader
+	GetBufferId() uint32
+	GetTotalLen() uint16
+	GetInPort() Port
+	GetReason() uint8
+	GetData() []byte
+}
+
+func (self *PacketIn) GetBufferId() uint32 {
+	return self.BufferId
+}
+
+func (self *PacketIn) SetBufferId(v uint32) {
+	self.BufferId = v
+}
+
+func (self *PacketIn) GetTotalLen() uint16 {
+	return self.TotalLen
+}
+
+func (self *PacketIn) SetTotalLen(v uint16) {
+	self.TotalLen = v
+}
+
+func (self *PacketIn) GetInPort() Port {
+	return self.InPort
+}
+
+func (self *PacketIn) SetInPort(v Port) {
+	self.InPort = v
+}
+
+func (self *PacketIn) GetReason() uint8 {
+	return self.Reason
+}
+
+func (self *PacketIn) SetReason(v uint8) {
+	self.Reason = v
+}
+
+func (self *PacketIn) GetData() []byte {
+	return self.Data
+}
+
+func (self *PacketIn) SetData(v []byte) {
+	self.Data = v
+}
+
+func (self *PacketIn) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.Header.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.BufferId))
+	encoder.PutUint16(uint16(self.TotalLen))
+	self.InPort.Serialize(encoder)
+	encoder.PutUint8(uint8(self.Reason))
+	encoder.Write(bytes.Repeat([]byte{0}, 1))
+	encoder.Write(self.Data)
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodePacketIn(parent *Header, decoder *goloxi.Decoder) (*PacketIn, error) {
+	_packetin := &PacketIn{Header: parent}
+	if decoder.Length() < 10 {
+		return nil, fmt.Errorf("PacketIn packet too short: %d < 10", decoder.Length())
+	}
+	_packetin.BufferId = uint32(decoder.ReadUint32())
+	_packetin.TotalLen = uint16(decoder.ReadUint16())
+	_packetin.InPort.Decode(decoder)
+	_packetin.Reason = uint8(decoder.ReadByte())
+	decoder.Skip(1)
+	_packetin.Data = decoder.Read(int(decoder.Length()))
+	return _packetin, nil
+}
+
+func NewPacketIn() *PacketIn {
+	obj := &PacketIn{
+		Header: NewHeader(10),
+	}
+	return obj
+}
+
+type PacketOut struct {
+	*Header
+	BufferId   uint32
+	InPort     Port
+	ActionsLen uint16
+	Actions    []goloxi.IAction
+	Data       []byte
+}
+
+type IPacketOut interface {
+	IHeader
+	GetBufferId() uint32
+	GetInPort() Port
+	GetActionsLen() uint16
+	GetActions() []goloxi.IAction
+	GetData() []byte
+}
+
+func (self *PacketOut) GetBufferId() uint32 {
+	return self.BufferId
+}
+
+func (self *PacketOut) SetBufferId(v uint32) {
+	self.BufferId = v
+}
+
+func (self *PacketOut) GetInPort() Port {
+	return self.InPort
+}
+
+func (self *PacketOut) SetInPort(v Port) {
+	self.InPort = v
+}
+
+func (self *PacketOut) GetActionsLen() uint16 {
+	return self.ActionsLen
+}
+
+func (self *PacketOut) SetActionsLen(v uint16) {
+	self.ActionsLen = v
+}
+
+func (self *PacketOut) GetActions() []goloxi.IAction {
+	return self.Actions
+}
+
+func (self *PacketOut) SetActions(v []goloxi.IAction) {
+	self.Actions = v
+}
+
+func (self *PacketOut) GetData() []byte {
+	return self.Data
+}
+
+func (self *PacketOut) SetData(v []byte) {
+	self.Data = v
+}
+
+func (self *PacketOut) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.Header.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.BufferId))
+	self.InPort.Serialize(encoder)
+	encoder.PutUint16(uint16(self.ActionsLen))
+	for _, obj := range self.Actions {
+		if err := obj.Serialize(encoder); err != nil {
+			return err
+		}
+	}
+	encoder.Write(self.Data)
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodePacketOut(parent *Header, decoder *goloxi.Decoder) (*PacketOut, error) {
+	_packetout := &PacketOut{Header: parent}
+	if decoder.Length() < 8 {
+		return nil, fmt.Errorf("PacketOut packet too short: %d < 8", decoder.Length())
+	}
+	_packetout.BufferId = uint32(decoder.ReadUint32())
+	_packetout.InPort.Decode(decoder)
+	_packetout.ActionsLen = uint16(decoder.ReadUint16())
+
+	end := decoder.Offset() + int(_packetout.ActionsLen)
+	for decoder.Offset() < end {
+		item, err := DecodeAction(decoder)
+		if err != nil {
+			return nil, err
+		}
+		if item != nil {
+			_packetout.Actions = append(_packetout.Actions, item)
+		}
+	}
+	_packetout.Data = decoder.Read(int(decoder.Length()))
+	return _packetout, nil
+}
+
+func NewPacketOut() *PacketOut {
+	obj := &PacketOut{
+		Header: NewHeader(13),
+	}
+	return obj
+}
+
+type PortMod struct {
+	*Header
+	PortNo    Port
+	HwAddr    net.HardwareAddr
+	Config    PortConfig
+	Mask      PortConfig
+	Advertise uint32
+}
+
+type IPortMod interface {
+	IHeader
+	GetPortNo() Port
+	GetHwAddr() net.HardwareAddr
+	GetConfig() PortConfig
+	GetMask() PortConfig
+	GetAdvertise() uint32
+}
+
+func (self *PortMod) GetPortNo() Port {
+	return self.PortNo
+}
+
+func (self *PortMod) SetPortNo(v Port) {
+	self.PortNo = v
+}
+
+func (self *PortMod) GetHwAddr() net.HardwareAddr {
+	return self.HwAddr
+}
+
+func (self *PortMod) SetHwAddr(v net.HardwareAddr) {
+	self.HwAddr = v
+}
+
+func (self *PortMod) GetConfig() PortConfig {
+	return self.Config
+}
+
+func (self *PortMod) SetConfig(v PortConfig) {
+	self.Config = v
+}
+
+func (self *PortMod) GetMask() PortConfig {
+	return self.Mask
+}
+
+func (self *PortMod) SetMask(v PortConfig) {
+	self.Mask = v
+}
+
+func (self *PortMod) GetAdvertise() uint32 {
+	return self.Advertise
+}
+
+func (self *PortMod) SetAdvertise(v uint32) {
+	self.Advertise = v
+}
+
+func (self *PortMod) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.Header.Serialize(encoder); err != nil {
+		return err
+	}
+
+	self.PortNo.Serialize(encoder)
+	encoder.Write(self.HwAddr)
+	encoder.PutUint32(uint32(self.Config))
+	encoder.PutUint32(uint32(self.Mask))
+	encoder.PutUint32(uint32(self.Advertise))
+	encoder.Write(bytes.Repeat([]byte{0}, 4))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodePortMod(parent *Header, decoder *goloxi.Decoder) (*PortMod, error) {
+	_portmod := &PortMod{Header: parent}
+	if decoder.Length() < 24 {
+		return nil, fmt.Errorf("PortMod packet too short: %d < 24", decoder.Length())
+	}
+	_portmod.PortNo.Decode(decoder)
+	_portmod.HwAddr = net.HardwareAddr(decoder.Read(6))
+	_portmod.Config = PortConfig(decoder.ReadUint32())
+	_portmod.Mask = PortConfig(decoder.ReadUint32())
+	_portmod.Advertise = uint32(decoder.ReadUint32())
+	decoder.Skip(4)
+	return _portmod, nil
+}
+
+func NewPortMod() *PortMod {
+	obj := &PortMod{
+		Header: NewHeader(15),
+	}
+	return obj
+}
+
+type PortModFailedErrorMsg struct {
+	*ErrorMsg
+	Code PortModFailedCode
+	Data []byte
+}
+
+type IPortModFailedErrorMsg interface {
+	IErrorMsg
+	GetCode() PortModFailedCode
+	GetData() []byte
+}
+
+func (self *PortModFailedErrorMsg) GetCode() PortModFailedCode {
+	return self.Code
+}
+
+func (self *PortModFailedErrorMsg) SetCode(v PortModFailedCode) {
+	self.Code = v
+}
+
+func (self *PortModFailedErrorMsg) GetData() []byte {
+	return self.Data
+}
+
+func (self *PortModFailedErrorMsg) SetData(v []byte) {
+	self.Data = v
+}
+
+func (self *PortModFailedErrorMsg) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ErrorMsg.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Code))
+	encoder.Write(self.Data)
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodePortModFailedErrorMsg(parent *ErrorMsg, decoder *goloxi.Decoder) (*PortModFailedErrorMsg, error) {
+	_portmodfailederrormsg := &PortModFailedErrorMsg{ErrorMsg: parent}
+	if decoder.Length() < 2 {
+		return nil, fmt.Errorf("PortModFailedErrorMsg packet too short: %d < 2", decoder.Length())
+	}
+	_portmodfailederrormsg.Code = PortModFailedCode(decoder.ReadUint16())
+	_portmodfailederrormsg.Data = decoder.Read(int(decoder.Length()))
+	return _portmodfailederrormsg, nil
+}
+
+func NewPortModFailedErrorMsg() *PortModFailedErrorMsg {
+	obj := &PortModFailedErrorMsg{
+		ErrorMsg: NewErrorMsg(4),
+	}
+	return obj
+}
+
+type PortStatsReply struct {
+	*StatsReply
+	Entries []*PortStatsEntry
+}
+
+type IPortStatsReply interface {
+	IStatsReply
+	GetEntries() []*PortStatsEntry
+}
+
+func (self *PortStatsReply) GetEntries() []*PortStatsEntry {
+	return self.Entries
+}
+
+func (self *PortStatsReply) SetEntries(v []*PortStatsEntry) {
+	self.Entries = v
+}
+
+func (self *PortStatsReply) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.StatsReply.Serialize(encoder); err != nil {
+		return err
+	}
+
+	for _, obj := range self.Entries {
+		if err := obj.Serialize(encoder); err != nil {
+			return err
+		}
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodePortStatsReply(parent *StatsReply, decoder *goloxi.Decoder) (*PortStatsReply, error) {
+	_portstatsreply := &PortStatsReply{StatsReply: parent}
+
+	for decoder.Length() >= 104 {
+		item, err := DecodePortStatsEntry(decoder)
+		if err != nil {
+			return nil, err
+		}
+		if item != nil {
+			_portstatsreply.Entries = append(_portstatsreply.Entries, item)
+		}
+	}
+	return _portstatsreply, nil
+}
+
+func NewPortStatsReply() *PortStatsReply {
+	obj := &PortStatsReply{
+		StatsReply: NewStatsReply(4),
+	}
+	return obj
+}
+
+type PortStatsRequest struct {
+	*StatsRequest
+	PortNo Port
+}
+
+type IPortStatsRequest interface {
+	IStatsRequest
+	GetPortNo() Port
+}
+
+func (self *PortStatsRequest) GetPortNo() Port {
+	return self.PortNo
+}
+
+func (self *PortStatsRequest) SetPortNo(v Port) {
+	self.PortNo = v
+}
+
+func (self *PortStatsRequest) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.StatsRequest.Serialize(encoder); err != nil {
+		return err
+	}
+
+	self.PortNo.Serialize(encoder)
+	encoder.Write(bytes.Repeat([]byte{0}, 6))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodePortStatsRequest(parent *StatsRequest, decoder *goloxi.Decoder) (*PortStatsRequest, error) {
+	_portstatsrequest := &PortStatsRequest{StatsRequest: parent}
+	if decoder.Length() < 8 {
+		return nil, fmt.Errorf("PortStatsRequest packet too short: %d < 8", decoder.Length())
+	}
+	_portstatsrequest.PortNo.Decode(decoder)
+	decoder.Skip(6)
+	return _portstatsrequest, nil
+}
+
+func NewPortStatsRequest() *PortStatsRequest {
+	obj := &PortStatsRequest{
+		StatsRequest: NewStatsRequest(4),
+	}
+	return obj
+}
+
+type PortStatus struct {
+	*Header
+	Reason PortReason
+	Desc   PortDesc
+}
+
+type IPortStatus interface {
+	IHeader
+	GetReason() PortReason
+	GetDesc() PortDesc
+}
+
+func (self *PortStatus) GetReason() PortReason {
+	return self.Reason
+}
+
+func (self *PortStatus) SetReason(v PortReason) {
+	self.Reason = v
+}
+
+func (self *PortStatus) GetDesc() PortDesc {
+	return self.Desc
+}
+
+func (self *PortStatus) SetDesc(v PortDesc) {
+	self.Desc = v
+}
+
+func (self *PortStatus) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.Header.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint8(uint8(self.Reason))
+	encoder.Write(bytes.Repeat([]byte{0}, 7))
+	if err := self.Desc.Serialize(encoder); err != nil {
+		return err
+	}
+
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodePortStatus(parent *Header, decoder *goloxi.Decoder) (*PortStatus, error) {
+	_portstatus := &PortStatus{Header: parent}
+	if decoder.Length() < 56 {
+		return nil, fmt.Errorf("PortStatus packet too short: %d < 56", decoder.Length())
+	}
+	_portstatus.Reason = PortReason(decoder.ReadByte())
+	decoder.Skip(7)
+	if err := _portstatus.Desc.Decode(decoder); err != nil {
+		return nil, err
+	}
+
+	return _portstatus, nil
+}
+
+func NewPortStatus() *PortStatus {
+	obj := &PortStatus{
+		Header: NewHeader(12),
+	}
+	return obj
+}
+
+type QueueGetConfigReply struct {
+	*Header
+	Port   Port
+	Queues []*PacketQueue
+}
+
+type IQueueGetConfigReply interface {
+	IHeader
+	GetPort() Port
+	GetQueues() []*PacketQueue
+}
+
+func (self *QueueGetConfigReply) GetPort() Port {
+	return self.Port
+}
+
+func (self *QueueGetConfigReply) SetPort(v Port) {
+	self.Port = v
+}
+
+func (self *QueueGetConfigReply) GetQueues() []*PacketQueue {
+	return self.Queues
+}
+
+func (self *QueueGetConfigReply) SetQueues(v []*PacketQueue) {
+	self.Queues = v
+}
+
+func (self *QueueGetConfigReply) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.Header.Serialize(encoder); err != nil {
+		return err
+	}
+
+	self.Port.Serialize(encoder)
+	encoder.Write(bytes.Repeat([]byte{0}, 6))
+	for _, obj := range self.Queues {
+		if err := obj.Serialize(encoder); err != nil {
+			return err
+		}
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeQueueGetConfigReply(parent *Header, decoder *goloxi.Decoder) (*QueueGetConfigReply, error) {
+	_queuegetconfigreply := &QueueGetConfigReply{Header: parent}
+	if decoder.Length() < 8 {
+		return nil, fmt.Errorf("QueueGetConfigReply packet too short: %d < 8", decoder.Length())
+	}
+	_queuegetconfigreply.Port.Decode(decoder)
+	decoder.Skip(6)
+
+	for decoder.Length() >= 8 {
+		item, err := DecodePacketQueue(decoder)
+		if err != nil {
+			return nil, err
+		}
+		if item != nil {
+			_queuegetconfigreply.Queues = append(_queuegetconfigreply.Queues, item)
+		}
+	}
+	return _queuegetconfigreply, nil
+}
+
+func NewQueueGetConfigReply() *QueueGetConfigReply {
+	obj := &QueueGetConfigReply{
+		Header: NewHeader(21),
+	}
+	return obj
+}
+
+type QueueGetConfigRequest struct {
+	*Header
+	Port Port
+}
+
+type IQueueGetConfigRequest interface {
+	IHeader
+	GetPort() Port
+}
+
+func (self *QueueGetConfigRequest) GetPort() Port {
+	return self.Port
+}
+
+func (self *QueueGetConfigRequest) SetPort(v Port) {
+	self.Port = v
+}
+
+func (self *QueueGetConfigRequest) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.Header.Serialize(encoder); err != nil {
+		return err
+	}
+
+	self.Port.Serialize(encoder)
+	encoder.Write(bytes.Repeat([]byte{0}, 2))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeQueueGetConfigRequest(parent *Header, decoder *goloxi.Decoder) (*QueueGetConfigRequest, error) {
+	_queuegetconfigrequest := &QueueGetConfigRequest{Header: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("QueueGetConfigRequest packet too short: %d < 4", decoder.Length())
+	}
+	_queuegetconfigrequest.Port.Decode(decoder)
+	decoder.Skip(2)
+	return _queuegetconfigrequest, nil
+}
+
+func NewQueueGetConfigRequest() *QueueGetConfigRequest {
+	obj := &QueueGetConfigRequest{
+		Header: NewHeader(20),
+	}
+	return obj
+}
+
+type QueueOpFailedErrorMsg struct {
+	*ErrorMsg
+	Code QueueOpFailedCode
+	Data []byte
+}
+
+type IQueueOpFailedErrorMsg interface {
+	IErrorMsg
+	GetCode() QueueOpFailedCode
+	GetData() []byte
+}
+
+func (self *QueueOpFailedErrorMsg) GetCode() QueueOpFailedCode {
+	return self.Code
+}
+
+func (self *QueueOpFailedErrorMsg) SetCode(v QueueOpFailedCode) {
+	self.Code = v
+}
+
+func (self *QueueOpFailedErrorMsg) GetData() []byte {
+	return self.Data
+}
+
+func (self *QueueOpFailedErrorMsg) SetData(v []byte) {
+	self.Data = v
+}
+
+func (self *QueueOpFailedErrorMsg) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.ErrorMsg.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Code))
+	encoder.Write(self.Data)
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeQueueOpFailedErrorMsg(parent *ErrorMsg, decoder *goloxi.Decoder) (*QueueOpFailedErrorMsg, error) {
+	_queueopfailederrormsg := &QueueOpFailedErrorMsg{ErrorMsg: parent}
+	if decoder.Length() < 2 {
+		return nil, fmt.Errorf("QueueOpFailedErrorMsg packet too short: %d < 2", decoder.Length())
+	}
+	_queueopfailederrormsg.Code = QueueOpFailedCode(decoder.ReadUint16())
+	_queueopfailederrormsg.Data = decoder.Read(int(decoder.Length()))
+	return _queueopfailederrormsg, nil
+}
+
+func NewQueueOpFailedErrorMsg() *QueueOpFailedErrorMsg {
+	obj := &QueueOpFailedErrorMsg{
+		ErrorMsg: NewErrorMsg(5),
+	}
+	return obj
+}
+
+type QueueStatsReply struct {
+	*StatsReply
+	Entries []*QueueStatsEntry
+}
+
+type IQueueStatsReply interface {
+	IStatsReply
+	GetEntries() []*QueueStatsEntry
+}
+
+func (self *QueueStatsReply) GetEntries() []*QueueStatsEntry {
+	return self.Entries
+}
+
+func (self *QueueStatsReply) SetEntries(v []*QueueStatsEntry) {
+	self.Entries = v
+}
+
+func (self *QueueStatsReply) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.StatsReply.Serialize(encoder); err != nil {
+		return err
+	}
+
+	for _, obj := range self.Entries {
+		if err := obj.Serialize(encoder); err != nil {
+			return err
+		}
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeQueueStatsReply(parent *StatsReply, decoder *goloxi.Decoder) (*QueueStatsReply, error) {
+	_queuestatsreply := &QueueStatsReply{StatsReply: parent}
+
+	for decoder.Length() >= 32 {
+		item, err := DecodeQueueStatsEntry(decoder)
+		if err != nil {
+			return nil, err
+		}
+		if item != nil {
+			_queuestatsreply.Entries = append(_queuestatsreply.Entries, item)
+		}
+	}
+	return _queuestatsreply, nil
+}
+
+func NewQueueStatsReply() *QueueStatsReply {
+	obj := &QueueStatsReply{
+		StatsReply: NewStatsReply(5),
+	}
+	return obj
+}
+
+type QueueStatsRequest struct {
+	*StatsRequest
+	PortNo  Port
+	QueueId uint32
+}
+
+type IQueueStatsRequest interface {
+	IStatsRequest
+	GetPortNo() Port
+	GetQueueId() uint32
+}
+
+func (self *QueueStatsRequest) GetPortNo() Port {
+	return self.PortNo
+}
+
+func (self *QueueStatsRequest) SetPortNo(v Port) {
+	self.PortNo = v
+}
+
+func (self *QueueStatsRequest) GetQueueId() uint32 {
+	return self.QueueId
+}
+
+func (self *QueueStatsRequest) SetQueueId(v uint32) {
+	self.QueueId = v
+}
+
+func (self *QueueStatsRequest) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.StatsRequest.Serialize(encoder); err != nil {
+		return err
+	}
+
+	self.PortNo.Serialize(encoder)
+	encoder.Write(bytes.Repeat([]byte{0}, 2))
+	encoder.PutUint32(uint32(self.QueueId))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeQueueStatsRequest(parent *StatsRequest, decoder *goloxi.Decoder) (*QueueStatsRequest, error) {
+	_queuestatsrequest := &QueueStatsRequest{StatsRequest: parent}
+	if decoder.Length() < 8 {
+		return nil, fmt.Errorf("QueueStatsRequest packet too short: %d < 8", decoder.Length())
+	}
+	_queuestatsrequest.PortNo.Decode(decoder)
+	decoder.Skip(2)
+	_queuestatsrequest.QueueId = uint32(decoder.ReadUint32())
+	return _queuestatsrequest, nil
+}
+
+func NewQueueStatsRequest() *QueueStatsRequest {
+	obj := &QueueStatsRequest{
+		StatsRequest: NewStatsRequest(5),
+	}
+	return obj
+}
+
+type SetConfig struct {
+	*Header
+	Flags       ConfigFlags
+	MissSendLen uint16
+}
+
+type ISetConfig interface {
+	IHeader
+	GetFlags() ConfigFlags
+	GetMissSendLen() uint16
+}
+
+func (self *SetConfig) GetFlags() ConfigFlags {
+	return self.Flags
+}
+
+func (self *SetConfig) SetFlags(v ConfigFlags) {
+	self.Flags = v
+}
+
+func (self *SetConfig) GetMissSendLen() uint16 {
+	return self.MissSendLen
+}
+
+func (self *SetConfig) SetMissSendLen(v uint16) {
+	self.MissSendLen = v
+}
+
+func (self *SetConfig) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.Header.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Flags))
+	encoder.PutUint16(uint16(self.MissSendLen))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeSetConfig(parent *Header, decoder *goloxi.Decoder) (*SetConfig, error) {
+	_setconfig := &SetConfig{Header: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("SetConfig packet too short: %d < 4", decoder.Length())
+	}
+	_setconfig.Flags = ConfigFlags(decoder.ReadUint16())
+	_setconfig.MissSendLen = uint16(decoder.ReadUint16())
+	return _setconfig, nil
+}
+
+func NewSetConfig() *SetConfig {
+	obj := &SetConfig{
+		Header: NewHeader(9),
+	}
+	return obj
+}
+
+type TableMod struct {
+	*Header
+	TableId uint8
+	Config  uint32
+}
+
+type ITableMod interface {
+	IHeader
+	GetTableId() uint8
+	GetConfig() uint32
+}
+
+func (self *TableMod) GetTableId() uint8 {
+	return self.TableId
+}
+
+func (self *TableMod) SetTableId(v uint8) {
+	self.TableId = v
+}
+
+func (self *TableMod) GetConfig() uint32 {
+	return self.Config
+}
+
+func (self *TableMod) SetConfig(v uint32) {
+	self.Config = v
+}
+
+func (self *TableMod) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.Header.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint8(uint8(self.TableId))
+	encoder.Write(bytes.Repeat([]byte{0}, 3))
+	encoder.PutUint32(uint32(self.Config))
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeTableMod(parent *Header, decoder *goloxi.Decoder) (*TableMod, error) {
+	_tablemod := &TableMod{Header: parent}
+	if decoder.Length() < 8 {
+		return nil, fmt.Errorf("TableMod packet too short: %d < 8", decoder.Length())
+	}
+	_tablemod.TableId = uint8(decoder.ReadByte())
+	decoder.Skip(3)
+	_tablemod.Config = uint32(decoder.ReadUint32())
+	return _tablemod, nil
+}
+
+func NewTableMod() *TableMod {
+	obj := &TableMod{
+		Header: NewHeader(22),
+	}
+	return obj
+}
+
+type TableStatsReply struct {
+	*StatsReply
+	Entries []*TableStatsEntry
+}
+
+type ITableStatsReply interface {
+	IStatsReply
+	GetEntries() []*TableStatsEntry
+}
+
+func (self *TableStatsReply) GetEntries() []*TableStatsEntry {
+	return self.Entries
+}
+
+func (self *TableStatsReply) SetEntries(v []*TableStatsEntry) {
+	self.Entries = v
+}
+
+func (self *TableStatsReply) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.StatsReply.Serialize(encoder); err != nil {
+		return err
+	}
+
+	for _, obj := range self.Entries {
+		if err := obj.Serialize(encoder); err != nil {
+			return err
+		}
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeTableStatsReply(parent *StatsReply, decoder *goloxi.Decoder) (*TableStatsReply, error) {
+	_tablestatsreply := &TableStatsReply{StatsReply: parent}
+
+	for decoder.Length() >= 64 {
+		item, err := DecodeTableStatsEntry(decoder)
+		if err != nil {
+			return nil, err
+		}
+		if item != nil {
+			_tablestatsreply.Entries = append(_tablestatsreply.Entries, item)
+		}
+	}
+	return _tablestatsreply, nil
+}
+
+func NewTableStatsReply() *TableStatsReply {
+	obj := &TableStatsReply{
+		StatsReply: NewStatsReply(3),
+	}
+	return obj
+}
+
+type TableStatsRequest struct {
+	*StatsRequest
+}
+
+type ITableStatsRequest interface {
+	IStatsRequest
+}
+
+func (self *TableStatsRequest) Serialize(encoder *goloxi.Encoder) error {
+	startIndex := len(encoder.Bytes())
+	if err := self.StatsRequest.Serialize(encoder); err != nil {
+		return err
+	}
+	length := len(encoder.Bytes()) - startIndex
+
+	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
+
+	return nil
+}
+
+func DecodeTableStatsRequest(parent *StatsRequest, decoder *goloxi.Decoder) (*TableStatsRequest, error) {
+	_tablestatsrequest := &TableStatsRequest{StatsRequest: parent}
+	return _tablestatsrequest, nil
+}
+
+func NewTableStatsRequest() *TableStatsRequest {
+	obj := &TableStatsRequest{
+		StatsRequest: NewStatsRequest(3),
+	}
+	return obj
+}
diff --git a/of10/oxm.go b/of10/oxm.go
new file mode 100644
index 0000000..1a60627
--- /dev/null
+++ b/of10/oxm.go
@@ -0,0 +1,24884 @@
+/*
+ * Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
+ * Copyright (c) 2011, 2012 Open Networking Foundation
+ * Copyright 2013, Big Switch Networks, Inc. This library was generated by the LoxiGen Compiler.
+ * Copyright 2018, Red Hat, Inc.
+ */
+// Automatically generated by LOXI from template module.go
+// Do not modify
+
+package of10
+
+import (
+	"fmt"
+	"net"
+
+	"github.com/opencord/goloxi"
+)
+
+type Oxm struct {
+	TypeLen uint32
+}
+
+type IOxm interface {
+	goloxi.Serializable
+	GetTypeLen() uint32
+	GetOXMName() string
+	GetOXMValue() interface{}
+}
+
+func (self *Oxm) GetTypeLen() uint32 {
+	return self.TypeLen
+}
+
+func (self *Oxm) SetTypeLen(v uint32) {
+	self.TypeLen = v
+}
+
+func (self *Oxm) Serialize(encoder *goloxi.Encoder) error {
+
+	encoder.PutUint32(uint32(self.TypeLen))
+
+	return nil
+}
+
+func DecodeOxm(decoder *goloxi.Decoder) (goloxi.IOxm, error) {
+	_oxm := &Oxm{}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("Oxm packet too short: %d < 4", decoder.Length())
+	}
+	_oxm.TypeLen = uint32(decoder.ReadUint32())
+
+	switch _oxm.TypeLen {
+	case 126465:
+		return DecodeOxmConnTrackingNwProto(_oxm, decoder)
+	case 7682:
+		return DecodeNxmArpOp(_oxm, decoder)
+	case 2147500550:
+		return DecodeOxmIpv6NdTll(_oxm, decoder)
+	case 84484:
+		return DecodeNxmConjId(_oxm, decoder)
+	case 105976:
+		return DecodeNxmTunMetadata38Masked(_oxm, decoder)
+	case 74246:
+		return DecodeNxmArpSha(_oxm, decoder)
+	case 7169:
+		return DecodeNxmIcmpCode(_oxm, decoder)
+	case 73736:
+		return DecodeNxmTunId(_oxm, decoder)
+	case 2147484424:
+		return DecodeOxmInPhyPortMasked(_oxm, decoder)
+	case 70408:
+		return DecodeNxmReg9Masked(_oxm, decoder)
+	case 129026:
+		return DecodeOxmConnTrackingTpSrc(_oxm, decoder)
+	case 127492:
+		return DecodeOxmConnTrackingNwDst(_oxm, decoder)
+	case 2147484680:
+		return DecodeOxmMetadata(_oxm, decoder)
+	case 128528:
+		return DecodeOxmConnTrackingIpv6Dst(_oxm, decoder)
+	case 94332:
+		return DecodeNxmTunMetadata16(_oxm, decoder)
+	case 129538:
+		return DecodeOxmConnTrackingTpDst(_oxm, decoder)
+	case 108536:
+		return DecodeNxmTunMetadata43Masked(_oxm, decoder)
+	case 106488:
+		return DecodeNxmTunMetadata39Masked(_oxm, decoder)
+	case 112764:
+		return DecodeNxmTunMetadata52(_oxm, decoder)
+	case 8708:
+		return DecodeNxmArpTpa(_oxm, decoder)
+	case 2147498754:
+		return DecodeOxmIcmpv6TypeMasked(_oxm, decoder)
+	case 2147493634:
+		return DecodeOxmIcmpv4TypeMasked(_oxm, decoder)
+	case 89080:
+		return DecodeNxmTunMetadata5Masked(_oxm, decoder)
+	case 94844:
+		return DecodeNxmTunMetadata17(_oxm, decoder)
+	case 2147499009:
+		return DecodeOxmIcmpv6Code(_oxm, decoder)
+	case 74758:
+		return DecodeNxmArpTha(_oxm, decoder)
+	case 2147498248:
+		return DecodeOxmIpv6FlabelMasked(_oxm, decoder)
+	case 99964:
+		return DecodeNxmTunMetadata27(_oxm, decoder)
+	case 67336:
+		return DecodeNxmReg3Masked(_oxm, decoder)
+	case 115192:
+		return DecodeNxmTunMetadata56Masked(_oxm, decoder)
+	case 71172:
+		return DecodeNxmReg11(_oxm, decoder)
+	case 79364:
+		return DecodeNxmIpv6Label(_oxm, decoder)
+	case 73480:
+		return DecodeNxmReg15Masked(_oxm, decoder)
+	case 2147495688:
+		return DecodeOxmArpTpaMasked(_oxm, decoder)
+	case 120068:
+		return DecodeOxmConnTrackingZoneMasked(_oxm, decoder)
+	case 107512:
+		return DecodeNxmTunMetadata41Masked(_oxm, decoder)
+	case 116348:
+		return DecodeNxmTunMetadata59(_oxm, decoder)
+	case 89592:
+		return DecodeNxmTunMetadata6Masked(_oxm, decoder)
+	case 110204:
+		return DecodeNxmTunMetadata47(_oxm, decoder)
+	case 77830:
+		return DecodeNxmNdSll(_oxm, decoder)
+	case 117372:
+		return DecodeNxmTunMetadata61(_oxm, decoder)
+	case 2147489796:
+		return DecodeOxmIpv4Dst(_oxm, decoder)
+	case 2147497988:
+		return DecodeOxmIpv6Flabel(_oxm, decoder)
+	case 103928:
+		return DecodeNxmTunMetadata34Masked(_oxm, decoder)
+	case 2147485452:
+		return DecodeOxmEthDstMasked(_oxm, decoder)
+	case 95868:
+		return DecodeNxmTunMetadata19(_oxm, decoder)
+	case 2:
+		return DecodeNxmInPort(_oxm, decoder)
+	case 74507:
+		return DecodeNxmArpShaMasked(_oxm, decoder)
+	case 96892:
+		return DecodeNxmTunMetadata21(_oxm, decoder)
+	case 108024:
+		return DecodeNxmTunMetadata42Masked(_oxm, decoder)
+	case 129284:
+		return DecodeOxmConnTrackingTpSrcMasked(_oxm, decoder)
+	case 112120:
+		return DecodeNxmTunMetadata50Masked(_oxm, decoder)
+	case 2147484944:
+		return DecodeOxmMetadataMasked(_oxm, decoder)
+	case 2147496716:
+		return DecodeOxmArpThaMasked(_oxm, decoder)
+	case 78342:
+		return DecodeNxmNdTll(_oxm, decoder)
+	case 2147486468:
+		return DecodeOxmEthTypeMasked(_oxm, decoder)
+	case 96380:
+		return DecodeNxmTunMetadata20(_oxm, decoder)
+	case 113276:
+		return DecodeNxmTunMetadata53(_oxm, decoder)
+	case 92152:
+		return DecodeNxmTunMetadata11Masked(_oxm, decoder)
+	case 129796:
+		return DecodeOxmConnTrackingTpDstMasked(_oxm, decoder)
+	case 103548:
+		return DecodeNxmTunMetadata34(_oxm, decoder)
+	case 120324:
+		return DecodeOxmConnTrackingMark(_oxm, decoder)
+	case 118776:
+		return DecodeNxmTunMetadata63Masked(_oxm, decoder)
+	case 90748:
+		return DecodeNxmTunMetadata9(_oxm, decoder)
+	case 128016:
+		return DecodeOxmConnTrackingIpv6Src(_oxm, decoder)
+	case 82946:
+		return DecodeNxmTcpFlags(_oxm, decoder)
+	case 2147483912:
+		return DecodeOxmInPortMasked(_oxm, decoder)
+	case 80897:
+		return DecodeNxmMplsTtl(_oxm, decoder)
+	case 92664:
+		return DecodeNxmTunMetadata12Masked(_oxm, decoder)
+	case 123408:
+		return DecodeNxmXxreg2(_oxm, decoder)
+	case 2147499266:
+		return DecodeOxmIcmpv6CodeMasked(_oxm, decoder)
+	case 2147489544:
+		return DecodeOxmIpv4SrcMasked(_oxm, decoder)
+	case 2147487490:
+		return DecodeOxmVlanPcpMasked(_oxm, decoder)
+	case 81412:
+		return DecodeNxmTunSrc(_oxm, decoder)
+	case 5122:
+		return DecodeNxmTcpDst(_oxm, decoder)
+	case 97404:
+		return DecodeNxmTunMetadata22(_oxm, decoder)
+	case 1538:
+		return DecodeNxmEthType(_oxm, decoder)
+	case 2561:
+		return DecodeNxmNwTos(_oxm, decoder)
+	case 93176:
+		return DecodeNxmTunMetadata13Masked(_oxm, decoder)
+	case 2147483652:
+		return DecodeOxmInPort(_oxm, decoder)
+	case 67848:
+		return DecodeNxmReg4Masked(_oxm, decoder)
+	case 115704:
+		return DecodeNxmTunMetadata57Masked(_oxm, decoder)
+	case 86140:
+		return DecodeNxmTunMetadata0(_oxm, decoder)
+	case 65540:
+		return DecodeNxmReg0(_oxm, decoder)
+	case 2147490306:
+		return DecodeOxmTcpSrc(_oxm, decoder)
+	case 2147500038:
+		return DecodeOxmIpv6NdSll(_oxm, decoder)
+	case 97916:
+		return DecodeNxmTunMetadata23(_oxm, decoder)
+	case 2050:
+		return DecodeNxmVlanTci(_oxm, decoder)
+	case 3073:
+		return DecodeNxmNwProto(_oxm, decoder)
+	case 93688:
+		return DecodeNxmTunMetadata14Masked(_oxm, decoder)
+	case 116860:
+		return DecodeNxmTunMetadata60(_oxm, decoder)
+	case 2147487233:
+		return DecodeOxmVlanPcp(_oxm, decoder)
+	case 2147484164:
+		return DecodeOxmInPhyPort(_oxm, decoder)
+	case 2147486980:
+		return DecodeOxmVlanVidMasked(_oxm, decoder)
+	case 113144:
+		return DecodeNxmTunMetadata52Masked(_oxm, decoder)
+	case 82436:
+		return DecodeNxmPktMark(_oxm, decoder)
+	case 121120:
+		return DecodeOxmConnTrackingLabelMasked(_oxm, decoder)
+	case 98428:
+		return DecodeNxmTunMetadata24(_oxm, decoder)
+	case 2147486210:
+		return DecodeOxmEthType(_oxm, decoder)
+	case 85505:
+		return DecodeNxmTunGbpFlags(_oxm, decoder)
+	case 94200:
+		return DecodeNxmTunMetadata15Masked(_oxm, decoder)
+	case 112632:
+		return DecodeNxmTunMetadata51Masked(_oxm, decoder)
+	case 5378:
+		return DecodeNxmTcpDstMasked(_oxm, decoder)
+	case 2147486722:
+		return DecodeOxmVlanVid(_oxm, decoder)
+	case 66564:
+		return DecodeNxmReg2(_oxm, decoder)
+	case 121632:
+		return DecodeNxmTunIpv6SrcMasked(_oxm, decoder)
+	case 103416:
+		return DecodeNxmTunMetadata33Masked(_oxm, decoder)
+	case 98940:
+		return DecodeNxmTunMetadata25(_oxm, decoder)
+	case 84994:
+		return DecodeNxmTunGbpId(_oxm, decoder)
+	case 2147485190:
+		return DecodeOxmEthDst(_oxm, decoder)
+	case 2147487745:
+		return DecodeOxmIpDscp(_oxm, decoder)
+	case 94712:
+		return DecodeNxmTunMetadata16Masked(_oxm, decoder)
+	case 120848:
+		return DecodeOxmConnTrackingLabel(_oxm, decoder)
+	case 109692:
+		return DecodeNxmTunMetadata46(_oxm, decoder)
+	case 69896:
+		return DecodeNxmReg8Masked(_oxm, decoder)
+	case 104060:
+		return DecodeNxmTunMetadata35(_oxm, decoder)
+	case 71432:
+		return DecodeNxmReg11Masked(_oxm, decoder)
+	case 110584:
+		return DecodeNxmTunMetadata47Masked(_oxm, decoder)
+	case 79624:
+		return DecodeNxmIpv6LabelMasked(_oxm, decoder)
+	case 122144:
+		return DecodeNxmTunIpv6DstMasked(_oxm, decoder)
+	case 99452:
+		return DecodeNxmTunMetadata26(_oxm, decoder)
+	case 109560:
+		return DecodeNxmTunMetadata45Masked(_oxm, decoder)
+	case 95224:
+		return DecodeNxmTunMetadata17Masked(_oxm, decoder)
+	case 121360:
+		return DecodeNxmTunIpv6Src(_oxm, decoder)
+	case 85762:
+		return DecodeNxmTunGbpFlagsMasked(_oxm, decoder)
+	case 2147490056:
+		return DecodeOxmIpv4DstMasked(_oxm, decoder)
+	case 83972:
+		return DecodeNxmRecircId(_oxm, decoder)
+	case 122656:
+		return DecodeNxmXxreg0Masked(_oxm, decoder)
+	case 2147490564:
+		return DecodeOxmTcpSrcMasked(_oxm, decoder)
+	case 128800:
+		return DecodeOxmConnTrackingIpv6DstMasked(_oxm, decoder)
+	case 118786:
+		return DecodeNxmTunFlags(_oxm, decoder)
+	case 2147488769:
+		return DecodeOxmIpProto(_oxm, decoder)
+	case 95736:
+		return DecodeNxmTunMetadata18Masked(_oxm, decoder)
+	case 121872:
+		return DecodeNxmTunIpv6Dst(_oxm, decoder)
+	case 81924:
+		return DecodeNxmTunDst(_oxm, decoder)
+	case 68360:
+		return DecodeNxmReg5Masked(_oxm, decoder)
+	case 518:
+		return DecodeNxmEthDst(_oxm, decoder)
+	case 116216:
+		return DecodeNxmTunMetadata58Masked(_oxm, decoder)
+	case 2147501569:
+		return DecodeOxmMplsTc(_oxm, decoder)
+	case 114300:
+		return DecodeNxmTunMetadata55(_oxm, decoder)
+	case 68100:
+		return DecodeNxmReg5(_oxm, decoder)
+	case 123168:
+		return DecodeNxmXxreg1Masked(_oxm, decoder)
+	case 100476:
+		return DecodeNxmTunMetadata28(_oxm, decoder)
+	case 4610:
+		return DecodeNxmTcpSrc(_oxm, decoder)
+	case 123680:
+		return DecodeNxmXxreg2Masked(_oxm, decoder)
+	case 96248:
+		return DecodeNxmTunMetadata19Masked(_oxm, decoder)
+	case 122384:
+		return DecodeNxmXxreg0(_oxm, decoder)
+	case 78091:
+		return DecodeNxmNdSllMasked(_oxm, decoder)
+	case 1030:
+		return DecodeNxmEthSrc(_oxm, decoder)
+	case 68612:
+		return DecodeNxmReg6(_oxm, decoder)
+	case 107644:
+		return DecodeNxmTunMetadata42(_oxm, decoder)
+	case 100988:
+		return DecodeNxmTunMetadata29(_oxm, decoder)
+	case 119810:
+		return DecodeOxmConnTrackingZone(_oxm, decoder)
+	case 96760:
+		return DecodeNxmTunMetadata20Masked(_oxm, decoder)
+	case 85252:
+		return DecodeNxmTunGbpIdMasked(_oxm, decoder)
+	case 78603:
+		return DecodeNxmNdTllMasked(_oxm, decoder)
+	case 86652:
+		return DecodeNxmTunMetadata1(_oxm, decoder)
+	case 69124:
+		return DecodeNxmReg7(_oxm, decoder)
+	case 2147494916:
+		return DecodeOxmArpSpa(_oxm, decoder)
+	case 88188:
+		return DecodeNxmTunMetadata4(_oxm, decoder)
+	case 3588:
+		return DecodeNxmIpSrc(_oxm, decoder)
+	case 124192:
+		return DecodeNxmXxreg3Masked(_oxm, decoder)
+	case 101500:
+		return DecodeNxmTunMetadata30(_oxm, decoder)
+	case 5634:
+		return DecodeNxmUdpSrc(_oxm, decoder)
+	case 127240:
+		return DecodeOxmConnTrackingNwSrcMasked(_oxm, decoder)
+	case 6657:
+		return DecodeNxmIcmpType(_oxm, decoder)
+	case 97272:
+		return DecodeNxmTunMetadata21Masked(_oxm, decoder)
+	case 81672:
+		return DecodeNxmTunSrcMasked(_oxm, decoder)
+	case 122896:
+		return DecodeNxmXxreg1(_oxm, decoder)
+	case 2147489026:
+		return DecodeOxmIpProtoMasked(_oxm, decoder)
+	case 2147485702:
+		return DecodeOxmEthSrc(_oxm, decoder)
+	case 4100:
+		return DecodeNxmIpDst(_oxm, decoder)
+	case 65800:
+		return DecodeNxmReg0Masked(_oxm, decoder)
+	case 75552:
+		return DecodeNxmIpv6SrcMasked(_oxm, decoder)
+	case 102012:
+		return DecodeNxmTunMetadata31(_oxm, decoder)
+	case 79106:
+		return DecodeNxmIpFragMasked(_oxm, decoder)
+	case 2147501826:
+		return DecodeOxmMplsTcMasked(_oxm, decoder)
+	case 8452:
+		return DecodeNxmArpSpaMasked(_oxm, decoder)
+	case 97784:
+		return DecodeNxmTunMetadata22Masked(_oxm, decoder)
+	case 1286:
+		return DecodeNxmEthSrcMasked(_oxm, decoder)
+	case 66052:
+		return DecodeNxmReg1(_oxm, decoder)
+	case 8968:
+		return DecodeNxmArpTpaMasked(_oxm, decoder)
+	case 2147488514:
+		return DecodeOxmIpEcnMasked(_oxm, decoder)
+	case 75019:
+		return DecodeNxmArpThaMasked(_oxm, decoder)
+	case 2147496204:
+		return DecodeOxmArpShaMasked(_oxm, decoder)
+	case 66312:
+		return DecodeNxmReg1Masked(_oxm, decoder)
+	case 74000:
+		return DecodeNxmTunIdMasked(_oxm, decoder)
+	case 102524:
+		return DecodeNxmTunMetadata32(_oxm, decoder)
+	case 111228:
+		return DecodeNxmTunMetadata49(_oxm, decoder)
+	case 88568:
+		return DecodeNxmTunMetadata4Masked(_oxm, decoder)
+	case 2147499536:
+		return DecodeOxmIpv6NdTarget(_oxm, decoder)
+	case 98296:
+		return DecodeNxmTunMetadata23Masked(_oxm, decoder)
+	case 75280:
+		return DecodeNxmIpv6Src(_oxm, decoder)
+	case 68872:
+		return DecodeNxmReg6Masked(_oxm, decoder)
+	case 116728:
+		return DecodeNxmTunMetadata59Masked(_oxm, decoder)
+	case 110072:
+		return DecodeNxmTunMetadata46Masked(_oxm, decoder)
+	case 70660:
+		return DecodeNxmReg10(_oxm, decoder)
+	case 2147491076:
+		return DecodeOxmTcpDstMasked(_oxm, decoder)
+	case 76064:
+		return DecodeNxmIpv6DstMasked(_oxm, decoder)
+	case 103036:
+		return DecodeNxmTunMetadata33(_oxm, decoder)
+	case 107000:
+		return DecodeNxmTunMetadata40Masked(_oxm, decoder)
+	case 110716:
+		return DecodeNxmTunMetadata48(_oxm, decoder)
+	case 98808:
+		return DecodeNxmTunMetadata24Masked(_oxm, decoder)
+	case 75792:
+		return DecodeNxmIpv6Dst(_oxm, decoder)
+	case 2147501060:
+		return DecodeOxmMplsLabel(_oxm, decoder)
+	case 73220:
+		return DecodeNxmReg15(_oxm, decoder)
+	case 117884:
+		return DecodeNxmTunMetadata62(_oxm, decoder)
+	case 83720:
+		return DecodeNxmDpHashMasked(_oxm, decoder)
+	case 108156:
+		return DecodeNxmTunMetadata43(_oxm, decoder)
+	case 87164:
+		return DecodeNxmTunMetadata2(_oxm, decoder)
+	case 2147491330:
+		return DecodeOxmUdpSrc(_oxm, decoder)
+	case 99320:
+		return DecodeNxmTunMetadata25Masked(_oxm, decoder)
+	case 5892:
+		return DecodeNxmUdpSrcMasked(_oxm, decoder)
+	case 113656:
+		return DecodeNxmTunMetadata53Masked(_oxm, decoder)
+	case 2147497248:
+		return DecodeOxmIpv6SrcMasked(_oxm, decoder)
+	case 69636:
+		return DecodeNxmReg8(_oxm, decoder)
+	case 88700:
+		return DecodeNxmTunMetadata5(_oxm, decoder)
+	case 113788:
+		return DecodeNxmTunMetadata54(_oxm, decoder)
+	case 71684:
+		return DecodeNxmReg12(_oxm, decoder)
+	case 77600:
+		return DecodeNxmNdTargetMasked(_oxm, decoder)
+	case 87676:
+		return DecodeNxmTunMetadata3(_oxm, decoder)
+	case 2147491842:
+		return DecodeOxmUdpDst(_oxm, decoder)
+	case 127752:
+		return DecodeOxmConnTrackingNwDstMasked(_oxm, decoder)
+	case 99832:
+		return DecodeNxmTunMetadata26Masked(_oxm, decoder)
+	case 114812:
+		return DecodeNxmTunMetadata56(_oxm, decoder)
+	case 82184:
+		return DecodeNxmTunDstMasked(_oxm, decoder)
+	case 90236:
+		return DecodeNxmTunMetadata8(_oxm, decoder)
+	case 72196:
+		return DecodeNxmReg13(_oxm, decoder)
+	case 104572:
+		return DecodeNxmTunMetadata36(_oxm, decoder)
+	case 2147492354:
+		return DecodeOxmSctpSrc(_oxm, decoder)
+	case 95356:
+		return DecodeNxmTunMetadata18(_oxm, decoder)
+	case 2147493377:
+		return DecodeOxmIcmpv4Type(_oxm, decoder)
+	case 100344:
+		return DecodeNxmTunMetadata27Masked(_oxm, decoder)
+	case 77328:
+		return DecodeNxmNdTarget(_oxm, decoder)
+	case 2147488257:
+		return DecodeOxmIpEcn(_oxm, decoder)
+	case 118264:
+		return DecodeNxmTunMetadata62Masked(_oxm, decoder)
+	case 90616:
+		return DecodeNxmTunMetadata8Masked(_oxm, decoder)
+	case 72708:
+		return DecodeNxmReg14(_oxm, decoder)
+	case 114680:
+		return DecodeNxmTunMetadata55Masked(_oxm, decoder)
+	case 105084:
+		return DecodeNxmTunMetadata37(_oxm, decoder)
+	case 91128:
+		return DecodeNxmTunMetadata9Masked(_oxm, decoder)
+	case 111740:
+		return DecodeNxmTunMetadata50(_oxm, decoder)
+	case 2147493889:
+		return DecodeOxmIcmpv4Code(_oxm, decoder)
+	case 100856:
+		return DecodeNxmTunMetadata28Masked(_oxm, decoder)
+	case 2308:
+		return DecodeNxmVlanTciMasked(_oxm, decoder)
+	case 2147501320:
+		return DecodeOxmMplsLabelMasked(_oxm, decoder)
+	case 779:
+		return DecodeNxmEthDstMasked(_oxm, decoder)
+	case 2147493124:
+		return DecodeOxmSctpDstMasked(_oxm, decoder)
+	case 69384:
+		return DecodeNxmReg7Masked(_oxm, decoder)
+	case 117240:
+		return DecodeNxmTunMetadata60Masked(_oxm, decoder)
+	case 3848:
+		return DecodeNxmIpSrcMasked(_oxm, decoder)
+	case 128288:
+		return DecodeOxmConnTrackingIpv6SrcMasked(_oxm, decoder)
+	case 92284:
+		return DecodeNxmTunMetadata12(_oxm, decoder)
+	case 105596:
+		return DecodeNxmTunMetadata38(_oxm, decoder)
+	case 4868:
+		return DecodeNxmTcpSrcMasked(_oxm, decoder)
+	case 76289:
+		return DecodeNxmIcmpv6Type(_oxm, decoder)
+	case 101368:
+		return DecodeNxmTunMetadata29Masked(_oxm, decoder)
+	case 2147500300:
+		return DecodeOxmIpv6NdSllMasked(_oxm, decoder)
+	case 88056:
+		return DecodeNxmTunMetadata3Masked(_oxm, decoder)
+	case 118396:
+		return DecodeNxmTunMetadata63(_oxm, decoder)
+	case 2147494402:
+		return DecodeOxmArpOp(_oxm, decoder)
+	case 2147496454:
+		return DecodeOxmArpTha(_oxm, decoder)
+	case 4360:
+		return DecodeNxmIpDstMasked(_oxm, decoder)
+	case 8196:
+		return DecodeNxmArpSpa(_oxm, decoder)
+	case 108668:
+		return DecodeNxmTunMetadata44(_oxm, decoder)
+	case 106108:
+		return DecodeNxmTunMetadata39(_oxm, decoder)
+	case 76801:
+		return DecodeNxmIcmpv6Code(_oxm, decoder)
+	case 101880:
+		return DecodeNxmTunMetadata30Masked(_oxm, decoder)
+	case 2147500812:
+		return DecodeOxmIpv6NdTllMasked(_oxm, decoder)
+	case 114168:
+		return DecodeNxmTunMetadata54Masked(_oxm, decoder)
+	case 2147494146:
+		return DecodeOxmIcmpv4CodeMasked(_oxm, decoder)
+	case 70148:
+		return DecodeNxmReg9(_oxm, decoder)
+	case 89212:
+		return DecodeNxmTunMetadata6(_oxm, decoder)
+	case 119560:
+		return DecodeOxmConnTrackingStateMasked(_oxm, decoder)
+	case 83204:
+		return DecodeNxmTcpFlagsMasked(_oxm, decoder)
+	case 106620:
+		return DecodeNxmTunMetadata40(_oxm, decoder)
+	case 6146:
+		return DecodeNxmUdpDst(_oxm, decoder)
+	case 119044:
+		return DecodeNxmTunFlagsMasked(_oxm, decoder)
+	case 102392:
+		return DecodeNxmTunMetadata31Masked(_oxm, decoder)
+	case 115324:
+		return DecodeNxmTunMetadata57(_oxm, decoder)
+	case 82696:
+		return DecodeNxmPktMarkMasked(_oxm, decoder)
+	case 123920:
+		return DecodeNxmXxreg3(_oxm, decoder)
+	case 2147497760:
+		return DecodeOxmIpv6DstMasked(_oxm, decoder)
+	case 2147489284:
+		return DecodeOxmIpv4Src(_oxm, decoder)
+	case 70920:
+		return DecodeNxmReg10Masked(_oxm, decoder)
+	case 107132:
+		return DecodeNxmTunMetadata41(_oxm, decoder)
+	case 2147491588:
+		return DecodeOxmUdpSrcMasked(_oxm, decoder)
+	case 102904:
+		return DecodeNxmTunMetadata32Masked(_oxm, decoder)
+	case 111096:
+		return DecodeNxmTunMetadata48Masked(_oxm, decoder)
+	case 2147492100:
+		return DecodeOxmUdpDstMasked(_oxm, decoder)
+	case 67076:
+		return DecodeNxmReg3(_oxm, decoder)
+	case 2147496976:
+		return DecodeOxmIpv6Src(_oxm, decoder)
+	case 120584:
+		return DecodeOxmConnTrackingMarkMasked(_oxm, decoder)
+	case 91260:
+		return DecodeNxmTunMetadata10(_oxm, decoder)
+	case 2147490818:
+		return DecodeOxmTcpDst(_oxm, decoder)
+	case 112252:
+		return DecodeNxmTunMetadata51(_oxm, decoder)
+	case 87032:
+		return DecodeNxmTunMetadata1Masked(_oxm, decoder)
+	case 2147485964:
+		return DecodeOxmEthSrcMasked(_oxm, decoder)
+	case 83460:
+		return DecodeNxmDpHash(_oxm, decoder)
+	case 126722:
+		return DecodeOxmConnTrackingNwProtoMasked(_oxm, decoder)
+	case 119300:
+		return DecodeOxmConnTrackingState(_oxm, decoder)
+	case 117752:
+		return DecodeNxmTunMetadata61Masked(_oxm, decoder)
+	case 71944:
+		return DecodeNxmReg12Masked(_oxm, decoder)
+	case 2147499808:
+		return DecodeOxmIpv6NdTargetMasked(_oxm, decoder)
+	case 91772:
+		return DecodeNxmTunMetadata11(_oxm, decoder)
+	case 78849:
+		return DecodeNxmIpFrag(_oxm, decoder)
+	case 87544:
+		return DecodeNxmTunMetadata2Masked(_oxm, decoder)
+	case 90104:
+		return DecodeNxmTunMetadata7Masked(_oxm, decoder)
+	case 72456:
+		return DecodeNxmReg13Masked(_oxm, decoder)
+	case 109180:
+		return DecodeNxmTunMetadata45(_oxm, decoder)
+	case 91640:
+		return DecodeNxmTunMetadata10Masked(_oxm, decoder)
+	case 2147498497:
+		return DecodeOxmIcmpv6Type(_oxm, decoder)
+	case 2147492612:
+		return DecodeOxmSctpSrcMasked(_oxm, decoder)
+	case 104440:
+		return DecodeNxmTunMetadata35Masked(_oxm, decoder)
+	case 2147494660:
+		return DecodeOxmArpOpMasked(_oxm, decoder)
+	case 66824:
+		return DecodeNxmReg2Masked(_oxm, decoder)
+	case 109048:
+		return DecodeNxmTunMetadata44Masked(_oxm, decoder)
+	case 2147492866:
+		return DecodeOxmSctpDst(_oxm, decoder)
+	case 89724:
+		return DecodeNxmTunMetadata7(_oxm, decoder)
+	case 72968:
+		return DecodeNxmReg14Masked(_oxm, decoder)
+	case 92796:
+		return DecodeNxmTunMetadata13(_oxm, decoder)
+	case 2147495176:
+		return DecodeOxmArpSpaMasked(_oxm, decoder)
+	case 79873:
+		return DecodeNxmNwEcn(_oxm, decoder)
+	case 104952:
+		return DecodeNxmTunMetadata36Masked(_oxm, decoder)
+	case 115836:
+		return DecodeNxmTunMetadata58(_oxm, decoder)
+	case 93820:
+		return DecodeNxmTunMetadata15(_oxm, decoder)
+	case 2147495942:
+		return DecodeOxmArpSha(_oxm, decoder)
+	case 2147495428:
+		return DecodeOxmArpTpa(_oxm, decoder)
+	case 93308:
+		return DecodeNxmTunMetadata14(_oxm, decoder)
+	case 80385:
+		return DecodeNxmNwTtl(_oxm, decoder)
+	case 105464:
+		return DecodeNxmTunMetadata37Masked(_oxm, decoder)
+	case 111608:
+		return DecodeNxmTunMetadata49Masked(_oxm, decoder)
+	case 2147488002:
+		return DecodeOxmIpDscpMasked(_oxm, decoder)
+	case 86520:
+		return DecodeNxmTunMetadata0Masked(_oxm, decoder)
+	case 67588:
+		return DecodeNxmReg4(_oxm, decoder)
+	case 6404:
+		return DecodeNxmUdpDstMasked(_oxm, decoder)
+	case 2147497488:
+		return DecodeOxmIpv6Dst(_oxm, decoder)
+	case 126980:
+		return DecodeOxmConnTrackingNwSrc(_oxm, decoder)
+	default:
+		return nil, nil
+	}
+}
+
+func NewOxm(_type_len uint32) *Oxm {
+	obj := &Oxm{}
+	obj.TypeLen = _type_len
+	return obj
+}
+
+type NxmArpOp struct {
+	*Oxm
+	Value uint16
+}
+
+type INxmArpOp interface {
+	goloxi.IOxm
+	GetValue() uint16
+}
+
+func (self *NxmArpOp) GetValue() uint16 {
+	return self.Value
+}
+
+func (self *NxmArpOp) SetValue(v uint16) {
+	self.Value = v
+}
+
+func (self *NxmArpOp) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Value))
+
+	return nil
+}
+
+func DecodeNxmArpOp(parent *Oxm, decoder *goloxi.Decoder) (*NxmArpOp, error) {
+	_nxmarpop := &NxmArpOp{Oxm: parent}
+	if decoder.Length() < 2 {
+		return nil, fmt.Errorf("NxmArpOp packet too short: %d < 2", decoder.Length())
+	}
+	_nxmarpop.Value = uint16(decoder.ReadUint16())
+	return _nxmarpop, nil
+}
+
+func NewNxmArpOp() *NxmArpOp {
+	obj := &NxmArpOp{
+		Oxm: NewOxm(7682),
+	}
+	return obj
+}
+func (self *NxmArpOp) GetOXMName() string {
+	return "arp_op"
+}
+
+func (self *NxmArpOp) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmArpOp) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmArpSha struct {
+	*Oxm
+	Value net.HardwareAddr
+}
+
+type INxmArpSha interface {
+	goloxi.IOxm
+	GetValue() net.HardwareAddr
+}
+
+func (self *NxmArpSha) GetValue() net.HardwareAddr {
+	return self.Value
+}
+
+func (self *NxmArpSha) SetValue(v net.HardwareAddr) {
+	self.Value = v
+}
+
+func (self *NxmArpSha) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeNxmArpSha(parent *Oxm, decoder *goloxi.Decoder) (*NxmArpSha, error) {
+	_nxmarpsha := &NxmArpSha{Oxm: parent}
+	if decoder.Length() < 6 {
+		return nil, fmt.Errorf("NxmArpSha packet too short: %d < 6", decoder.Length())
+	}
+	_nxmarpsha.Value = net.HardwareAddr(decoder.Read(6))
+	return _nxmarpsha, nil
+}
+
+func NewNxmArpSha() *NxmArpSha {
+	obj := &NxmArpSha{
+		Oxm: NewOxm(74246),
+	}
+	return obj
+}
+func (self *NxmArpSha) GetOXMName() string {
+	return "arp_sha"
+}
+
+func (self *NxmArpSha) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmArpSha) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmArpShaMasked struct {
+	*Oxm
+	Value     net.HardwareAddr
+	ValueMask net.HardwareAddr
+}
+
+type INxmArpShaMasked interface {
+	goloxi.IOxm
+	GetValue() net.HardwareAddr
+	GetValueMask() net.HardwareAddr
+}
+
+func (self *NxmArpShaMasked) GetValue() net.HardwareAddr {
+	return self.Value
+}
+
+func (self *NxmArpShaMasked) SetValue(v net.HardwareAddr) {
+	self.Value = v
+}
+
+func (self *NxmArpShaMasked) GetValueMask() net.HardwareAddr {
+	return self.ValueMask
+}
+
+func (self *NxmArpShaMasked) SetValueMask(v net.HardwareAddr) {
+	self.ValueMask = v
+}
+
+func (self *NxmArpShaMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeNxmArpShaMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmArpShaMasked, error) {
+	_nxmarpshamasked := &NxmArpShaMasked{Oxm: parent}
+	if decoder.Length() < 12 {
+		return nil, fmt.Errorf("NxmArpShaMasked packet too short: %d < 12", decoder.Length())
+	}
+	_nxmarpshamasked.Value = net.HardwareAddr(decoder.Read(6))
+	_nxmarpshamasked.ValueMask = net.HardwareAddr(decoder.Read(6))
+	return _nxmarpshamasked, nil
+}
+
+func NewNxmArpShaMasked() *NxmArpShaMasked {
+	obj := &NxmArpShaMasked{
+		Oxm: NewOxm(74507),
+	}
+	return obj
+}
+func (self *NxmArpShaMasked) GetOXMName() string {
+	return "arp_sha_masked"
+}
+
+func (self *NxmArpShaMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmArpShaMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmArpShaMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmArpSpa struct {
+	*Oxm
+	Value net.IP
+}
+
+type INxmArpSpa interface {
+	goloxi.IOxm
+	GetValue() net.IP
+}
+
+func (self *NxmArpSpa) GetValue() net.IP {
+	return self.Value
+}
+
+func (self *NxmArpSpa) SetValue(v net.IP) {
+	self.Value = v
+}
+
+func (self *NxmArpSpa) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value.To4())
+
+	return nil
+}
+
+func DecodeNxmArpSpa(parent *Oxm, decoder *goloxi.Decoder) (*NxmArpSpa, error) {
+	_nxmarpspa := &NxmArpSpa{Oxm: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("NxmArpSpa packet too short: %d < 4", decoder.Length())
+	}
+	_nxmarpspa.Value = net.IP(decoder.Read(4))
+	return _nxmarpspa, nil
+}
+
+func NewNxmArpSpa() *NxmArpSpa {
+	obj := &NxmArpSpa{
+		Oxm: NewOxm(8196),
+	}
+	return obj
+}
+func (self *NxmArpSpa) GetOXMName() string {
+	return "arp_spa"
+}
+
+func (self *NxmArpSpa) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmArpSpa) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmArpSpaMasked struct {
+	*Oxm
+	Value     net.IP
+	ValueMask net.IP
+}
+
+type INxmArpSpaMasked interface {
+	goloxi.IOxm
+	GetValue() net.IP
+	GetValueMask() net.IP
+}
+
+func (self *NxmArpSpaMasked) GetValue() net.IP {
+	return self.Value
+}
+
+func (self *NxmArpSpaMasked) SetValue(v net.IP) {
+	self.Value = v
+}
+
+func (self *NxmArpSpaMasked) GetValueMask() net.IP {
+	return self.ValueMask
+}
+
+func (self *NxmArpSpaMasked) SetValueMask(v net.IP) {
+	self.ValueMask = v
+}
+
+func (self *NxmArpSpaMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value.To4())
+	encoder.Write(self.ValueMask.To4())
+
+	return nil
+}
+
+func DecodeNxmArpSpaMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmArpSpaMasked, error) {
+	_nxmarpspamasked := &NxmArpSpaMasked{Oxm: parent}
+	if decoder.Length() < 8 {
+		return nil, fmt.Errorf("NxmArpSpaMasked packet too short: %d < 8", decoder.Length())
+	}
+	_nxmarpspamasked.Value = net.IP(decoder.Read(4))
+	_nxmarpspamasked.ValueMask = net.IP(decoder.Read(4))
+	return _nxmarpspamasked, nil
+}
+
+func NewNxmArpSpaMasked() *NxmArpSpaMasked {
+	obj := &NxmArpSpaMasked{
+		Oxm: NewOxm(8452),
+	}
+	return obj
+}
+func (self *NxmArpSpaMasked) GetOXMName() string {
+	return "arp_spa_masked"
+}
+
+func (self *NxmArpSpaMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmArpSpaMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmArpSpaMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmArpTha struct {
+	*Oxm
+	Value net.HardwareAddr
+}
+
+type INxmArpTha interface {
+	goloxi.IOxm
+	GetValue() net.HardwareAddr
+}
+
+func (self *NxmArpTha) GetValue() net.HardwareAddr {
+	return self.Value
+}
+
+func (self *NxmArpTha) SetValue(v net.HardwareAddr) {
+	self.Value = v
+}
+
+func (self *NxmArpTha) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeNxmArpTha(parent *Oxm, decoder *goloxi.Decoder) (*NxmArpTha, error) {
+	_nxmarptha := &NxmArpTha{Oxm: parent}
+	if decoder.Length() < 6 {
+		return nil, fmt.Errorf("NxmArpTha packet too short: %d < 6", decoder.Length())
+	}
+	_nxmarptha.Value = net.HardwareAddr(decoder.Read(6))
+	return _nxmarptha, nil
+}
+
+func NewNxmArpTha() *NxmArpTha {
+	obj := &NxmArpTha{
+		Oxm: NewOxm(74758),
+	}
+	return obj
+}
+func (self *NxmArpTha) GetOXMName() string {
+	return "arp_tha"
+}
+
+func (self *NxmArpTha) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmArpTha) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmArpThaMasked struct {
+	*Oxm
+	Value     net.HardwareAddr
+	ValueMask net.HardwareAddr
+}
+
+type INxmArpThaMasked interface {
+	goloxi.IOxm
+	GetValue() net.HardwareAddr
+	GetValueMask() net.HardwareAddr
+}
+
+func (self *NxmArpThaMasked) GetValue() net.HardwareAddr {
+	return self.Value
+}
+
+func (self *NxmArpThaMasked) SetValue(v net.HardwareAddr) {
+	self.Value = v
+}
+
+func (self *NxmArpThaMasked) GetValueMask() net.HardwareAddr {
+	return self.ValueMask
+}
+
+func (self *NxmArpThaMasked) SetValueMask(v net.HardwareAddr) {
+	self.ValueMask = v
+}
+
+func (self *NxmArpThaMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeNxmArpThaMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmArpThaMasked, error) {
+	_nxmarpthamasked := &NxmArpThaMasked{Oxm: parent}
+	if decoder.Length() < 12 {
+		return nil, fmt.Errorf("NxmArpThaMasked packet too short: %d < 12", decoder.Length())
+	}
+	_nxmarpthamasked.Value = net.HardwareAddr(decoder.Read(6))
+	_nxmarpthamasked.ValueMask = net.HardwareAddr(decoder.Read(6))
+	return _nxmarpthamasked, nil
+}
+
+func NewNxmArpThaMasked() *NxmArpThaMasked {
+	obj := &NxmArpThaMasked{
+		Oxm: NewOxm(75019),
+	}
+	return obj
+}
+func (self *NxmArpThaMasked) GetOXMName() string {
+	return "arp_tha_masked"
+}
+
+func (self *NxmArpThaMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmArpThaMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmArpThaMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmArpTpa struct {
+	*Oxm
+	Value net.IP
+}
+
+type INxmArpTpa interface {
+	goloxi.IOxm
+	GetValue() net.IP
+}
+
+func (self *NxmArpTpa) GetValue() net.IP {
+	return self.Value
+}
+
+func (self *NxmArpTpa) SetValue(v net.IP) {
+	self.Value = v
+}
+
+func (self *NxmArpTpa) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value.To4())
+
+	return nil
+}
+
+func DecodeNxmArpTpa(parent *Oxm, decoder *goloxi.Decoder) (*NxmArpTpa, error) {
+	_nxmarptpa := &NxmArpTpa{Oxm: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("NxmArpTpa packet too short: %d < 4", decoder.Length())
+	}
+	_nxmarptpa.Value = net.IP(decoder.Read(4))
+	return _nxmarptpa, nil
+}
+
+func NewNxmArpTpa() *NxmArpTpa {
+	obj := &NxmArpTpa{
+		Oxm: NewOxm(8708),
+	}
+	return obj
+}
+func (self *NxmArpTpa) GetOXMName() string {
+	return "arp_tpa"
+}
+
+func (self *NxmArpTpa) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmArpTpa) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmArpTpaMasked struct {
+	*Oxm
+	Value     net.IP
+	ValueMask net.IP
+}
+
+type INxmArpTpaMasked interface {
+	goloxi.IOxm
+	GetValue() net.IP
+	GetValueMask() net.IP
+}
+
+func (self *NxmArpTpaMasked) GetValue() net.IP {
+	return self.Value
+}
+
+func (self *NxmArpTpaMasked) SetValue(v net.IP) {
+	self.Value = v
+}
+
+func (self *NxmArpTpaMasked) GetValueMask() net.IP {
+	return self.ValueMask
+}
+
+func (self *NxmArpTpaMasked) SetValueMask(v net.IP) {
+	self.ValueMask = v
+}
+
+func (self *NxmArpTpaMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value.To4())
+	encoder.Write(self.ValueMask.To4())
+
+	return nil
+}
+
+func DecodeNxmArpTpaMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmArpTpaMasked, error) {
+	_nxmarptpamasked := &NxmArpTpaMasked{Oxm: parent}
+	if decoder.Length() < 8 {
+		return nil, fmt.Errorf("NxmArpTpaMasked packet too short: %d < 8", decoder.Length())
+	}
+	_nxmarptpamasked.Value = net.IP(decoder.Read(4))
+	_nxmarptpamasked.ValueMask = net.IP(decoder.Read(4))
+	return _nxmarptpamasked, nil
+}
+
+func NewNxmArpTpaMasked() *NxmArpTpaMasked {
+	obj := &NxmArpTpaMasked{
+		Oxm: NewOxm(8968),
+	}
+	return obj
+}
+func (self *NxmArpTpaMasked) GetOXMName() string {
+	return "arp_tpa_masked"
+}
+
+func (self *NxmArpTpaMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmArpTpaMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmArpTpaMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmConjId struct {
+	*Oxm
+	Value uint32
+}
+
+type INxmConjId interface {
+	goloxi.IOxm
+	GetValue() uint32
+}
+
+func (self *NxmConjId) GetValue() uint32 {
+	return self.Value
+}
+
+func (self *NxmConjId) SetValue(v uint32) {
+	self.Value = v
+}
+
+func (self *NxmConjId) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Value))
+
+	return nil
+}
+
+func DecodeNxmConjId(parent *Oxm, decoder *goloxi.Decoder) (*NxmConjId, error) {
+	_nxmconjid := &NxmConjId{Oxm: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("NxmConjId packet too short: %d < 4", decoder.Length())
+	}
+	_nxmconjid.Value = uint32(decoder.ReadUint32())
+	return _nxmconjid, nil
+}
+
+func NewNxmConjId() *NxmConjId {
+	obj := &NxmConjId{
+		Oxm: NewOxm(84484),
+	}
+	return obj
+}
+func (self *NxmConjId) GetOXMName() string {
+	return "conj_id"
+}
+
+func (self *NxmConjId) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmConjId) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmCtIpv6Dst struct {
+	*Oxm
+	Value net.IP
+}
+
+type INxmCtIpv6Dst interface {
+	goloxi.IOxm
+	GetValue() net.IP
+}
+
+func (self *NxmCtIpv6Dst) GetValue() net.IP {
+	return self.Value
+}
+
+func (self *NxmCtIpv6Dst) SetValue(v net.IP) {
+	self.Value = v
+}
+
+func (self *NxmCtIpv6Dst) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value.To16())
+
+	return nil
+}
+
+func DecodeNxmCtIpv6Dst(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtIpv6Dst, error) {
+	_nxmctipv6dst := &NxmCtIpv6Dst{Oxm: parent}
+	if decoder.Length() < 16 {
+		return nil, fmt.Errorf("NxmCtIpv6Dst packet too short: %d < 16", decoder.Length())
+	}
+	_nxmctipv6dst.Value = net.IP(decoder.Read(16))
+	return _nxmctipv6dst, nil
+}
+
+func NewNxmCtIpv6Dst() *NxmCtIpv6Dst {
+	obj := &NxmCtIpv6Dst{
+		Oxm: NewOxm(128528),
+	}
+	return obj
+}
+func (self *NxmCtIpv6Dst) GetOXMName() string {
+	return "ct_ipv6_dst"
+}
+
+func (self *NxmCtIpv6Dst) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmCtIpv6Dst) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmCtIpv6DstMasked struct {
+	*Oxm
+	Value     net.IP
+	ValueMask net.IP
+}
+
+type INxmCtIpv6DstMasked interface {
+	goloxi.IOxm
+	GetValue() net.IP
+	GetValueMask() net.IP
+}
+
+func (self *NxmCtIpv6DstMasked) GetValue() net.IP {
+	return self.Value
+}
+
+func (self *NxmCtIpv6DstMasked) SetValue(v net.IP) {
+	self.Value = v
+}
+
+func (self *NxmCtIpv6DstMasked) GetValueMask() net.IP {
+	return self.ValueMask
+}
+
+func (self *NxmCtIpv6DstMasked) SetValueMask(v net.IP) {
+	self.ValueMask = v
+}
+
+func (self *NxmCtIpv6DstMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value.To16())
+	encoder.Write(self.ValueMask.To16())
+
+	return nil
+}
+
+func DecodeNxmCtIpv6DstMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtIpv6DstMasked, error) {
+	_nxmctipv6dstmasked := &NxmCtIpv6DstMasked{Oxm: parent}
+	if decoder.Length() < 32 {
+		return nil, fmt.Errorf("NxmCtIpv6DstMasked packet too short: %d < 32", decoder.Length())
+	}
+	_nxmctipv6dstmasked.Value = net.IP(decoder.Read(16))
+	_nxmctipv6dstmasked.ValueMask = net.IP(decoder.Read(16))
+	return _nxmctipv6dstmasked, nil
+}
+
+func NewNxmCtIpv6DstMasked() *NxmCtIpv6DstMasked {
+	obj := &NxmCtIpv6DstMasked{
+		Oxm: NewOxm(128800),
+	}
+	return obj
+}
+func (self *NxmCtIpv6DstMasked) GetOXMName() string {
+	return "ct_ipv6_dst_masked"
+}
+
+func (self *NxmCtIpv6DstMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmCtIpv6DstMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmCtIpv6DstMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmCtIpv6Src struct {
+	*Oxm
+	Value net.IP
+}
+
+type INxmCtIpv6Src interface {
+	goloxi.IOxm
+	GetValue() net.IP
+}
+
+func (self *NxmCtIpv6Src) GetValue() net.IP {
+	return self.Value
+}
+
+func (self *NxmCtIpv6Src) SetValue(v net.IP) {
+	self.Value = v
+}
+
+func (self *NxmCtIpv6Src) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value.To16())
+
+	return nil
+}
+
+func DecodeNxmCtIpv6Src(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtIpv6Src, error) {
+	_nxmctipv6src := &NxmCtIpv6Src{Oxm: parent}
+	if decoder.Length() < 16 {
+		return nil, fmt.Errorf("NxmCtIpv6Src packet too short: %d < 16", decoder.Length())
+	}
+	_nxmctipv6src.Value = net.IP(decoder.Read(16))
+	return _nxmctipv6src, nil
+}
+
+func NewNxmCtIpv6Src() *NxmCtIpv6Src {
+	obj := &NxmCtIpv6Src{
+		Oxm: NewOxm(128016),
+	}
+	return obj
+}
+func (self *NxmCtIpv6Src) GetOXMName() string {
+	return "ct_ipv6_src"
+}
+
+func (self *NxmCtIpv6Src) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmCtIpv6Src) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmCtIpv6SrcMasked struct {
+	*Oxm
+	Value     net.IP
+	ValueMask net.IP
+}
+
+type INxmCtIpv6SrcMasked interface {
+	goloxi.IOxm
+	GetValue() net.IP
+	GetValueMask() net.IP
+}
+
+func (self *NxmCtIpv6SrcMasked) GetValue() net.IP {
+	return self.Value
+}
+
+func (self *NxmCtIpv6SrcMasked) SetValue(v net.IP) {
+	self.Value = v
+}
+
+func (self *NxmCtIpv6SrcMasked) GetValueMask() net.IP {
+	return self.ValueMask
+}
+
+func (self *NxmCtIpv6SrcMasked) SetValueMask(v net.IP) {
+	self.ValueMask = v
+}
+
+func (self *NxmCtIpv6SrcMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value.To16())
+	encoder.Write(self.ValueMask.To16())
+
+	return nil
+}
+
+func DecodeNxmCtIpv6SrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtIpv6SrcMasked, error) {
+	_nxmctipv6srcmasked := &NxmCtIpv6SrcMasked{Oxm: parent}
+	if decoder.Length() < 32 {
+		return nil, fmt.Errorf("NxmCtIpv6SrcMasked packet too short: %d < 32", decoder.Length())
+	}
+	_nxmctipv6srcmasked.Value = net.IP(decoder.Read(16))
+	_nxmctipv6srcmasked.ValueMask = net.IP(decoder.Read(16))
+	return _nxmctipv6srcmasked, nil
+}
+
+func NewNxmCtIpv6SrcMasked() *NxmCtIpv6SrcMasked {
+	obj := &NxmCtIpv6SrcMasked{
+		Oxm: NewOxm(128288),
+	}
+	return obj
+}
+func (self *NxmCtIpv6SrcMasked) GetOXMName() string {
+	return "ct_ipv6_src_masked"
+}
+
+func (self *NxmCtIpv6SrcMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmCtIpv6SrcMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmCtIpv6SrcMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmCtLabel struct {
+	*Oxm
+	Value uint128
+}
+
+type INxmCtLabel interface {
+	goloxi.IOxm
+	GetValue() uint128
+}
+
+func (self *NxmCtLabel) GetValue() uint128 {
+	return self.Value
+}
+
+func (self *NxmCtLabel) SetValue(v uint128) {
+	self.Value = v
+}
+
+func (self *NxmCtLabel) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint128(uint128(self.Value))
+
+	return nil
+}
+
+func DecodeNxmCtLabel(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtLabel, error) {
+	_nxmctlabel := &NxmCtLabel{Oxm: parent}
+	if decoder.Length() < 16 {
+		return nil, fmt.Errorf("NxmCtLabel packet too short: %d < 16", decoder.Length())
+	}
+	_nxmctlabel.Value = uint128(decoder.ReadUint128())
+	return _nxmctlabel, nil
+}
+
+func NewNxmCtLabel() *NxmCtLabel {
+	obj := &NxmCtLabel{
+		Oxm: NewOxm(120848),
+	}
+	return obj
+}
+func (self *NxmCtLabel) GetOXMName() string {
+	return "ct_label"
+}
+
+func (self *NxmCtLabel) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmCtLabel) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmCtLabelMasked struct {
+	*Oxm
+	Value     uint128
+	ValueMask uint128
+}
+
+type INxmCtLabelMasked interface {
+	goloxi.IOxm
+	GetValue() uint128
+	GetValueMask() uint128
+}
+
+func (self *NxmCtLabelMasked) GetValue() uint128 {
+	return self.Value
+}
+
+func (self *NxmCtLabelMasked) SetValue(v uint128) {
+	self.Value = v
+}
+
+func (self *NxmCtLabelMasked) GetValueMask() uint128 {
+	return self.ValueMask
+}
+
+func (self *NxmCtLabelMasked) SetValueMask(v uint128) {
+	self.ValueMask = v
+}
+
+func (self *NxmCtLabelMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint128(uint128(self.Value))
+	encoder.PutUint128(uint128(self.ValueMask))
+
+	return nil
+}
+
+func DecodeNxmCtLabelMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtLabelMasked, error) {
+	_nxmctlabelmasked := &NxmCtLabelMasked{Oxm: parent}
+	if decoder.Length() < 32 {
+		return nil, fmt.Errorf("NxmCtLabelMasked packet too short: %d < 32", decoder.Length())
+	}
+	_nxmctlabelmasked.Value = uint128(decoder.ReadUint128())
+	_nxmctlabelmasked.ValueMask = uint128(decoder.ReadUint128())
+	return _nxmctlabelmasked, nil
+}
+
+func NewNxmCtLabelMasked() *NxmCtLabelMasked {
+	obj := &NxmCtLabelMasked{
+		Oxm: NewOxm(121120),
+	}
+	return obj
+}
+func (self *NxmCtLabelMasked) GetOXMName() string {
+	return "ct_label_masked"
+}
+
+func (self *NxmCtLabelMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmCtLabelMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmCtLabelMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmCtMark struct {
+	*Oxm
+	Value uint32
+}
+
+type INxmCtMark interface {
+	goloxi.IOxm
+	GetValue() uint32
+}
+
+func (self *NxmCtMark) GetValue() uint32 {
+	return self.Value
+}
+
+func (self *NxmCtMark) SetValue(v uint32) {
+	self.Value = v
+}
+
+func (self *NxmCtMark) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Value))
+
+	return nil
+}
+
+func DecodeNxmCtMark(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtMark, error) {
+	_nxmctmark := &NxmCtMark{Oxm: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("NxmCtMark packet too short: %d < 4", decoder.Length())
+	}
+	_nxmctmark.Value = uint32(decoder.ReadUint32())
+	return _nxmctmark, nil
+}
+
+func NewNxmCtMark() *NxmCtMark {
+	obj := &NxmCtMark{
+		Oxm: NewOxm(120324),
+	}
+	return obj
+}
+func (self *NxmCtMark) GetOXMName() string {
+	return "ct_mark"
+}
+
+func (self *NxmCtMark) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmCtMark) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmCtMarkMasked struct {
+	*Oxm
+	Value     uint32
+	ValueMask uint32
+}
+
+type INxmCtMarkMasked interface {
+	goloxi.IOxm
+	GetValue() uint32
+	GetValueMask() uint32
+}
+
+func (self *NxmCtMarkMasked) GetValue() uint32 {
+	return self.Value
+}
+
+func (self *NxmCtMarkMasked) SetValue(v uint32) {
+	self.Value = v
+}
+
+func (self *NxmCtMarkMasked) GetValueMask() uint32 {
+	return self.ValueMask
+}
+
+func (self *NxmCtMarkMasked) SetValueMask(v uint32) {
+	self.ValueMask = v
+}
+
+func (self *NxmCtMarkMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Value))
+	encoder.PutUint32(uint32(self.ValueMask))
+
+	return nil
+}
+
+func DecodeNxmCtMarkMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtMarkMasked, error) {
+	_nxmctmarkmasked := &NxmCtMarkMasked{Oxm: parent}
+	if decoder.Length() < 8 {
+		return nil, fmt.Errorf("NxmCtMarkMasked packet too short: %d < 8", decoder.Length())
+	}
+	_nxmctmarkmasked.Value = uint32(decoder.ReadUint32())
+	_nxmctmarkmasked.ValueMask = uint32(decoder.ReadUint32())
+	return _nxmctmarkmasked, nil
+}
+
+func NewNxmCtMarkMasked() *NxmCtMarkMasked {
+	obj := &NxmCtMarkMasked{
+		Oxm: NewOxm(120584),
+	}
+	return obj
+}
+func (self *NxmCtMarkMasked) GetOXMName() string {
+	return "ct_mark_masked"
+}
+
+func (self *NxmCtMarkMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmCtMarkMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmCtMarkMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmCtNwDst struct {
+	*Oxm
+	Value net.IP
+}
+
+type INxmCtNwDst interface {
+	goloxi.IOxm
+	GetValue() net.IP
+}
+
+func (self *NxmCtNwDst) GetValue() net.IP {
+	return self.Value
+}
+
+func (self *NxmCtNwDst) SetValue(v net.IP) {
+	self.Value = v
+}
+
+func (self *NxmCtNwDst) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value.To4())
+
+	return nil
+}
+
+func DecodeNxmCtNwDst(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtNwDst, error) {
+	_nxmctnwdst := &NxmCtNwDst{Oxm: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("NxmCtNwDst packet too short: %d < 4", decoder.Length())
+	}
+	_nxmctnwdst.Value = net.IP(decoder.Read(4))
+	return _nxmctnwdst, nil
+}
+
+func NewNxmCtNwDst() *NxmCtNwDst {
+	obj := &NxmCtNwDst{
+		Oxm: NewOxm(127492),
+	}
+	return obj
+}
+func (self *NxmCtNwDst) GetOXMName() string {
+	return "ct_nw_dst"
+}
+
+func (self *NxmCtNwDst) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmCtNwDst) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmCtNwDstMasked struct {
+	*Oxm
+	Value     net.IP
+	ValueMask net.IP
+}
+
+type INxmCtNwDstMasked interface {
+	goloxi.IOxm
+	GetValue() net.IP
+	GetValueMask() net.IP
+}
+
+func (self *NxmCtNwDstMasked) GetValue() net.IP {
+	return self.Value
+}
+
+func (self *NxmCtNwDstMasked) SetValue(v net.IP) {
+	self.Value = v
+}
+
+func (self *NxmCtNwDstMasked) GetValueMask() net.IP {
+	return self.ValueMask
+}
+
+func (self *NxmCtNwDstMasked) SetValueMask(v net.IP) {
+	self.ValueMask = v
+}
+
+func (self *NxmCtNwDstMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value.To4())
+	encoder.Write(self.ValueMask.To4())
+
+	return nil
+}
+
+func DecodeNxmCtNwDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtNwDstMasked, error) {
+	_nxmctnwdstmasked := &NxmCtNwDstMasked{Oxm: parent}
+	if decoder.Length() < 8 {
+		return nil, fmt.Errorf("NxmCtNwDstMasked packet too short: %d < 8", decoder.Length())
+	}
+	_nxmctnwdstmasked.Value = net.IP(decoder.Read(4))
+	_nxmctnwdstmasked.ValueMask = net.IP(decoder.Read(4))
+	return _nxmctnwdstmasked, nil
+}
+
+func NewNxmCtNwDstMasked() *NxmCtNwDstMasked {
+	obj := &NxmCtNwDstMasked{
+		Oxm: NewOxm(127752),
+	}
+	return obj
+}
+func (self *NxmCtNwDstMasked) GetOXMName() string {
+	return "ct_nw_dst_masked"
+}
+
+func (self *NxmCtNwDstMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmCtNwDstMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmCtNwDstMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmCtNwProto struct {
+	*Oxm
+	Value uint8
+}
+
+type INxmCtNwProto interface {
+	goloxi.IOxm
+	GetValue() uint8
+}
+
+func (self *NxmCtNwProto) GetValue() uint8 {
+	return self.Value
+}
+
+func (self *NxmCtNwProto) SetValue(v uint8) {
+	self.Value = v
+}
+
+func (self *NxmCtNwProto) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint8(uint8(self.Value))
+
+	return nil
+}
+
+func DecodeNxmCtNwProto(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtNwProto, error) {
+	_nxmctnwproto := &NxmCtNwProto{Oxm: parent}
+	if decoder.Length() < 1 {
+		return nil, fmt.Errorf("NxmCtNwProto packet too short: %d < 1", decoder.Length())
+	}
+	_nxmctnwproto.Value = uint8(decoder.ReadByte())
+	return _nxmctnwproto, nil
+}
+
+func NewNxmCtNwProto() *NxmCtNwProto {
+	obj := &NxmCtNwProto{
+		Oxm: NewOxm(126465),
+	}
+	return obj
+}
+func (self *NxmCtNwProto) GetOXMName() string {
+	return "ct_nw_proto"
+}
+
+func (self *NxmCtNwProto) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmCtNwProto) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmCtNwSrc struct {
+	*Oxm
+	Value net.IP
+}
+
+type INxmCtNwSrc interface {
+	goloxi.IOxm
+	GetValue() net.IP
+}
+
+func (self *NxmCtNwSrc) GetValue() net.IP {
+	return self.Value
+}
+
+func (self *NxmCtNwSrc) SetValue(v net.IP) {
+	self.Value = v
+}
+
+func (self *NxmCtNwSrc) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value.To4())
+
+	return nil
+}
+
+func DecodeNxmCtNwSrc(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtNwSrc, error) {
+	_nxmctnwsrc := &NxmCtNwSrc{Oxm: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("NxmCtNwSrc packet too short: %d < 4", decoder.Length())
+	}
+	_nxmctnwsrc.Value = net.IP(decoder.Read(4))
+	return _nxmctnwsrc, nil
+}
+
+func NewNxmCtNwSrc() *NxmCtNwSrc {
+	obj := &NxmCtNwSrc{
+		Oxm: NewOxm(126980),
+	}
+	return obj
+}
+func (self *NxmCtNwSrc) GetOXMName() string {
+	return "ct_nw_src"
+}
+
+func (self *NxmCtNwSrc) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmCtNwSrc) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmCtNwSrcMasked struct {
+	*Oxm
+	Value     net.IP
+	ValueMask net.IP
+}
+
+type INxmCtNwSrcMasked interface {
+	goloxi.IOxm
+	GetValue() net.IP
+	GetValueMask() net.IP
+}
+
+func (self *NxmCtNwSrcMasked) GetValue() net.IP {
+	return self.Value
+}
+
+func (self *NxmCtNwSrcMasked) SetValue(v net.IP) {
+	self.Value = v
+}
+
+func (self *NxmCtNwSrcMasked) GetValueMask() net.IP {
+	return self.ValueMask
+}
+
+func (self *NxmCtNwSrcMasked) SetValueMask(v net.IP) {
+	self.ValueMask = v
+}
+
+func (self *NxmCtNwSrcMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value.To4())
+	encoder.Write(self.ValueMask.To4())
+
+	return nil
+}
+
+func DecodeNxmCtNwSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtNwSrcMasked, error) {
+	_nxmctnwsrcmasked := &NxmCtNwSrcMasked{Oxm: parent}
+	if decoder.Length() < 8 {
+		return nil, fmt.Errorf("NxmCtNwSrcMasked packet too short: %d < 8", decoder.Length())
+	}
+	_nxmctnwsrcmasked.Value = net.IP(decoder.Read(4))
+	_nxmctnwsrcmasked.ValueMask = net.IP(decoder.Read(4))
+	return _nxmctnwsrcmasked, nil
+}
+
+func NewNxmCtNwSrcMasked() *NxmCtNwSrcMasked {
+	obj := &NxmCtNwSrcMasked{
+		Oxm: NewOxm(127240),
+	}
+	return obj
+}
+func (self *NxmCtNwSrcMasked) GetOXMName() string {
+	return "ct_nw_src_masked"
+}
+
+func (self *NxmCtNwSrcMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmCtNwSrcMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmCtNwSrcMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmCtState struct {
+	*Oxm
+	Value []byte
+}
+
+type INxmCtState interface {
+	goloxi.IOxm
+	GetValue() []byte
+}
+
+func (self *NxmCtState) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmCtState) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmCtState) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeNxmCtState(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtState, error) {
+	_nxmctstate := &NxmCtState{Oxm: parent}
+	_nxmctstate.Value = decoder.Read(int(_nxmctstate.TypeLen & 0xFF))
+	return _nxmctstate, nil
+}
+
+func NewNxmCtState() *NxmCtState {
+	obj := &NxmCtState{
+		Oxm: NewOxm(119300),
+	}
+	return obj
+}
+func (self *NxmCtState) GetOXMName() string {
+	return "ct_state"
+}
+
+func (self *NxmCtState) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmCtState) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmCtStateMasked struct {
+	*Oxm
+	Value     []byte
+	ValueMask []byte
+}
+
+type INxmCtStateMasked interface {
+	goloxi.IOxm
+	GetValue() []byte
+	GetValueMask() []byte
+}
+
+func (self *NxmCtStateMasked) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmCtStateMasked) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmCtStateMasked) GetValueMask() []byte {
+	return self.ValueMask
+}
+
+func (self *NxmCtStateMasked) SetValueMask(v []byte) {
+	self.ValueMask = v
+}
+
+func (self *NxmCtStateMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeNxmCtStateMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtStateMasked, error) {
+	_nxmctstatemasked := &NxmCtStateMasked{Oxm: parent}
+	_nxmctstatemasked.Value = decoder.Read(int(_nxmctstatemasked.TypeLen & 0xFF))
+	_nxmctstatemasked.ValueMask = decoder.Read(int(_nxmctstatemasked.TypeLen & 0xFF))
+	return _nxmctstatemasked, nil
+}
+
+func NewNxmCtStateMasked() *NxmCtStateMasked {
+	obj := &NxmCtStateMasked{
+		Oxm: NewOxm(119560),
+	}
+	return obj
+}
+func (self *NxmCtStateMasked) GetOXMName() string {
+	return "ct_state_masked"
+}
+
+func (self *NxmCtStateMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmCtStateMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmCtStateMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmCtTpDst struct {
+	*Oxm
+	Value uint16
+}
+
+type INxmCtTpDst interface {
+	goloxi.IOxm
+	GetValue() uint16
+}
+
+func (self *NxmCtTpDst) GetValue() uint16 {
+	return self.Value
+}
+
+func (self *NxmCtTpDst) SetValue(v uint16) {
+	self.Value = v
+}
+
+func (self *NxmCtTpDst) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Value))
+
+	return nil
+}
+
+func DecodeNxmCtTpDst(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtTpDst, error) {
+	_nxmcttpdst := &NxmCtTpDst{Oxm: parent}
+	if decoder.Length() < 2 {
+		return nil, fmt.Errorf("NxmCtTpDst packet too short: %d < 2", decoder.Length())
+	}
+	_nxmcttpdst.Value = uint16(decoder.ReadUint16())
+	return _nxmcttpdst, nil
+}
+
+func NewNxmCtTpDst() *NxmCtTpDst {
+	obj := &NxmCtTpDst{
+		Oxm: NewOxm(129538),
+	}
+	return obj
+}
+func (self *NxmCtTpDst) GetOXMName() string {
+	return "ct_tp_dst"
+}
+
+func (self *NxmCtTpDst) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmCtTpDst) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmCtTpDstMasked struct {
+	*Oxm
+	Value     uint16
+	ValueMask uint16
+}
+
+type INxmCtTpDstMasked interface {
+	goloxi.IOxm
+	GetValue() uint16
+	GetValueMask() uint16
+}
+
+func (self *NxmCtTpDstMasked) GetValue() uint16 {
+	return self.Value
+}
+
+func (self *NxmCtTpDstMasked) SetValue(v uint16) {
+	self.Value = v
+}
+
+func (self *NxmCtTpDstMasked) GetValueMask() uint16 {
+	return self.ValueMask
+}
+
+func (self *NxmCtTpDstMasked) SetValueMask(v uint16) {
+	self.ValueMask = v
+}
+
+func (self *NxmCtTpDstMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Value))
+	encoder.PutUint16(uint16(self.ValueMask))
+
+	return nil
+}
+
+func DecodeNxmCtTpDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtTpDstMasked, error) {
+	_nxmcttpdstmasked := &NxmCtTpDstMasked{Oxm: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("NxmCtTpDstMasked packet too short: %d < 4", decoder.Length())
+	}
+	_nxmcttpdstmasked.Value = uint16(decoder.ReadUint16())
+	_nxmcttpdstmasked.ValueMask = uint16(decoder.ReadUint16())
+	return _nxmcttpdstmasked, nil
+}
+
+func NewNxmCtTpDstMasked() *NxmCtTpDstMasked {
+	obj := &NxmCtTpDstMasked{
+		Oxm: NewOxm(129796),
+	}
+	return obj
+}
+func (self *NxmCtTpDstMasked) GetOXMName() string {
+	return "ct_tp_dst_masked"
+}
+
+func (self *NxmCtTpDstMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmCtTpDstMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmCtTpDstMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmCtTpSrc struct {
+	*Oxm
+	Value uint16
+}
+
+type INxmCtTpSrc interface {
+	goloxi.IOxm
+	GetValue() uint16
+}
+
+func (self *NxmCtTpSrc) GetValue() uint16 {
+	return self.Value
+}
+
+func (self *NxmCtTpSrc) SetValue(v uint16) {
+	self.Value = v
+}
+
+func (self *NxmCtTpSrc) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Value))
+
+	return nil
+}
+
+func DecodeNxmCtTpSrc(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtTpSrc, error) {
+	_nxmcttpsrc := &NxmCtTpSrc{Oxm: parent}
+	if decoder.Length() < 2 {
+		return nil, fmt.Errorf("NxmCtTpSrc packet too short: %d < 2", decoder.Length())
+	}
+	_nxmcttpsrc.Value = uint16(decoder.ReadUint16())
+	return _nxmcttpsrc, nil
+}
+
+func NewNxmCtTpSrc() *NxmCtTpSrc {
+	obj := &NxmCtTpSrc{
+		Oxm: NewOxm(129026),
+	}
+	return obj
+}
+func (self *NxmCtTpSrc) GetOXMName() string {
+	return "ct_tp_src"
+}
+
+func (self *NxmCtTpSrc) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmCtTpSrc) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmCtTpSrcMasked struct {
+	*Oxm
+	Value     uint16
+	ValueMask uint16
+}
+
+type INxmCtTpSrcMasked interface {
+	goloxi.IOxm
+	GetValue() uint16
+	GetValueMask() uint16
+}
+
+func (self *NxmCtTpSrcMasked) GetValue() uint16 {
+	return self.Value
+}
+
+func (self *NxmCtTpSrcMasked) SetValue(v uint16) {
+	self.Value = v
+}
+
+func (self *NxmCtTpSrcMasked) GetValueMask() uint16 {
+	return self.ValueMask
+}
+
+func (self *NxmCtTpSrcMasked) SetValueMask(v uint16) {
+	self.ValueMask = v
+}
+
+func (self *NxmCtTpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Value))
+	encoder.PutUint16(uint16(self.ValueMask))
+
+	return nil
+}
+
+func DecodeNxmCtTpSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtTpSrcMasked, error) {
+	_nxmcttpsrcmasked := &NxmCtTpSrcMasked{Oxm: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("NxmCtTpSrcMasked packet too short: %d < 4", decoder.Length())
+	}
+	_nxmcttpsrcmasked.Value = uint16(decoder.ReadUint16())
+	_nxmcttpsrcmasked.ValueMask = uint16(decoder.ReadUint16())
+	return _nxmcttpsrcmasked, nil
+}
+
+func NewNxmCtTpSrcMasked() *NxmCtTpSrcMasked {
+	obj := &NxmCtTpSrcMasked{
+		Oxm: NewOxm(129284),
+	}
+	return obj
+}
+func (self *NxmCtTpSrcMasked) GetOXMName() string {
+	return "ct_tp_src_masked"
+}
+
+func (self *NxmCtTpSrcMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmCtTpSrcMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmCtTpSrcMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmCtZone struct {
+	*Oxm
+	Value uint16
+}
+
+type INxmCtZone interface {
+	goloxi.IOxm
+	GetValue() uint16
+}
+
+func (self *NxmCtZone) GetValue() uint16 {
+	return self.Value
+}
+
+func (self *NxmCtZone) SetValue(v uint16) {
+	self.Value = v
+}
+
+func (self *NxmCtZone) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Value))
+
+	return nil
+}
+
+func DecodeNxmCtZone(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtZone, error) {
+	_nxmctzone := &NxmCtZone{Oxm: parent}
+	if decoder.Length() < 2 {
+		return nil, fmt.Errorf("NxmCtZone packet too short: %d < 2", decoder.Length())
+	}
+	_nxmctzone.Value = uint16(decoder.ReadUint16())
+	return _nxmctzone, nil
+}
+
+func NewNxmCtZone() *NxmCtZone {
+	obj := &NxmCtZone{
+		Oxm: NewOxm(119810),
+	}
+	return obj
+}
+func (self *NxmCtZone) GetOXMName() string {
+	return "ct_zone"
+}
+
+func (self *NxmCtZone) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmCtZone) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmDpHash struct {
+	*Oxm
+	Value uint32
+}
+
+type INxmDpHash interface {
+	goloxi.IOxm
+	GetValue() uint32
+}
+
+func (self *NxmDpHash) GetValue() uint32 {
+	return self.Value
+}
+
+func (self *NxmDpHash) SetValue(v uint32) {
+	self.Value = v
+}
+
+func (self *NxmDpHash) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Value))
+
+	return nil
+}
+
+func DecodeNxmDpHash(parent *Oxm, decoder *goloxi.Decoder) (*NxmDpHash, error) {
+	_nxmdphash := &NxmDpHash{Oxm: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("NxmDpHash packet too short: %d < 4", decoder.Length())
+	}
+	_nxmdphash.Value = uint32(decoder.ReadUint32())
+	return _nxmdphash, nil
+}
+
+func NewNxmDpHash() *NxmDpHash {
+	obj := &NxmDpHash{
+		Oxm: NewOxm(83460),
+	}
+	return obj
+}
+func (self *NxmDpHash) GetOXMName() string {
+	return "dp_hash"
+}
+
+func (self *NxmDpHash) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmDpHash) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmDpHashMasked struct {
+	*Oxm
+	Value     uint32
+	ValueMask uint32
+}
+
+type INxmDpHashMasked interface {
+	goloxi.IOxm
+	GetValue() uint32
+	GetValueMask() uint32
+}
+
+func (self *NxmDpHashMasked) GetValue() uint32 {
+	return self.Value
+}
+
+func (self *NxmDpHashMasked) SetValue(v uint32) {
+	self.Value = v
+}
+
+func (self *NxmDpHashMasked) GetValueMask() uint32 {
+	return self.ValueMask
+}
+
+func (self *NxmDpHashMasked) SetValueMask(v uint32) {
+	self.ValueMask = v
+}
+
+func (self *NxmDpHashMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Value))
+	encoder.PutUint32(uint32(self.ValueMask))
+
+	return nil
+}
+
+func DecodeNxmDpHashMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmDpHashMasked, error) {
+	_nxmdphashmasked := &NxmDpHashMasked{Oxm: parent}
+	if decoder.Length() < 8 {
+		return nil, fmt.Errorf("NxmDpHashMasked packet too short: %d < 8", decoder.Length())
+	}
+	_nxmdphashmasked.Value = uint32(decoder.ReadUint32())
+	_nxmdphashmasked.ValueMask = uint32(decoder.ReadUint32())
+	return _nxmdphashmasked, nil
+}
+
+func NewNxmDpHashMasked() *NxmDpHashMasked {
+	obj := &NxmDpHashMasked{
+		Oxm: NewOxm(83720),
+	}
+	return obj
+}
+func (self *NxmDpHashMasked) GetOXMName() string {
+	return "dp_hash_masked"
+}
+
+func (self *NxmDpHashMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmDpHashMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmDpHashMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmEthDst struct {
+	*Oxm
+	Value net.HardwareAddr
+}
+
+type INxmEthDst interface {
+	goloxi.IOxm
+	GetValue() net.HardwareAddr
+}
+
+func (self *NxmEthDst) GetValue() net.HardwareAddr {
+	return self.Value
+}
+
+func (self *NxmEthDst) SetValue(v net.HardwareAddr) {
+	self.Value = v
+}
+
+func (self *NxmEthDst) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeNxmEthDst(parent *Oxm, decoder *goloxi.Decoder) (*NxmEthDst, error) {
+	_nxmethdst := &NxmEthDst{Oxm: parent}
+	if decoder.Length() < 6 {
+		return nil, fmt.Errorf("NxmEthDst packet too short: %d < 6", decoder.Length())
+	}
+	_nxmethdst.Value = net.HardwareAddr(decoder.Read(6))
+	return _nxmethdst, nil
+}
+
+func NewNxmEthDst() *NxmEthDst {
+	obj := &NxmEthDst{
+		Oxm: NewOxm(518),
+	}
+	return obj
+}
+func (self *NxmEthDst) GetOXMName() string {
+	return "eth_dst"
+}
+
+func (self *NxmEthDst) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmEthDst) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmEthDstMasked struct {
+	*Oxm
+	Value     net.HardwareAddr
+	ValueMask net.HardwareAddr
+}
+
+type INxmEthDstMasked interface {
+	goloxi.IOxm
+	GetValue() net.HardwareAddr
+	GetValueMask() net.HardwareAddr
+}
+
+func (self *NxmEthDstMasked) GetValue() net.HardwareAddr {
+	return self.Value
+}
+
+func (self *NxmEthDstMasked) SetValue(v net.HardwareAddr) {
+	self.Value = v
+}
+
+func (self *NxmEthDstMasked) GetValueMask() net.HardwareAddr {
+	return self.ValueMask
+}
+
+func (self *NxmEthDstMasked) SetValueMask(v net.HardwareAddr) {
+	self.ValueMask = v
+}
+
+func (self *NxmEthDstMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeNxmEthDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmEthDstMasked, error) {
+	_nxmethdstmasked := &NxmEthDstMasked{Oxm: parent}
+	if decoder.Length() < 12 {
+		return nil, fmt.Errorf("NxmEthDstMasked packet too short: %d < 12", decoder.Length())
+	}
+	_nxmethdstmasked.Value = net.HardwareAddr(decoder.Read(6))
+	_nxmethdstmasked.ValueMask = net.HardwareAddr(decoder.Read(6))
+	return _nxmethdstmasked, nil
+}
+
+func NewNxmEthDstMasked() *NxmEthDstMasked {
+	obj := &NxmEthDstMasked{
+		Oxm: NewOxm(779),
+	}
+	return obj
+}
+func (self *NxmEthDstMasked) GetOXMName() string {
+	return "eth_dst_masked"
+}
+
+func (self *NxmEthDstMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmEthDstMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmEthDstMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmEthSrc struct {
+	*Oxm
+	Value net.HardwareAddr
+}
+
+type INxmEthSrc interface {
+	goloxi.IOxm
+	GetValue() net.HardwareAddr
+}
+
+func (self *NxmEthSrc) GetValue() net.HardwareAddr {
+	return self.Value
+}
+
+func (self *NxmEthSrc) SetValue(v net.HardwareAddr) {
+	self.Value = v
+}
+
+func (self *NxmEthSrc) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeNxmEthSrc(parent *Oxm, decoder *goloxi.Decoder) (*NxmEthSrc, error) {
+	_nxmethsrc := &NxmEthSrc{Oxm: parent}
+	if decoder.Length() < 6 {
+		return nil, fmt.Errorf("NxmEthSrc packet too short: %d < 6", decoder.Length())
+	}
+	_nxmethsrc.Value = net.HardwareAddr(decoder.Read(6))
+	return _nxmethsrc, nil
+}
+
+func NewNxmEthSrc() *NxmEthSrc {
+	obj := &NxmEthSrc{
+		Oxm: NewOxm(1030),
+	}
+	return obj
+}
+func (self *NxmEthSrc) GetOXMName() string {
+	return "eth_src"
+}
+
+func (self *NxmEthSrc) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmEthSrc) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmEthSrcMasked struct {
+	*Oxm
+	Value     net.HardwareAddr
+	ValueMask net.HardwareAddr
+}
+
+type INxmEthSrcMasked interface {
+	goloxi.IOxm
+	GetValue() net.HardwareAddr
+	GetValueMask() net.HardwareAddr
+}
+
+func (self *NxmEthSrcMasked) GetValue() net.HardwareAddr {
+	return self.Value
+}
+
+func (self *NxmEthSrcMasked) SetValue(v net.HardwareAddr) {
+	self.Value = v
+}
+
+func (self *NxmEthSrcMasked) GetValueMask() net.HardwareAddr {
+	return self.ValueMask
+}
+
+func (self *NxmEthSrcMasked) SetValueMask(v net.HardwareAddr) {
+	self.ValueMask = v
+}
+
+func (self *NxmEthSrcMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeNxmEthSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmEthSrcMasked, error) {
+	_nxmethsrcmasked := &NxmEthSrcMasked{Oxm: parent}
+	if decoder.Length() < 12 {
+		return nil, fmt.Errorf("NxmEthSrcMasked packet too short: %d < 12", decoder.Length())
+	}
+	_nxmethsrcmasked.Value = net.HardwareAddr(decoder.Read(6))
+	_nxmethsrcmasked.ValueMask = net.HardwareAddr(decoder.Read(6))
+	return _nxmethsrcmasked, nil
+}
+
+func NewNxmEthSrcMasked() *NxmEthSrcMasked {
+	obj := &NxmEthSrcMasked{
+		Oxm: NewOxm(1286),
+	}
+	return obj
+}
+func (self *NxmEthSrcMasked) GetOXMName() string {
+	return "eth_src_masked"
+}
+
+func (self *NxmEthSrcMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmEthSrcMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmEthSrcMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmEthType struct {
+	*Oxm
+	Value uint16
+}
+
+type INxmEthType interface {
+	goloxi.IOxm
+	GetValue() uint16
+}
+
+func (self *NxmEthType) GetValue() uint16 {
+	return self.Value
+}
+
+func (self *NxmEthType) SetValue(v uint16) {
+	self.Value = v
+}
+
+func (self *NxmEthType) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Value))
+
+	return nil
+}
+
+func DecodeNxmEthType(parent *Oxm, decoder *goloxi.Decoder) (*NxmEthType, error) {
+	_nxmethtype := &NxmEthType{Oxm: parent}
+	if decoder.Length() < 2 {
+		return nil, fmt.Errorf("NxmEthType packet too short: %d < 2", decoder.Length())
+	}
+	_nxmethtype.Value = uint16(decoder.ReadUint16())
+	return _nxmethtype, nil
+}
+
+func NewNxmEthType() *NxmEthType {
+	obj := &NxmEthType{
+		Oxm: NewOxm(1538),
+	}
+	return obj
+}
+func (self *NxmEthType) GetOXMName() string {
+	return "eth_type"
+}
+
+func (self *NxmEthType) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmEthType) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmIcmpCode struct {
+	*Oxm
+	Value uint8
+}
+
+type INxmIcmpCode interface {
+	goloxi.IOxm
+	GetValue() uint8
+}
+
+func (self *NxmIcmpCode) GetValue() uint8 {
+	return self.Value
+}
+
+func (self *NxmIcmpCode) SetValue(v uint8) {
+	self.Value = v
+}
+
+func (self *NxmIcmpCode) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint8(uint8(self.Value))
+
+	return nil
+}
+
+func DecodeNxmIcmpCode(parent *Oxm, decoder *goloxi.Decoder) (*NxmIcmpCode, error) {
+	_nxmicmpcode := &NxmIcmpCode{Oxm: parent}
+	if decoder.Length() < 1 {
+		return nil, fmt.Errorf("NxmIcmpCode packet too short: %d < 1", decoder.Length())
+	}
+	_nxmicmpcode.Value = uint8(decoder.ReadByte())
+	return _nxmicmpcode, nil
+}
+
+func NewNxmIcmpCode() *NxmIcmpCode {
+	obj := &NxmIcmpCode{
+		Oxm: NewOxm(7169),
+	}
+	return obj
+}
+func (self *NxmIcmpCode) GetOXMName() string {
+	return "icmp_code"
+}
+
+func (self *NxmIcmpCode) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmIcmpCode) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmIcmpType struct {
+	*Oxm
+	Value uint8
+}
+
+type INxmIcmpType interface {
+	goloxi.IOxm
+	GetValue() uint8
+}
+
+func (self *NxmIcmpType) GetValue() uint8 {
+	return self.Value
+}
+
+func (self *NxmIcmpType) SetValue(v uint8) {
+	self.Value = v
+}
+
+func (self *NxmIcmpType) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint8(uint8(self.Value))
+
+	return nil
+}
+
+func DecodeNxmIcmpType(parent *Oxm, decoder *goloxi.Decoder) (*NxmIcmpType, error) {
+	_nxmicmptype := &NxmIcmpType{Oxm: parent}
+	if decoder.Length() < 1 {
+		return nil, fmt.Errorf("NxmIcmpType packet too short: %d < 1", decoder.Length())
+	}
+	_nxmicmptype.Value = uint8(decoder.ReadByte())
+	return _nxmicmptype, nil
+}
+
+func NewNxmIcmpType() *NxmIcmpType {
+	obj := &NxmIcmpType{
+		Oxm: NewOxm(6657),
+	}
+	return obj
+}
+func (self *NxmIcmpType) GetOXMName() string {
+	return "icmp_type"
+}
+
+func (self *NxmIcmpType) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmIcmpType) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmIcmpv6Code struct {
+	*Oxm
+	Value uint8
+}
+
+type INxmIcmpv6Code interface {
+	goloxi.IOxm
+	GetValue() uint8
+}
+
+func (self *NxmIcmpv6Code) GetValue() uint8 {
+	return self.Value
+}
+
+func (self *NxmIcmpv6Code) SetValue(v uint8) {
+	self.Value = v
+}
+
+func (self *NxmIcmpv6Code) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint8(uint8(self.Value))
+
+	return nil
+}
+
+func DecodeNxmIcmpv6Code(parent *Oxm, decoder *goloxi.Decoder) (*NxmIcmpv6Code, error) {
+	_nxmicmpv6code := &NxmIcmpv6Code{Oxm: parent}
+	if decoder.Length() < 1 {
+		return nil, fmt.Errorf("NxmIcmpv6Code packet too short: %d < 1", decoder.Length())
+	}
+	_nxmicmpv6code.Value = uint8(decoder.ReadByte())
+	return _nxmicmpv6code, nil
+}
+
+func NewNxmIcmpv6Code() *NxmIcmpv6Code {
+	obj := &NxmIcmpv6Code{
+		Oxm: NewOxm(76801),
+	}
+	return obj
+}
+func (self *NxmIcmpv6Code) GetOXMName() string {
+	return "icmpv6_code"
+}
+
+func (self *NxmIcmpv6Code) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmIcmpv6Code) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmIcmpv6Type struct {
+	*Oxm
+	Value uint8
+}
+
+type INxmIcmpv6Type interface {
+	goloxi.IOxm
+	GetValue() uint8
+}
+
+func (self *NxmIcmpv6Type) GetValue() uint8 {
+	return self.Value
+}
+
+func (self *NxmIcmpv6Type) SetValue(v uint8) {
+	self.Value = v
+}
+
+func (self *NxmIcmpv6Type) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint8(uint8(self.Value))
+
+	return nil
+}
+
+func DecodeNxmIcmpv6Type(parent *Oxm, decoder *goloxi.Decoder) (*NxmIcmpv6Type, error) {
+	_nxmicmpv6type := &NxmIcmpv6Type{Oxm: parent}
+	if decoder.Length() < 1 {
+		return nil, fmt.Errorf("NxmIcmpv6Type packet too short: %d < 1", decoder.Length())
+	}
+	_nxmicmpv6type.Value = uint8(decoder.ReadByte())
+	return _nxmicmpv6type, nil
+}
+
+func NewNxmIcmpv6Type() *NxmIcmpv6Type {
+	obj := &NxmIcmpv6Type{
+		Oxm: NewOxm(76289),
+	}
+	return obj
+}
+func (self *NxmIcmpv6Type) GetOXMName() string {
+	return "icmpv6_type"
+}
+
+func (self *NxmIcmpv6Type) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmIcmpv6Type) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmInPort struct {
+	*Oxm
+	Value Port
+}
+
+type INxmInPort interface {
+	goloxi.IOxm
+	GetValue() Port
+}
+
+func (self *NxmInPort) GetValue() Port {
+	return self.Value
+}
+
+func (self *NxmInPort) SetValue(v Port) {
+	self.Value = v
+}
+
+func (self *NxmInPort) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	self.Value.Serialize(encoder)
+
+	return nil
+}
+
+func DecodeNxmInPort(parent *Oxm, decoder *goloxi.Decoder) (*NxmInPort, error) {
+	_nxminport := &NxmInPort{Oxm: parent}
+	if decoder.Length() < 2 {
+		return nil, fmt.Errorf("NxmInPort packet too short: %d < 2", decoder.Length())
+	}
+	_nxminport.Value.Decode(decoder)
+	return _nxminport, nil
+}
+
+func NewNxmInPort() *NxmInPort {
+	obj := &NxmInPort{
+		Oxm: NewOxm(2),
+	}
+	return obj
+}
+func (self *NxmInPort) GetOXMName() string {
+	return "in_port"
+}
+
+func (self *NxmInPort) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmInPort) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmIpDst struct {
+	*Oxm
+	Value net.IP
+}
+
+type INxmIpDst interface {
+	goloxi.IOxm
+	GetValue() net.IP
+}
+
+func (self *NxmIpDst) GetValue() net.IP {
+	return self.Value
+}
+
+func (self *NxmIpDst) SetValue(v net.IP) {
+	self.Value = v
+}
+
+func (self *NxmIpDst) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value.To4())
+
+	return nil
+}
+
+func DecodeNxmIpDst(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpDst, error) {
+	_nxmipdst := &NxmIpDst{Oxm: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("NxmIpDst packet too short: %d < 4", decoder.Length())
+	}
+	_nxmipdst.Value = net.IP(decoder.Read(4))
+	return _nxmipdst, nil
+}
+
+func NewNxmIpDst() *NxmIpDst {
+	obj := &NxmIpDst{
+		Oxm: NewOxm(4100),
+	}
+	return obj
+}
+func (self *NxmIpDst) GetOXMName() string {
+	return "ip_dst"
+}
+
+func (self *NxmIpDst) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmIpDst) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmIpDstMasked struct {
+	*Oxm
+	Value     net.IP
+	ValueMask net.IP
+}
+
+type INxmIpDstMasked interface {
+	goloxi.IOxm
+	GetValue() net.IP
+	GetValueMask() net.IP
+}
+
+func (self *NxmIpDstMasked) GetValue() net.IP {
+	return self.Value
+}
+
+func (self *NxmIpDstMasked) SetValue(v net.IP) {
+	self.Value = v
+}
+
+func (self *NxmIpDstMasked) GetValueMask() net.IP {
+	return self.ValueMask
+}
+
+func (self *NxmIpDstMasked) SetValueMask(v net.IP) {
+	self.ValueMask = v
+}
+
+func (self *NxmIpDstMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value.To4())
+	encoder.Write(self.ValueMask.To4())
+
+	return nil
+}
+
+func DecodeNxmIpDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpDstMasked, error) {
+	_nxmipdstmasked := &NxmIpDstMasked{Oxm: parent}
+	if decoder.Length() < 8 {
+		return nil, fmt.Errorf("NxmIpDstMasked packet too short: %d < 8", decoder.Length())
+	}
+	_nxmipdstmasked.Value = net.IP(decoder.Read(4))
+	_nxmipdstmasked.ValueMask = net.IP(decoder.Read(4))
+	return _nxmipdstmasked, nil
+}
+
+func NewNxmIpDstMasked() *NxmIpDstMasked {
+	obj := &NxmIpDstMasked{
+		Oxm: NewOxm(4360),
+	}
+	return obj
+}
+func (self *NxmIpDstMasked) GetOXMName() string {
+	return "ip_dst_masked"
+}
+
+func (self *NxmIpDstMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmIpDstMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmIpDstMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmIpFrag struct {
+	*Oxm
+	Value []byte
+}
+
+type INxmIpFrag interface {
+	goloxi.IOxm
+	GetValue() []byte
+}
+
+func (self *NxmIpFrag) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmIpFrag) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmIpFrag) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeNxmIpFrag(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpFrag, error) {
+	_nxmipfrag := &NxmIpFrag{Oxm: parent}
+	_nxmipfrag.Value = decoder.Read(int(_nxmipfrag.TypeLen & 0xFF))
+	return _nxmipfrag, nil
+}
+
+func NewNxmIpFrag() *NxmIpFrag {
+	obj := &NxmIpFrag{
+		Oxm: NewOxm(78849),
+	}
+	return obj
+}
+func (self *NxmIpFrag) GetOXMName() string {
+	return "ip_frag"
+}
+
+func (self *NxmIpFrag) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmIpFrag) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmIpFragMasked struct {
+	*Oxm
+	Value     []byte
+	ValueMask []byte
+}
+
+type INxmIpFragMasked interface {
+	goloxi.IOxm
+	GetValue() []byte
+	GetValueMask() []byte
+}
+
+func (self *NxmIpFragMasked) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmIpFragMasked) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmIpFragMasked) GetValueMask() []byte {
+	return self.ValueMask
+}
+
+func (self *NxmIpFragMasked) SetValueMask(v []byte) {
+	self.ValueMask = v
+}
+
+func (self *NxmIpFragMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeNxmIpFragMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpFragMasked, error) {
+	_nxmipfragmasked := &NxmIpFragMasked{Oxm: parent}
+	_nxmipfragmasked.Value = decoder.Read(int(_nxmipfragmasked.TypeLen & 0xFF))
+	_nxmipfragmasked.ValueMask = decoder.Read(int(_nxmipfragmasked.TypeLen & 0xFF))
+	return _nxmipfragmasked, nil
+}
+
+func NewNxmIpFragMasked() *NxmIpFragMasked {
+	obj := &NxmIpFragMasked{
+		Oxm: NewOxm(79106),
+	}
+	return obj
+}
+func (self *NxmIpFragMasked) GetOXMName() string {
+	return "ip_frag_masked"
+}
+
+func (self *NxmIpFragMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmIpFragMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmIpFragMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmIpSrc struct {
+	*Oxm
+	Value net.IP
+}
+
+type INxmIpSrc interface {
+	goloxi.IOxm
+	GetValue() net.IP
+}
+
+func (self *NxmIpSrc) GetValue() net.IP {
+	return self.Value
+}
+
+func (self *NxmIpSrc) SetValue(v net.IP) {
+	self.Value = v
+}
+
+func (self *NxmIpSrc) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value.To4())
+
+	return nil
+}
+
+func DecodeNxmIpSrc(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpSrc, error) {
+	_nxmipsrc := &NxmIpSrc{Oxm: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("NxmIpSrc packet too short: %d < 4", decoder.Length())
+	}
+	_nxmipsrc.Value = net.IP(decoder.Read(4))
+	return _nxmipsrc, nil
+}
+
+func NewNxmIpSrc() *NxmIpSrc {
+	obj := &NxmIpSrc{
+		Oxm: NewOxm(3588),
+	}
+	return obj
+}
+func (self *NxmIpSrc) GetOXMName() string {
+	return "ip_src"
+}
+
+func (self *NxmIpSrc) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmIpSrc) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmIpSrcMasked struct {
+	*Oxm
+	Value     net.IP
+	ValueMask net.IP
+}
+
+type INxmIpSrcMasked interface {
+	goloxi.IOxm
+	GetValue() net.IP
+	GetValueMask() net.IP
+}
+
+func (self *NxmIpSrcMasked) GetValue() net.IP {
+	return self.Value
+}
+
+func (self *NxmIpSrcMasked) SetValue(v net.IP) {
+	self.Value = v
+}
+
+func (self *NxmIpSrcMasked) GetValueMask() net.IP {
+	return self.ValueMask
+}
+
+func (self *NxmIpSrcMasked) SetValueMask(v net.IP) {
+	self.ValueMask = v
+}
+
+func (self *NxmIpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value.To4())
+	encoder.Write(self.ValueMask.To4())
+
+	return nil
+}
+
+func DecodeNxmIpSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpSrcMasked, error) {
+	_nxmipsrcmasked := &NxmIpSrcMasked{Oxm: parent}
+	if decoder.Length() < 8 {
+		return nil, fmt.Errorf("NxmIpSrcMasked packet too short: %d < 8", decoder.Length())
+	}
+	_nxmipsrcmasked.Value = net.IP(decoder.Read(4))
+	_nxmipsrcmasked.ValueMask = net.IP(decoder.Read(4))
+	return _nxmipsrcmasked, nil
+}
+
+func NewNxmIpSrcMasked() *NxmIpSrcMasked {
+	obj := &NxmIpSrcMasked{
+		Oxm: NewOxm(3848),
+	}
+	return obj
+}
+func (self *NxmIpSrcMasked) GetOXMName() string {
+	return "ip_src_masked"
+}
+
+func (self *NxmIpSrcMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmIpSrcMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmIpSrcMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmIpv6Dst struct {
+	*Oxm
+	Value net.IP
+}
+
+type INxmIpv6Dst interface {
+	goloxi.IOxm
+	GetValue() net.IP
+}
+
+func (self *NxmIpv6Dst) GetValue() net.IP {
+	return self.Value
+}
+
+func (self *NxmIpv6Dst) SetValue(v net.IP) {
+	self.Value = v
+}
+
+func (self *NxmIpv6Dst) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value.To16())
+
+	return nil
+}
+
+func DecodeNxmIpv6Dst(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpv6Dst, error) {
+	_nxmipv6dst := &NxmIpv6Dst{Oxm: parent}
+	if decoder.Length() < 16 {
+		return nil, fmt.Errorf("NxmIpv6Dst packet too short: %d < 16", decoder.Length())
+	}
+	_nxmipv6dst.Value = net.IP(decoder.Read(16))
+	return _nxmipv6dst, nil
+}
+
+func NewNxmIpv6Dst() *NxmIpv6Dst {
+	obj := &NxmIpv6Dst{
+		Oxm: NewOxm(75792),
+	}
+	return obj
+}
+func (self *NxmIpv6Dst) GetOXMName() string {
+	return "ipv6_dst"
+}
+
+func (self *NxmIpv6Dst) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmIpv6Dst) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmIpv6DstMasked struct {
+	*Oxm
+	Value     net.IP
+	ValueMask net.IP
+}
+
+type INxmIpv6DstMasked interface {
+	goloxi.IOxm
+	GetValue() net.IP
+	GetValueMask() net.IP
+}
+
+func (self *NxmIpv6DstMasked) GetValue() net.IP {
+	return self.Value
+}
+
+func (self *NxmIpv6DstMasked) SetValue(v net.IP) {
+	self.Value = v
+}
+
+func (self *NxmIpv6DstMasked) GetValueMask() net.IP {
+	return self.ValueMask
+}
+
+func (self *NxmIpv6DstMasked) SetValueMask(v net.IP) {
+	self.ValueMask = v
+}
+
+func (self *NxmIpv6DstMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value.To16())
+	encoder.Write(self.ValueMask.To16())
+
+	return nil
+}
+
+func DecodeNxmIpv6DstMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpv6DstMasked, error) {
+	_nxmipv6dstmasked := &NxmIpv6DstMasked{Oxm: parent}
+	if decoder.Length() < 32 {
+		return nil, fmt.Errorf("NxmIpv6DstMasked packet too short: %d < 32", decoder.Length())
+	}
+	_nxmipv6dstmasked.Value = net.IP(decoder.Read(16))
+	_nxmipv6dstmasked.ValueMask = net.IP(decoder.Read(16))
+	return _nxmipv6dstmasked, nil
+}
+
+func NewNxmIpv6DstMasked() *NxmIpv6DstMasked {
+	obj := &NxmIpv6DstMasked{
+		Oxm: NewOxm(76064),
+	}
+	return obj
+}
+func (self *NxmIpv6DstMasked) GetOXMName() string {
+	return "ipv6_dst_masked"
+}
+
+func (self *NxmIpv6DstMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmIpv6DstMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmIpv6DstMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmIpv6Label struct {
+	*Oxm
+	Value uint32
+}
+
+type INxmIpv6Label interface {
+	goloxi.IOxm
+	GetValue() uint32
+}
+
+func (self *NxmIpv6Label) GetValue() uint32 {
+	return self.Value
+}
+
+func (self *NxmIpv6Label) SetValue(v uint32) {
+	self.Value = v
+}
+
+func (self *NxmIpv6Label) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Value))
+
+	return nil
+}
+
+func DecodeNxmIpv6Label(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpv6Label, error) {
+	_nxmipv6label := &NxmIpv6Label{Oxm: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("NxmIpv6Label packet too short: %d < 4", decoder.Length())
+	}
+	_nxmipv6label.Value = uint32(decoder.ReadUint32())
+	return _nxmipv6label, nil
+}
+
+func NewNxmIpv6Label() *NxmIpv6Label {
+	obj := &NxmIpv6Label{
+		Oxm: NewOxm(79364),
+	}
+	return obj
+}
+func (self *NxmIpv6Label) GetOXMName() string {
+	return "ipv6_label"
+}
+
+func (self *NxmIpv6Label) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmIpv6Label) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmIpv6LabelMasked struct {
+	*Oxm
+	Value     uint32
+	ValueMask uint32
+}
+
+type INxmIpv6LabelMasked interface {
+	goloxi.IOxm
+	GetValue() uint32
+	GetValueMask() uint32
+}
+
+func (self *NxmIpv6LabelMasked) GetValue() uint32 {
+	return self.Value
+}
+
+func (self *NxmIpv6LabelMasked) SetValue(v uint32) {
+	self.Value = v
+}
+
+func (self *NxmIpv6LabelMasked) GetValueMask() uint32 {
+	return self.ValueMask
+}
+
+func (self *NxmIpv6LabelMasked) SetValueMask(v uint32) {
+	self.ValueMask = v
+}
+
+func (self *NxmIpv6LabelMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Value))
+	encoder.PutUint32(uint32(self.ValueMask))
+
+	return nil
+}
+
+func DecodeNxmIpv6LabelMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpv6LabelMasked, error) {
+	_nxmipv6labelmasked := &NxmIpv6LabelMasked{Oxm: parent}
+	if decoder.Length() < 8 {
+		return nil, fmt.Errorf("NxmIpv6LabelMasked packet too short: %d < 8", decoder.Length())
+	}
+	_nxmipv6labelmasked.Value = uint32(decoder.ReadUint32())
+	_nxmipv6labelmasked.ValueMask = uint32(decoder.ReadUint32())
+	return _nxmipv6labelmasked, nil
+}
+
+func NewNxmIpv6LabelMasked() *NxmIpv6LabelMasked {
+	obj := &NxmIpv6LabelMasked{
+		Oxm: NewOxm(79624),
+	}
+	return obj
+}
+func (self *NxmIpv6LabelMasked) GetOXMName() string {
+	return "ipv6_label_masked"
+}
+
+func (self *NxmIpv6LabelMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmIpv6LabelMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmIpv6LabelMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmIpv6Src struct {
+	*Oxm
+	Value net.IP
+}
+
+type INxmIpv6Src interface {
+	goloxi.IOxm
+	GetValue() net.IP
+}
+
+func (self *NxmIpv6Src) GetValue() net.IP {
+	return self.Value
+}
+
+func (self *NxmIpv6Src) SetValue(v net.IP) {
+	self.Value = v
+}
+
+func (self *NxmIpv6Src) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value.To16())
+
+	return nil
+}
+
+func DecodeNxmIpv6Src(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpv6Src, error) {
+	_nxmipv6src := &NxmIpv6Src{Oxm: parent}
+	if decoder.Length() < 16 {
+		return nil, fmt.Errorf("NxmIpv6Src packet too short: %d < 16", decoder.Length())
+	}
+	_nxmipv6src.Value = net.IP(decoder.Read(16))
+	return _nxmipv6src, nil
+}
+
+func NewNxmIpv6Src() *NxmIpv6Src {
+	obj := &NxmIpv6Src{
+		Oxm: NewOxm(75280),
+	}
+	return obj
+}
+func (self *NxmIpv6Src) GetOXMName() string {
+	return "ipv6_src"
+}
+
+func (self *NxmIpv6Src) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmIpv6Src) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmIpv6SrcMasked struct {
+	*Oxm
+	Value     net.IP
+	ValueMask net.IP
+}
+
+type INxmIpv6SrcMasked interface {
+	goloxi.IOxm
+	GetValue() net.IP
+	GetValueMask() net.IP
+}
+
+func (self *NxmIpv6SrcMasked) GetValue() net.IP {
+	return self.Value
+}
+
+func (self *NxmIpv6SrcMasked) SetValue(v net.IP) {
+	self.Value = v
+}
+
+func (self *NxmIpv6SrcMasked) GetValueMask() net.IP {
+	return self.ValueMask
+}
+
+func (self *NxmIpv6SrcMasked) SetValueMask(v net.IP) {
+	self.ValueMask = v
+}
+
+func (self *NxmIpv6SrcMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value.To16())
+	encoder.Write(self.ValueMask.To16())
+
+	return nil
+}
+
+func DecodeNxmIpv6SrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpv6SrcMasked, error) {
+	_nxmipv6srcmasked := &NxmIpv6SrcMasked{Oxm: parent}
+	if decoder.Length() < 32 {
+		return nil, fmt.Errorf("NxmIpv6SrcMasked packet too short: %d < 32", decoder.Length())
+	}
+	_nxmipv6srcmasked.Value = net.IP(decoder.Read(16))
+	_nxmipv6srcmasked.ValueMask = net.IP(decoder.Read(16))
+	return _nxmipv6srcmasked, nil
+}
+
+func NewNxmIpv6SrcMasked() *NxmIpv6SrcMasked {
+	obj := &NxmIpv6SrcMasked{
+		Oxm: NewOxm(75552),
+	}
+	return obj
+}
+func (self *NxmIpv6SrcMasked) GetOXMName() string {
+	return "ipv6_src_masked"
+}
+
+func (self *NxmIpv6SrcMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmIpv6SrcMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmIpv6SrcMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmMplsTtl struct {
+	*Oxm
+	Value uint8
+}
+
+type INxmMplsTtl interface {
+	goloxi.IOxm
+	GetValue() uint8
+}
+
+func (self *NxmMplsTtl) GetValue() uint8 {
+	return self.Value
+}
+
+func (self *NxmMplsTtl) SetValue(v uint8) {
+	self.Value = v
+}
+
+func (self *NxmMplsTtl) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint8(uint8(self.Value))
+
+	return nil
+}
+
+func DecodeNxmMplsTtl(parent *Oxm, decoder *goloxi.Decoder) (*NxmMplsTtl, error) {
+	_nxmmplsttl := &NxmMplsTtl{Oxm: parent}
+	if decoder.Length() < 1 {
+		return nil, fmt.Errorf("NxmMplsTtl packet too short: %d < 1", decoder.Length())
+	}
+	_nxmmplsttl.Value = uint8(decoder.ReadByte())
+	return _nxmmplsttl, nil
+}
+
+func NewNxmMplsTtl() *NxmMplsTtl {
+	obj := &NxmMplsTtl{
+		Oxm: NewOxm(80897),
+	}
+	return obj
+}
+func (self *NxmMplsTtl) GetOXMName() string {
+	return "mpls_ttl"
+}
+
+func (self *NxmMplsTtl) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmMplsTtl) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmNdSll struct {
+	*Oxm
+	Value net.HardwareAddr
+}
+
+type INxmNdSll interface {
+	goloxi.IOxm
+	GetValue() net.HardwareAddr
+}
+
+func (self *NxmNdSll) GetValue() net.HardwareAddr {
+	return self.Value
+}
+
+func (self *NxmNdSll) SetValue(v net.HardwareAddr) {
+	self.Value = v
+}
+
+func (self *NxmNdSll) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeNxmNdSll(parent *Oxm, decoder *goloxi.Decoder) (*NxmNdSll, error) {
+	_nxmndsll := &NxmNdSll{Oxm: parent}
+	if decoder.Length() < 6 {
+		return nil, fmt.Errorf("NxmNdSll packet too short: %d < 6", decoder.Length())
+	}
+	_nxmndsll.Value = net.HardwareAddr(decoder.Read(6))
+	return _nxmndsll, nil
+}
+
+func NewNxmNdSll() *NxmNdSll {
+	obj := &NxmNdSll{
+		Oxm: NewOxm(77830),
+	}
+	return obj
+}
+func (self *NxmNdSll) GetOXMName() string {
+	return "nd_sll"
+}
+
+func (self *NxmNdSll) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmNdSll) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmNdSllMasked struct {
+	*Oxm
+	Value     net.HardwareAddr
+	ValueMask net.HardwareAddr
+}
+
+type INxmNdSllMasked interface {
+	goloxi.IOxm
+	GetValue() net.HardwareAddr
+	GetValueMask() net.HardwareAddr
+}
+
+func (self *NxmNdSllMasked) GetValue() net.HardwareAddr {
+	return self.Value
+}
+
+func (self *NxmNdSllMasked) SetValue(v net.HardwareAddr) {
+	self.Value = v
+}
+
+func (self *NxmNdSllMasked) GetValueMask() net.HardwareAddr {
+	return self.ValueMask
+}
+
+func (self *NxmNdSllMasked) SetValueMask(v net.HardwareAddr) {
+	self.ValueMask = v
+}
+
+func (self *NxmNdSllMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeNxmNdSllMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmNdSllMasked, error) {
+	_nxmndsllmasked := &NxmNdSllMasked{Oxm: parent}
+	if decoder.Length() < 12 {
+		return nil, fmt.Errorf("NxmNdSllMasked packet too short: %d < 12", decoder.Length())
+	}
+	_nxmndsllmasked.Value = net.HardwareAddr(decoder.Read(6))
+	_nxmndsllmasked.ValueMask = net.HardwareAddr(decoder.Read(6))
+	return _nxmndsllmasked, nil
+}
+
+func NewNxmNdSllMasked() *NxmNdSllMasked {
+	obj := &NxmNdSllMasked{
+		Oxm: NewOxm(78091),
+	}
+	return obj
+}
+func (self *NxmNdSllMasked) GetOXMName() string {
+	return "nd_sll_masked"
+}
+
+func (self *NxmNdSllMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmNdSllMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmNdSllMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmNdTarget struct {
+	*Oxm
+	Value net.IP
+}
+
+type INxmNdTarget interface {
+	goloxi.IOxm
+	GetValue() net.IP
+}
+
+func (self *NxmNdTarget) GetValue() net.IP {
+	return self.Value
+}
+
+func (self *NxmNdTarget) SetValue(v net.IP) {
+	self.Value = v
+}
+
+func (self *NxmNdTarget) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value.To16())
+
+	return nil
+}
+
+func DecodeNxmNdTarget(parent *Oxm, decoder *goloxi.Decoder) (*NxmNdTarget, error) {
+	_nxmndtarget := &NxmNdTarget{Oxm: parent}
+	if decoder.Length() < 16 {
+		return nil, fmt.Errorf("NxmNdTarget packet too short: %d < 16", decoder.Length())
+	}
+	_nxmndtarget.Value = net.IP(decoder.Read(16))
+	return _nxmndtarget, nil
+}
+
+func NewNxmNdTarget() *NxmNdTarget {
+	obj := &NxmNdTarget{
+		Oxm: NewOxm(77328),
+	}
+	return obj
+}
+func (self *NxmNdTarget) GetOXMName() string {
+	return "nd_target"
+}
+
+func (self *NxmNdTarget) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmNdTarget) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmNdTargetMasked struct {
+	*Oxm
+	Value     net.IP
+	ValueMask net.IP
+}
+
+type INxmNdTargetMasked interface {
+	goloxi.IOxm
+	GetValue() net.IP
+	GetValueMask() net.IP
+}
+
+func (self *NxmNdTargetMasked) GetValue() net.IP {
+	return self.Value
+}
+
+func (self *NxmNdTargetMasked) SetValue(v net.IP) {
+	self.Value = v
+}
+
+func (self *NxmNdTargetMasked) GetValueMask() net.IP {
+	return self.ValueMask
+}
+
+func (self *NxmNdTargetMasked) SetValueMask(v net.IP) {
+	self.ValueMask = v
+}
+
+func (self *NxmNdTargetMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value.To16())
+	encoder.Write(self.ValueMask.To16())
+
+	return nil
+}
+
+func DecodeNxmNdTargetMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmNdTargetMasked, error) {
+	_nxmndtargetmasked := &NxmNdTargetMasked{Oxm: parent}
+	if decoder.Length() < 32 {
+		return nil, fmt.Errorf("NxmNdTargetMasked packet too short: %d < 32", decoder.Length())
+	}
+	_nxmndtargetmasked.Value = net.IP(decoder.Read(16))
+	_nxmndtargetmasked.ValueMask = net.IP(decoder.Read(16))
+	return _nxmndtargetmasked, nil
+}
+
+func NewNxmNdTargetMasked() *NxmNdTargetMasked {
+	obj := &NxmNdTargetMasked{
+		Oxm: NewOxm(77600),
+	}
+	return obj
+}
+func (self *NxmNdTargetMasked) GetOXMName() string {
+	return "nd_target_masked"
+}
+
+func (self *NxmNdTargetMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmNdTargetMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmNdTargetMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmNdTll struct {
+	*Oxm
+	Value net.HardwareAddr
+}
+
+type INxmNdTll interface {
+	goloxi.IOxm
+	GetValue() net.HardwareAddr
+}
+
+func (self *NxmNdTll) GetValue() net.HardwareAddr {
+	return self.Value
+}
+
+func (self *NxmNdTll) SetValue(v net.HardwareAddr) {
+	self.Value = v
+}
+
+func (self *NxmNdTll) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeNxmNdTll(parent *Oxm, decoder *goloxi.Decoder) (*NxmNdTll, error) {
+	_nxmndtll := &NxmNdTll{Oxm: parent}
+	if decoder.Length() < 6 {
+		return nil, fmt.Errorf("NxmNdTll packet too short: %d < 6", decoder.Length())
+	}
+	_nxmndtll.Value = net.HardwareAddr(decoder.Read(6))
+	return _nxmndtll, nil
+}
+
+func NewNxmNdTll() *NxmNdTll {
+	obj := &NxmNdTll{
+		Oxm: NewOxm(78342),
+	}
+	return obj
+}
+func (self *NxmNdTll) GetOXMName() string {
+	return "nd_tll"
+}
+
+func (self *NxmNdTll) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmNdTll) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmNdTllMasked struct {
+	*Oxm
+	Value     net.HardwareAddr
+	ValueMask net.HardwareAddr
+}
+
+type INxmNdTllMasked interface {
+	goloxi.IOxm
+	GetValue() net.HardwareAddr
+	GetValueMask() net.HardwareAddr
+}
+
+func (self *NxmNdTllMasked) GetValue() net.HardwareAddr {
+	return self.Value
+}
+
+func (self *NxmNdTllMasked) SetValue(v net.HardwareAddr) {
+	self.Value = v
+}
+
+func (self *NxmNdTllMasked) GetValueMask() net.HardwareAddr {
+	return self.ValueMask
+}
+
+func (self *NxmNdTllMasked) SetValueMask(v net.HardwareAddr) {
+	self.ValueMask = v
+}
+
+func (self *NxmNdTllMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeNxmNdTllMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmNdTllMasked, error) {
+	_nxmndtllmasked := &NxmNdTllMasked{Oxm: parent}
+	if decoder.Length() < 12 {
+		return nil, fmt.Errorf("NxmNdTllMasked packet too short: %d < 12", decoder.Length())
+	}
+	_nxmndtllmasked.Value = net.HardwareAddr(decoder.Read(6))
+	_nxmndtllmasked.ValueMask = net.HardwareAddr(decoder.Read(6))
+	return _nxmndtllmasked, nil
+}
+
+func NewNxmNdTllMasked() *NxmNdTllMasked {
+	obj := &NxmNdTllMasked{
+		Oxm: NewOxm(78603),
+	}
+	return obj
+}
+func (self *NxmNdTllMasked) GetOXMName() string {
+	return "nd_tll_masked"
+}
+
+func (self *NxmNdTllMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmNdTllMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmNdTllMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmNwEcn struct {
+	*Oxm
+	Value uint8
+}
+
+type INxmNwEcn interface {
+	goloxi.IOxm
+	GetValue() uint8
+}
+
+func (self *NxmNwEcn) GetValue() uint8 {
+	return self.Value
+}
+
+func (self *NxmNwEcn) SetValue(v uint8) {
+	self.Value = v
+}
+
+func (self *NxmNwEcn) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint8(uint8(self.Value))
+
+	return nil
+}
+
+func DecodeNxmNwEcn(parent *Oxm, decoder *goloxi.Decoder) (*NxmNwEcn, error) {
+	_nxmnwecn := &NxmNwEcn{Oxm: parent}
+	if decoder.Length() < 1 {
+		return nil, fmt.Errorf("NxmNwEcn packet too short: %d < 1", decoder.Length())
+	}
+	_nxmnwecn.Value = uint8(decoder.ReadByte())
+	return _nxmnwecn, nil
+}
+
+func NewNxmNwEcn() *NxmNwEcn {
+	obj := &NxmNwEcn{
+		Oxm: NewOxm(79873),
+	}
+	return obj
+}
+func (self *NxmNwEcn) GetOXMName() string {
+	return "nw_ecn"
+}
+
+func (self *NxmNwEcn) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmNwEcn) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmNwProto struct {
+	*Oxm
+	Value uint8
+}
+
+type INxmNwProto interface {
+	goloxi.IOxm
+	GetValue() uint8
+}
+
+func (self *NxmNwProto) GetValue() uint8 {
+	return self.Value
+}
+
+func (self *NxmNwProto) SetValue(v uint8) {
+	self.Value = v
+}
+
+func (self *NxmNwProto) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint8(uint8(self.Value))
+
+	return nil
+}
+
+func DecodeNxmNwProto(parent *Oxm, decoder *goloxi.Decoder) (*NxmNwProto, error) {
+	_nxmnwproto := &NxmNwProto{Oxm: parent}
+	if decoder.Length() < 1 {
+		return nil, fmt.Errorf("NxmNwProto packet too short: %d < 1", decoder.Length())
+	}
+	_nxmnwproto.Value = uint8(decoder.ReadByte())
+	return _nxmnwproto, nil
+}
+
+func NewNxmNwProto() *NxmNwProto {
+	obj := &NxmNwProto{
+		Oxm: NewOxm(3073),
+	}
+	return obj
+}
+func (self *NxmNwProto) GetOXMName() string {
+	return "nw_proto"
+}
+
+func (self *NxmNwProto) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmNwProto) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmNwTos struct {
+	*Oxm
+	Value uint8
+}
+
+type INxmNwTos interface {
+	goloxi.IOxm
+	GetValue() uint8
+}
+
+func (self *NxmNwTos) GetValue() uint8 {
+	return self.Value
+}
+
+func (self *NxmNwTos) SetValue(v uint8) {
+	self.Value = v
+}
+
+func (self *NxmNwTos) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint8(uint8(self.Value))
+
+	return nil
+}
+
+func DecodeNxmNwTos(parent *Oxm, decoder *goloxi.Decoder) (*NxmNwTos, error) {
+	_nxmnwtos := &NxmNwTos{Oxm: parent}
+	if decoder.Length() < 1 {
+		return nil, fmt.Errorf("NxmNwTos packet too short: %d < 1", decoder.Length())
+	}
+	_nxmnwtos.Value = uint8(decoder.ReadByte())
+	return _nxmnwtos, nil
+}
+
+func NewNxmNwTos() *NxmNwTos {
+	obj := &NxmNwTos{
+		Oxm: NewOxm(2561),
+	}
+	return obj
+}
+func (self *NxmNwTos) GetOXMName() string {
+	return "nw_tos"
+}
+
+func (self *NxmNwTos) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmNwTos) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmNwTtl struct {
+	*Oxm
+	Value uint8
+}
+
+type INxmNwTtl interface {
+	goloxi.IOxm
+	GetValue() uint8
+}
+
+func (self *NxmNwTtl) GetValue() uint8 {
+	return self.Value
+}
+
+func (self *NxmNwTtl) SetValue(v uint8) {
+	self.Value = v
+}
+
+func (self *NxmNwTtl) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint8(uint8(self.Value))
+
+	return nil
+}
+
+func DecodeNxmNwTtl(parent *Oxm, decoder *goloxi.Decoder) (*NxmNwTtl, error) {
+	_nxmnwttl := &NxmNwTtl{Oxm: parent}
+	if decoder.Length() < 1 {
+		return nil, fmt.Errorf("NxmNwTtl packet too short: %d < 1", decoder.Length())
+	}
+	_nxmnwttl.Value = uint8(decoder.ReadByte())
+	return _nxmnwttl, nil
+}
+
+func NewNxmNwTtl() *NxmNwTtl {
+	obj := &NxmNwTtl{
+		Oxm: NewOxm(80385),
+	}
+	return obj
+}
+func (self *NxmNwTtl) GetOXMName() string {
+	return "nw_ttl"
+}
+
+func (self *NxmNwTtl) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmNwTtl) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmPktMark struct {
+	*Oxm
+	Value uint32
+}
+
+type INxmPktMark interface {
+	goloxi.IOxm
+	GetValue() uint32
+}
+
+func (self *NxmPktMark) GetValue() uint32 {
+	return self.Value
+}
+
+func (self *NxmPktMark) SetValue(v uint32) {
+	self.Value = v
+}
+
+func (self *NxmPktMark) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Value))
+
+	return nil
+}
+
+func DecodeNxmPktMark(parent *Oxm, decoder *goloxi.Decoder) (*NxmPktMark, error) {
+	_nxmpktmark := &NxmPktMark{Oxm: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("NxmPktMark packet too short: %d < 4", decoder.Length())
+	}
+	_nxmpktmark.Value = uint32(decoder.ReadUint32())
+	return _nxmpktmark, nil
+}
+
+func NewNxmPktMark() *NxmPktMark {
+	obj := &NxmPktMark{
+		Oxm: NewOxm(82436),
+	}
+	return obj
+}
+func (self *NxmPktMark) GetOXMName() string {
+	return "pkt_mark"
+}
+
+func (self *NxmPktMark) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmPktMark) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmPktMarkMasked struct {
+	*Oxm
+	Value     uint32
+	ValueMask uint32
+}
+
+type INxmPktMarkMasked interface {
+	goloxi.IOxm
+	GetValue() uint32
+	GetValueMask() uint32
+}
+
+func (self *NxmPktMarkMasked) GetValue() uint32 {
+	return self.Value
+}
+
+func (self *NxmPktMarkMasked) SetValue(v uint32) {
+	self.Value = v
+}
+
+func (self *NxmPktMarkMasked) GetValueMask() uint32 {
+	return self.ValueMask
+}
+
+func (self *NxmPktMarkMasked) SetValueMask(v uint32) {
+	self.ValueMask = v
+}
+
+func (self *NxmPktMarkMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Value))
+	encoder.PutUint32(uint32(self.ValueMask))
+
+	return nil
+}
+
+func DecodeNxmPktMarkMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmPktMarkMasked, error) {
+	_nxmpktmarkmasked := &NxmPktMarkMasked{Oxm: parent}
+	if decoder.Length() < 8 {
+		return nil, fmt.Errorf("NxmPktMarkMasked packet too short: %d < 8", decoder.Length())
+	}
+	_nxmpktmarkmasked.Value = uint32(decoder.ReadUint32())
+	_nxmpktmarkmasked.ValueMask = uint32(decoder.ReadUint32())
+	return _nxmpktmarkmasked, nil
+}
+
+func NewNxmPktMarkMasked() *NxmPktMarkMasked {
+	obj := &NxmPktMarkMasked{
+		Oxm: NewOxm(82696),
+	}
+	return obj
+}
+func (self *NxmPktMarkMasked) GetOXMName() string {
+	return "pkt_mark_masked"
+}
+
+func (self *NxmPktMarkMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmPktMarkMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmPktMarkMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmRecircId struct {
+	*Oxm
+	Value uint32
+}
+
+type INxmRecircId interface {
+	goloxi.IOxm
+	GetValue() uint32
+}
+
+func (self *NxmRecircId) GetValue() uint32 {
+	return self.Value
+}
+
+func (self *NxmRecircId) SetValue(v uint32) {
+	self.Value = v
+}
+
+func (self *NxmRecircId) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Value))
+
+	return nil
+}
+
+func DecodeNxmRecircId(parent *Oxm, decoder *goloxi.Decoder) (*NxmRecircId, error) {
+	_nxmrecircid := &NxmRecircId{Oxm: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("NxmRecircId packet too short: %d < 4", decoder.Length())
+	}
+	_nxmrecircid.Value = uint32(decoder.ReadUint32())
+	return _nxmrecircid, nil
+}
+
+func NewNxmRecircId() *NxmRecircId {
+	obj := &NxmRecircId{
+		Oxm: NewOxm(83972),
+	}
+	return obj
+}
+func (self *NxmRecircId) GetOXMName() string {
+	return "recirc_id"
+}
+
+func (self *NxmRecircId) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmRecircId) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmReg0 struct {
+	*Oxm
+	Value uint32
+}
+
+type INxmReg0 interface {
+	goloxi.IOxm
+	GetValue() uint32
+}
+
+func (self *NxmReg0) GetValue() uint32 {
+	return self.Value
+}
+
+func (self *NxmReg0) SetValue(v uint32) {
+	self.Value = v
+}
+
+func (self *NxmReg0) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Value))
+
+	return nil
+}
+
+func DecodeNxmReg0(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg0, error) {
+	_nxmreg0 := &NxmReg0{Oxm: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("NxmReg0 packet too short: %d < 4", decoder.Length())
+	}
+	_nxmreg0.Value = uint32(decoder.ReadUint32())
+	return _nxmreg0, nil
+}
+
+func NewNxmReg0() *NxmReg0 {
+	obj := &NxmReg0{
+		Oxm: NewOxm(65540),
+	}
+	return obj
+}
+func (self *NxmReg0) GetOXMName() string {
+	return "reg0"
+}
+
+func (self *NxmReg0) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmReg0) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmReg0Masked struct {
+	*Oxm
+	Value     uint32
+	ValueMask uint32
+}
+
+type INxmReg0Masked interface {
+	goloxi.IOxm
+	GetValue() uint32
+	GetValueMask() uint32
+}
+
+func (self *NxmReg0Masked) GetValue() uint32 {
+	return self.Value
+}
+
+func (self *NxmReg0Masked) SetValue(v uint32) {
+	self.Value = v
+}
+
+func (self *NxmReg0Masked) GetValueMask() uint32 {
+	return self.ValueMask
+}
+
+func (self *NxmReg0Masked) SetValueMask(v uint32) {
+	self.ValueMask = v
+}
+
+func (self *NxmReg0Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Value))
+	encoder.PutUint32(uint32(self.ValueMask))
+
+	return nil
+}
+
+func DecodeNxmReg0Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg0Masked, error) {
+	_nxmreg0masked := &NxmReg0Masked{Oxm: parent}
+	if decoder.Length() < 8 {
+		return nil, fmt.Errorf("NxmReg0Masked packet too short: %d < 8", decoder.Length())
+	}
+	_nxmreg0masked.Value = uint32(decoder.ReadUint32())
+	_nxmreg0masked.ValueMask = uint32(decoder.ReadUint32())
+	return _nxmreg0masked, nil
+}
+
+func NewNxmReg0Masked() *NxmReg0Masked {
+	obj := &NxmReg0Masked{
+		Oxm: NewOxm(65800),
+	}
+	return obj
+}
+func (self *NxmReg0Masked) GetOXMName() string {
+	return "reg0_masked"
+}
+
+func (self *NxmReg0Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmReg0Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmReg0Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmReg1 struct {
+	*Oxm
+	Value uint32
+}
+
+type INxmReg1 interface {
+	goloxi.IOxm
+	GetValue() uint32
+}
+
+func (self *NxmReg1) GetValue() uint32 {
+	return self.Value
+}
+
+func (self *NxmReg1) SetValue(v uint32) {
+	self.Value = v
+}
+
+func (self *NxmReg1) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Value))
+
+	return nil
+}
+
+func DecodeNxmReg1(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg1, error) {
+	_nxmreg1 := &NxmReg1{Oxm: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("NxmReg1 packet too short: %d < 4", decoder.Length())
+	}
+	_nxmreg1.Value = uint32(decoder.ReadUint32())
+	return _nxmreg1, nil
+}
+
+func NewNxmReg1() *NxmReg1 {
+	obj := &NxmReg1{
+		Oxm: NewOxm(66052),
+	}
+	return obj
+}
+func (self *NxmReg1) GetOXMName() string {
+	return "reg1"
+}
+
+func (self *NxmReg1) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmReg1) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmReg10 struct {
+	*Oxm
+	Value uint32
+}
+
+type INxmReg10 interface {
+	goloxi.IOxm
+	GetValue() uint32
+}
+
+func (self *NxmReg10) GetValue() uint32 {
+	return self.Value
+}
+
+func (self *NxmReg10) SetValue(v uint32) {
+	self.Value = v
+}
+
+func (self *NxmReg10) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Value))
+
+	return nil
+}
+
+func DecodeNxmReg10(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg10, error) {
+	_nxmreg10 := &NxmReg10{Oxm: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("NxmReg10 packet too short: %d < 4", decoder.Length())
+	}
+	_nxmreg10.Value = uint32(decoder.ReadUint32())
+	return _nxmreg10, nil
+}
+
+func NewNxmReg10() *NxmReg10 {
+	obj := &NxmReg10{
+		Oxm: NewOxm(70660),
+	}
+	return obj
+}
+func (self *NxmReg10) GetOXMName() string {
+	return "reg10"
+}
+
+func (self *NxmReg10) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmReg10) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmReg10Masked struct {
+	*Oxm
+	Value     uint32
+	ValueMask uint32
+}
+
+type INxmReg10Masked interface {
+	goloxi.IOxm
+	GetValue() uint32
+	GetValueMask() uint32
+}
+
+func (self *NxmReg10Masked) GetValue() uint32 {
+	return self.Value
+}
+
+func (self *NxmReg10Masked) SetValue(v uint32) {
+	self.Value = v
+}
+
+func (self *NxmReg10Masked) GetValueMask() uint32 {
+	return self.ValueMask
+}
+
+func (self *NxmReg10Masked) SetValueMask(v uint32) {
+	self.ValueMask = v
+}
+
+func (self *NxmReg10Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Value))
+	encoder.PutUint32(uint32(self.ValueMask))
+
+	return nil
+}
+
+func DecodeNxmReg10Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg10Masked, error) {
+	_nxmreg10masked := &NxmReg10Masked{Oxm: parent}
+	if decoder.Length() < 8 {
+		return nil, fmt.Errorf("NxmReg10Masked packet too short: %d < 8", decoder.Length())
+	}
+	_nxmreg10masked.Value = uint32(decoder.ReadUint32())
+	_nxmreg10masked.ValueMask = uint32(decoder.ReadUint32())
+	return _nxmreg10masked, nil
+}
+
+func NewNxmReg10Masked() *NxmReg10Masked {
+	obj := &NxmReg10Masked{
+		Oxm: NewOxm(70920),
+	}
+	return obj
+}
+func (self *NxmReg10Masked) GetOXMName() string {
+	return "reg10_masked"
+}
+
+func (self *NxmReg10Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmReg10Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmReg10Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmReg11 struct {
+	*Oxm
+	Value uint32
+}
+
+type INxmReg11 interface {
+	goloxi.IOxm
+	GetValue() uint32
+}
+
+func (self *NxmReg11) GetValue() uint32 {
+	return self.Value
+}
+
+func (self *NxmReg11) SetValue(v uint32) {
+	self.Value = v
+}
+
+func (self *NxmReg11) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Value))
+
+	return nil
+}
+
+func DecodeNxmReg11(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg11, error) {
+	_nxmreg11 := &NxmReg11{Oxm: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("NxmReg11 packet too short: %d < 4", decoder.Length())
+	}
+	_nxmreg11.Value = uint32(decoder.ReadUint32())
+	return _nxmreg11, nil
+}
+
+func NewNxmReg11() *NxmReg11 {
+	obj := &NxmReg11{
+		Oxm: NewOxm(71172),
+	}
+	return obj
+}
+func (self *NxmReg11) GetOXMName() string {
+	return "reg11"
+}
+
+func (self *NxmReg11) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmReg11) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmReg11Masked struct {
+	*Oxm
+	Value     uint32
+	ValueMask uint32
+}
+
+type INxmReg11Masked interface {
+	goloxi.IOxm
+	GetValue() uint32
+	GetValueMask() uint32
+}
+
+func (self *NxmReg11Masked) GetValue() uint32 {
+	return self.Value
+}
+
+func (self *NxmReg11Masked) SetValue(v uint32) {
+	self.Value = v
+}
+
+func (self *NxmReg11Masked) GetValueMask() uint32 {
+	return self.ValueMask
+}
+
+func (self *NxmReg11Masked) SetValueMask(v uint32) {
+	self.ValueMask = v
+}
+
+func (self *NxmReg11Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Value))
+	encoder.PutUint32(uint32(self.ValueMask))
+
+	return nil
+}
+
+func DecodeNxmReg11Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg11Masked, error) {
+	_nxmreg11masked := &NxmReg11Masked{Oxm: parent}
+	if decoder.Length() < 8 {
+		return nil, fmt.Errorf("NxmReg11Masked packet too short: %d < 8", decoder.Length())
+	}
+	_nxmreg11masked.Value = uint32(decoder.ReadUint32())
+	_nxmreg11masked.ValueMask = uint32(decoder.ReadUint32())
+	return _nxmreg11masked, nil
+}
+
+func NewNxmReg11Masked() *NxmReg11Masked {
+	obj := &NxmReg11Masked{
+		Oxm: NewOxm(71432),
+	}
+	return obj
+}
+func (self *NxmReg11Masked) GetOXMName() string {
+	return "reg11_masked"
+}
+
+func (self *NxmReg11Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmReg11Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmReg11Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmReg12 struct {
+	*Oxm
+	Value uint32
+}
+
+type INxmReg12 interface {
+	goloxi.IOxm
+	GetValue() uint32
+}
+
+func (self *NxmReg12) GetValue() uint32 {
+	return self.Value
+}
+
+func (self *NxmReg12) SetValue(v uint32) {
+	self.Value = v
+}
+
+func (self *NxmReg12) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Value))
+
+	return nil
+}
+
+func DecodeNxmReg12(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg12, error) {
+	_nxmreg12 := &NxmReg12{Oxm: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("NxmReg12 packet too short: %d < 4", decoder.Length())
+	}
+	_nxmreg12.Value = uint32(decoder.ReadUint32())
+	return _nxmreg12, nil
+}
+
+func NewNxmReg12() *NxmReg12 {
+	obj := &NxmReg12{
+		Oxm: NewOxm(71684),
+	}
+	return obj
+}
+func (self *NxmReg12) GetOXMName() string {
+	return "reg12"
+}
+
+func (self *NxmReg12) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmReg12) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmReg12Masked struct {
+	*Oxm
+	Value     uint32
+	ValueMask uint32
+}
+
+type INxmReg12Masked interface {
+	goloxi.IOxm
+	GetValue() uint32
+	GetValueMask() uint32
+}
+
+func (self *NxmReg12Masked) GetValue() uint32 {
+	return self.Value
+}
+
+func (self *NxmReg12Masked) SetValue(v uint32) {
+	self.Value = v
+}
+
+func (self *NxmReg12Masked) GetValueMask() uint32 {
+	return self.ValueMask
+}
+
+func (self *NxmReg12Masked) SetValueMask(v uint32) {
+	self.ValueMask = v
+}
+
+func (self *NxmReg12Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Value))
+	encoder.PutUint32(uint32(self.ValueMask))
+
+	return nil
+}
+
+func DecodeNxmReg12Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg12Masked, error) {
+	_nxmreg12masked := &NxmReg12Masked{Oxm: parent}
+	if decoder.Length() < 8 {
+		return nil, fmt.Errorf("NxmReg12Masked packet too short: %d < 8", decoder.Length())
+	}
+	_nxmreg12masked.Value = uint32(decoder.ReadUint32())
+	_nxmreg12masked.ValueMask = uint32(decoder.ReadUint32())
+	return _nxmreg12masked, nil
+}
+
+func NewNxmReg12Masked() *NxmReg12Masked {
+	obj := &NxmReg12Masked{
+		Oxm: NewOxm(71944),
+	}
+	return obj
+}
+func (self *NxmReg12Masked) GetOXMName() string {
+	return "reg12_masked"
+}
+
+func (self *NxmReg12Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmReg12Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmReg12Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmReg13 struct {
+	*Oxm
+	Value uint32
+}
+
+type INxmReg13 interface {
+	goloxi.IOxm
+	GetValue() uint32
+}
+
+func (self *NxmReg13) GetValue() uint32 {
+	return self.Value
+}
+
+func (self *NxmReg13) SetValue(v uint32) {
+	self.Value = v
+}
+
+func (self *NxmReg13) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Value))
+
+	return nil
+}
+
+func DecodeNxmReg13(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg13, error) {
+	_nxmreg13 := &NxmReg13{Oxm: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("NxmReg13 packet too short: %d < 4", decoder.Length())
+	}
+	_nxmreg13.Value = uint32(decoder.ReadUint32())
+	return _nxmreg13, nil
+}
+
+func NewNxmReg13() *NxmReg13 {
+	obj := &NxmReg13{
+		Oxm: NewOxm(72196),
+	}
+	return obj
+}
+func (self *NxmReg13) GetOXMName() string {
+	return "reg13"
+}
+
+func (self *NxmReg13) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmReg13) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmReg13Masked struct {
+	*Oxm
+	Value     uint32
+	ValueMask uint32
+}
+
+type INxmReg13Masked interface {
+	goloxi.IOxm
+	GetValue() uint32
+	GetValueMask() uint32
+}
+
+func (self *NxmReg13Masked) GetValue() uint32 {
+	return self.Value
+}
+
+func (self *NxmReg13Masked) SetValue(v uint32) {
+	self.Value = v
+}
+
+func (self *NxmReg13Masked) GetValueMask() uint32 {
+	return self.ValueMask
+}
+
+func (self *NxmReg13Masked) SetValueMask(v uint32) {
+	self.ValueMask = v
+}
+
+func (self *NxmReg13Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Value))
+	encoder.PutUint32(uint32(self.ValueMask))
+
+	return nil
+}
+
+func DecodeNxmReg13Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg13Masked, error) {
+	_nxmreg13masked := &NxmReg13Masked{Oxm: parent}
+	if decoder.Length() < 8 {
+		return nil, fmt.Errorf("NxmReg13Masked packet too short: %d < 8", decoder.Length())
+	}
+	_nxmreg13masked.Value = uint32(decoder.ReadUint32())
+	_nxmreg13masked.ValueMask = uint32(decoder.ReadUint32())
+	return _nxmreg13masked, nil
+}
+
+func NewNxmReg13Masked() *NxmReg13Masked {
+	obj := &NxmReg13Masked{
+		Oxm: NewOxm(72456),
+	}
+	return obj
+}
+func (self *NxmReg13Masked) GetOXMName() string {
+	return "reg13_masked"
+}
+
+func (self *NxmReg13Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmReg13Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmReg13Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmReg14 struct {
+	*Oxm
+	Value uint32
+}
+
+type INxmReg14 interface {
+	goloxi.IOxm
+	GetValue() uint32
+}
+
+func (self *NxmReg14) GetValue() uint32 {
+	return self.Value
+}
+
+func (self *NxmReg14) SetValue(v uint32) {
+	self.Value = v
+}
+
+func (self *NxmReg14) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Value))
+
+	return nil
+}
+
+func DecodeNxmReg14(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg14, error) {
+	_nxmreg14 := &NxmReg14{Oxm: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("NxmReg14 packet too short: %d < 4", decoder.Length())
+	}
+	_nxmreg14.Value = uint32(decoder.ReadUint32())
+	return _nxmreg14, nil
+}
+
+func NewNxmReg14() *NxmReg14 {
+	obj := &NxmReg14{
+		Oxm: NewOxm(72708),
+	}
+	return obj
+}
+func (self *NxmReg14) GetOXMName() string {
+	return "reg14"
+}
+
+func (self *NxmReg14) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmReg14) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmReg14Masked struct {
+	*Oxm
+	Value     uint32
+	ValueMask uint32
+}
+
+type INxmReg14Masked interface {
+	goloxi.IOxm
+	GetValue() uint32
+	GetValueMask() uint32
+}
+
+func (self *NxmReg14Masked) GetValue() uint32 {
+	return self.Value
+}
+
+func (self *NxmReg14Masked) SetValue(v uint32) {
+	self.Value = v
+}
+
+func (self *NxmReg14Masked) GetValueMask() uint32 {
+	return self.ValueMask
+}
+
+func (self *NxmReg14Masked) SetValueMask(v uint32) {
+	self.ValueMask = v
+}
+
+func (self *NxmReg14Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Value))
+	encoder.PutUint32(uint32(self.ValueMask))
+
+	return nil
+}
+
+func DecodeNxmReg14Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg14Masked, error) {
+	_nxmreg14masked := &NxmReg14Masked{Oxm: parent}
+	if decoder.Length() < 8 {
+		return nil, fmt.Errorf("NxmReg14Masked packet too short: %d < 8", decoder.Length())
+	}
+	_nxmreg14masked.Value = uint32(decoder.ReadUint32())
+	_nxmreg14masked.ValueMask = uint32(decoder.ReadUint32())
+	return _nxmreg14masked, nil
+}
+
+func NewNxmReg14Masked() *NxmReg14Masked {
+	obj := &NxmReg14Masked{
+		Oxm: NewOxm(72968),
+	}
+	return obj
+}
+func (self *NxmReg14Masked) GetOXMName() string {
+	return "reg14_masked"
+}
+
+func (self *NxmReg14Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmReg14Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmReg14Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmReg15 struct {
+	*Oxm
+	Value uint32
+}
+
+type INxmReg15 interface {
+	goloxi.IOxm
+	GetValue() uint32
+}
+
+func (self *NxmReg15) GetValue() uint32 {
+	return self.Value
+}
+
+func (self *NxmReg15) SetValue(v uint32) {
+	self.Value = v
+}
+
+func (self *NxmReg15) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Value))
+
+	return nil
+}
+
+func DecodeNxmReg15(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg15, error) {
+	_nxmreg15 := &NxmReg15{Oxm: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("NxmReg15 packet too short: %d < 4", decoder.Length())
+	}
+	_nxmreg15.Value = uint32(decoder.ReadUint32())
+	return _nxmreg15, nil
+}
+
+func NewNxmReg15() *NxmReg15 {
+	obj := &NxmReg15{
+		Oxm: NewOxm(73220),
+	}
+	return obj
+}
+func (self *NxmReg15) GetOXMName() string {
+	return "reg15"
+}
+
+func (self *NxmReg15) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmReg15) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmReg15Masked struct {
+	*Oxm
+	Value     uint32
+	ValueMask uint32
+}
+
+type INxmReg15Masked interface {
+	goloxi.IOxm
+	GetValue() uint32
+	GetValueMask() uint32
+}
+
+func (self *NxmReg15Masked) GetValue() uint32 {
+	return self.Value
+}
+
+func (self *NxmReg15Masked) SetValue(v uint32) {
+	self.Value = v
+}
+
+func (self *NxmReg15Masked) GetValueMask() uint32 {
+	return self.ValueMask
+}
+
+func (self *NxmReg15Masked) SetValueMask(v uint32) {
+	self.ValueMask = v
+}
+
+func (self *NxmReg15Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Value))
+	encoder.PutUint32(uint32(self.ValueMask))
+
+	return nil
+}
+
+func DecodeNxmReg15Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg15Masked, error) {
+	_nxmreg15masked := &NxmReg15Masked{Oxm: parent}
+	if decoder.Length() < 8 {
+		return nil, fmt.Errorf("NxmReg15Masked packet too short: %d < 8", decoder.Length())
+	}
+	_nxmreg15masked.Value = uint32(decoder.ReadUint32())
+	_nxmreg15masked.ValueMask = uint32(decoder.ReadUint32())
+	return _nxmreg15masked, nil
+}
+
+func NewNxmReg15Masked() *NxmReg15Masked {
+	obj := &NxmReg15Masked{
+		Oxm: NewOxm(73480),
+	}
+	return obj
+}
+func (self *NxmReg15Masked) GetOXMName() string {
+	return "reg15_masked"
+}
+
+func (self *NxmReg15Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmReg15Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmReg15Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmReg1Masked struct {
+	*Oxm
+	Value     uint32
+	ValueMask uint32
+}
+
+type INxmReg1Masked interface {
+	goloxi.IOxm
+	GetValue() uint32
+	GetValueMask() uint32
+}
+
+func (self *NxmReg1Masked) GetValue() uint32 {
+	return self.Value
+}
+
+func (self *NxmReg1Masked) SetValue(v uint32) {
+	self.Value = v
+}
+
+func (self *NxmReg1Masked) GetValueMask() uint32 {
+	return self.ValueMask
+}
+
+func (self *NxmReg1Masked) SetValueMask(v uint32) {
+	self.ValueMask = v
+}
+
+func (self *NxmReg1Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Value))
+	encoder.PutUint32(uint32(self.ValueMask))
+
+	return nil
+}
+
+func DecodeNxmReg1Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg1Masked, error) {
+	_nxmreg1masked := &NxmReg1Masked{Oxm: parent}
+	if decoder.Length() < 8 {
+		return nil, fmt.Errorf("NxmReg1Masked packet too short: %d < 8", decoder.Length())
+	}
+	_nxmreg1masked.Value = uint32(decoder.ReadUint32())
+	_nxmreg1masked.ValueMask = uint32(decoder.ReadUint32())
+	return _nxmreg1masked, nil
+}
+
+func NewNxmReg1Masked() *NxmReg1Masked {
+	obj := &NxmReg1Masked{
+		Oxm: NewOxm(66312),
+	}
+	return obj
+}
+func (self *NxmReg1Masked) GetOXMName() string {
+	return "reg1_masked"
+}
+
+func (self *NxmReg1Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmReg1Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmReg1Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmReg2 struct {
+	*Oxm
+	Value uint32
+}
+
+type INxmReg2 interface {
+	goloxi.IOxm
+	GetValue() uint32
+}
+
+func (self *NxmReg2) GetValue() uint32 {
+	return self.Value
+}
+
+func (self *NxmReg2) SetValue(v uint32) {
+	self.Value = v
+}
+
+func (self *NxmReg2) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Value))
+
+	return nil
+}
+
+func DecodeNxmReg2(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg2, error) {
+	_nxmreg2 := &NxmReg2{Oxm: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("NxmReg2 packet too short: %d < 4", decoder.Length())
+	}
+	_nxmreg2.Value = uint32(decoder.ReadUint32())
+	return _nxmreg2, nil
+}
+
+func NewNxmReg2() *NxmReg2 {
+	obj := &NxmReg2{
+		Oxm: NewOxm(66564),
+	}
+	return obj
+}
+func (self *NxmReg2) GetOXMName() string {
+	return "reg2"
+}
+
+func (self *NxmReg2) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmReg2) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmReg2Masked struct {
+	*Oxm
+	Value     uint32
+	ValueMask uint32
+}
+
+type INxmReg2Masked interface {
+	goloxi.IOxm
+	GetValue() uint32
+	GetValueMask() uint32
+}
+
+func (self *NxmReg2Masked) GetValue() uint32 {
+	return self.Value
+}
+
+func (self *NxmReg2Masked) SetValue(v uint32) {
+	self.Value = v
+}
+
+func (self *NxmReg2Masked) GetValueMask() uint32 {
+	return self.ValueMask
+}
+
+func (self *NxmReg2Masked) SetValueMask(v uint32) {
+	self.ValueMask = v
+}
+
+func (self *NxmReg2Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Value))
+	encoder.PutUint32(uint32(self.ValueMask))
+
+	return nil
+}
+
+func DecodeNxmReg2Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg2Masked, error) {
+	_nxmreg2masked := &NxmReg2Masked{Oxm: parent}
+	if decoder.Length() < 8 {
+		return nil, fmt.Errorf("NxmReg2Masked packet too short: %d < 8", decoder.Length())
+	}
+	_nxmreg2masked.Value = uint32(decoder.ReadUint32())
+	_nxmreg2masked.ValueMask = uint32(decoder.ReadUint32())
+	return _nxmreg2masked, nil
+}
+
+func NewNxmReg2Masked() *NxmReg2Masked {
+	obj := &NxmReg2Masked{
+		Oxm: NewOxm(66824),
+	}
+	return obj
+}
+func (self *NxmReg2Masked) GetOXMName() string {
+	return "reg2_masked"
+}
+
+func (self *NxmReg2Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmReg2Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmReg2Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmReg3 struct {
+	*Oxm
+	Value uint32
+}
+
+type INxmReg3 interface {
+	goloxi.IOxm
+	GetValue() uint32
+}
+
+func (self *NxmReg3) GetValue() uint32 {
+	return self.Value
+}
+
+func (self *NxmReg3) SetValue(v uint32) {
+	self.Value = v
+}
+
+func (self *NxmReg3) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Value))
+
+	return nil
+}
+
+func DecodeNxmReg3(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg3, error) {
+	_nxmreg3 := &NxmReg3{Oxm: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("NxmReg3 packet too short: %d < 4", decoder.Length())
+	}
+	_nxmreg3.Value = uint32(decoder.ReadUint32())
+	return _nxmreg3, nil
+}
+
+func NewNxmReg3() *NxmReg3 {
+	obj := &NxmReg3{
+		Oxm: NewOxm(67076),
+	}
+	return obj
+}
+func (self *NxmReg3) GetOXMName() string {
+	return "reg3"
+}
+
+func (self *NxmReg3) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmReg3) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmReg3Masked struct {
+	*Oxm
+	Value     uint32
+	ValueMask uint32
+}
+
+type INxmReg3Masked interface {
+	goloxi.IOxm
+	GetValue() uint32
+	GetValueMask() uint32
+}
+
+func (self *NxmReg3Masked) GetValue() uint32 {
+	return self.Value
+}
+
+func (self *NxmReg3Masked) SetValue(v uint32) {
+	self.Value = v
+}
+
+func (self *NxmReg3Masked) GetValueMask() uint32 {
+	return self.ValueMask
+}
+
+func (self *NxmReg3Masked) SetValueMask(v uint32) {
+	self.ValueMask = v
+}
+
+func (self *NxmReg3Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Value))
+	encoder.PutUint32(uint32(self.ValueMask))
+
+	return nil
+}
+
+func DecodeNxmReg3Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg3Masked, error) {
+	_nxmreg3masked := &NxmReg3Masked{Oxm: parent}
+	if decoder.Length() < 8 {
+		return nil, fmt.Errorf("NxmReg3Masked packet too short: %d < 8", decoder.Length())
+	}
+	_nxmreg3masked.Value = uint32(decoder.ReadUint32())
+	_nxmreg3masked.ValueMask = uint32(decoder.ReadUint32())
+	return _nxmreg3masked, nil
+}
+
+func NewNxmReg3Masked() *NxmReg3Masked {
+	obj := &NxmReg3Masked{
+		Oxm: NewOxm(67336),
+	}
+	return obj
+}
+func (self *NxmReg3Masked) GetOXMName() string {
+	return "reg3_masked"
+}
+
+func (self *NxmReg3Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmReg3Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmReg3Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmReg4 struct {
+	*Oxm
+	Value uint32
+}
+
+type INxmReg4 interface {
+	goloxi.IOxm
+	GetValue() uint32
+}
+
+func (self *NxmReg4) GetValue() uint32 {
+	return self.Value
+}
+
+func (self *NxmReg4) SetValue(v uint32) {
+	self.Value = v
+}
+
+func (self *NxmReg4) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Value))
+
+	return nil
+}
+
+func DecodeNxmReg4(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg4, error) {
+	_nxmreg4 := &NxmReg4{Oxm: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("NxmReg4 packet too short: %d < 4", decoder.Length())
+	}
+	_nxmreg4.Value = uint32(decoder.ReadUint32())
+	return _nxmreg4, nil
+}
+
+func NewNxmReg4() *NxmReg4 {
+	obj := &NxmReg4{
+		Oxm: NewOxm(67588),
+	}
+	return obj
+}
+func (self *NxmReg4) GetOXMName() string {
+	return "reg4"
+}
+
+func (self *NxmReg4) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmReg4) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmReg4Masked struct {
+	*Oxm
+	Value     uint32
+	ValueMask uint32
+}
+
+type INxmReg4Masked interface {
+	goloxi.IOxm
+	GetValue() uint32
+	GetValueMask() uint32
+}
+
+func (self *NxmReg4Masked) GetValue() uint32 {
+	return self.Value
+}
+
+func (self *NxmReg4Masked) SetValue(v uint32) {
+	self.Value = v
+}
+
+func (self *NxmReg4Masked) GetValueMask() uint32 {
+	return self.ValueMask
+}
+
+func (self *NxmReg4Masked) SetValueMask(v uint32) {
+	self.ValueMask = v
+}
+
+func (self *NxmReg4Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Value))
+	encoder.PutUint32(uint32(self.ValueMask))
+
+	return nil
+}
+
+func DecodeNxmReg4Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg4Masked, error) {
+	_nxmreg4masked := &NxmReg4Masked{Oxm: parent}
+	if decoder.Length() < 8 {
+		return nil, fmt.Errorf("NxmReg4Masked packet too short: %d < 8", decoder.Length())
+	}
+	_nxmreg4masked.Value = uint32(decoder.ReadUint32())
+	_nxmreg4masked.ValueMask = uint32(decoder.ReadUint32())
+	return _nxmreg4masked, nil
+}
+
+func NewNxmReg4Masked() *NxmReg4Masked {
+	obj := &NxmReg4Masked{
+		Oxm: NewOxm(67848),
+	}
+	return obj
+}
+func (self *NxmReg4Masked) GetOXMName() string {
+	return "reg4_masked"
+}
+
+func (self *NxmReg4Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmReg4Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmReg4Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmReg5 struct {
+	*Oxm
+	Value uint32
+}
+
+type INxmReg5 interface {
+	goloxi.IOxm
+	GetValue() uint32
+}
+
+func (self *NxmReg5) GetValue() uint32 {
+	return self.Value
+}
+
+func (self *NxmReg5) SetValue(v uint32) {
+	self.Value = v
+}
+
+func (self *NxmReg5) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Value))
+
+	return nil
+}
+
+func DecodeNxmReg5(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg5, error) {
+	_nxmreg5 := &NxmReg5{Oxm: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("NxmReg5 packet too short: %d < 4", decoder.Length())
+	}
+	_nxmreg5.Value = uint32(decoder.ReadUint32())
+	return _nxmreg5, nil
+}
+
+func NewNxmReg5() *NxmReg5 {
+	obj := &NxmReg5{
+		Oxm: NewOxm(68100),
+	}
+	return obj
+}
+func (self *NxmReg5) GetOXMName() string {
+	return "reg5"
+}
+
+func (self *NxmReg5) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmReg5) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmReg5Masked struct {
+	*Oxm
+	Value     uint32
+	ValueMask uint32
+}
+
+type INxmReg5Masked interface {
+	goloxi.IOxm
+	GetValue() uint32
+	GetValueMask() uint32
+}
+
+func (self *NxmReg5Masked) GetValue() uint32 {
+	return self.Value
+}
+
+func (self *NxmReg5Masked) SetValue(v uint32) {
+	self.Value = v
+}
+
+func (self *NxmReg5Masked) GetValueMask() uint32 {
+	return self.ValueMask
+}
+
+func (self *NxmReg5Masked) SetValueMask(v uint32) {
+	self.ValueMask = v
+}
+
+func (self *NxmReg5Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Value))
+	encoder.PutUint32(uint32(self.ValueMask))
+
+	return nil
+}
+
+func DecodeNxmReg5Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg5Masked, error) {
+	_nxmreg5masked := &NxmReg5Masked{Oxm: parent}
+	if decoder.Length() < 8 {
+		return nil, fmt.Errorf("NxmReg5Masked packet too short: %d < 8", decoder.Length())
+	}
+	_nxmreg5masked.Value = uint32(decoder.ReadUint32())
+	_nxmreg5masked.ValueMask = uint32(decoder.ReadUint32())
+	return _nxmreg5masked, nil
+}
+
+func NewNxmReg5Masked() *NxmReg5Masked {
+	obj := &NxmReg5Masked{
+		Oxm: NewOxm(68360),
+	}
+	return obj
+}
+func (self *NxmReg5Masked) GetOXMName() string {
+	return "reg5_masked"
+}
+
+func (self *NxmReg5Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmReg5Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmReg5Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmReg6 struct {
+	*Oxm
+	Value uint32
+}
+
+type INxmReg6 interface {
+	goloxi.IOxm
+	GetValue() uint32
+}
+
+func (self *NxmReg6) GetValue() uint32 {
+	return self.Value
+}
+
+func (self *NxmReg6) SetValue(v uint32) {
+	self.Value = v
+}
+
+func (self *NxmReg6) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Value))
+
+	return nil
+}
+
+func DecodeNxmReg6(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg6, error) {
+	_nxmreg6 := &NxmReg6{Oxm: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("NxmReg6 packet too short: %d < 4", decoder.Length())
+	}
+	_nxmreg6.Value = uint32(decoder.ReadUint32())
+	return _nxmreg6, nil
+}
+
+func NewNxmReg6() *NxmReg6 {
+	obj := &NxmReg6{
+		Oxm: NewOxm(68612),
+	}
+	return obj
+}
+func (self *NxmReg6) GetOXMName() string {
+	return "reg6"
+}
+
+func (self *NxmReg6) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmReg6) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmReg6Masked struct {
+	*Oxm
+	Value     uint32
+	ValueMask uint32
+}
+
+type INxmReg6Masked interface {
+	goloxi.IOxm
+	GetValue() uint32
+	GetValueMask() uint32
+}
+
+func (self *NxmReg6Masked) GetValue() uint32 {
+	return self.Value
+}
+
+func (self *NxmReg6Masked) SetValue(v uint32) {
+	self.Value = v
+}
+
+func (self *NxmReg6Masked) GetValueMask() uint32 {
+	return self.ValueMask
+}
+
+func (self *NxmReg6Masked) SetValueMask(v uint32) {
+	self.ValueMask = v
+}
+
+func (self *NxmReg6Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Value))
+	encoder.PutUint32(uint32(self.ValueMask))
+
+	return nil
+}
+
+func DecodeNxmReg6Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg6Masked, error) {
+	_nxmreg6masked := &NxmReg6Masked{Oxm: parent}
+	if decoder.Length() < 8 {
+		return nil, fmt.Errorf("NxmReg6Masked packet too short: %d < 8", decoder.Length())
+	}
+	_nxmreg6masked.Value = uint32(decoder.ReadUint32())
+	_nxmreg6masked.ValueMask = uint32(decoder.ReadUint32())
+	return _nxmreg6masked, nil
+}
+
+func NewNxmReg6Masked() *NxmReg6Masked {
+	obj := &NxmReg6Masked{
+		Oxm: NewOxm(68872),
+	}
+	return obj
+}
+func (self *NxmReg6Masked) GetOXMName() string {
+	return "reg6_masked"
+}
+
+func (self *NxmReg6Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmReg6Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmReg6Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmReg7 struct {
+	*Oxm
+	Value uint32
+}
+
+type INxmReg7 interface {
+	goloxi.IOxm
+	GetValue() uint32
+}
+
+func (self *NxmReg7) GetValue() uint32 {
+	return self.Value
+}
+
+func (self *NxmReg7) SetValue(v uint32) {
+	self.Value = v
+}
+
+func (self *NxmReg7) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Value))
+
+	return nil
+}
+
+func DecodeNxmReg7(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg7, error) {
+	_nxmreg7 := &NxmReg7{Oxm: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("NxmReg7 packet too short: %d < 4", decoder.Length())
+	}
+	_nxmreg7.Value = uint32(decoder.ReadUint32())
+	return _nxmreg7, nil
+}
+
+func NewNxmReg7() *NxmReg7 {
+	obj := &NxmReg7{
+		Oxm: NewOxm(69124),
+	}
+	return obj
+}
+func (self *NxmReg7) GetOXMName() string {
+	return "reg7"
+}
+
+func (self *NxmReg7) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmReg7) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmReg7Masked struct {
+	*Oxm
+	Value     uint32
+	ValueMask uint32
+}
+
+type INxmReg7Masked interface {
+	goloxi.IOxm
+	GetValue() uint32
+	GetValueMask() uint32
+}
+
+func (self *NxmReg7Masked) GetValue() uint32 {
+	return self.Value
+}
+
+func (self *NxmReg7Masked) SetValue(v uint32) {
+	self.Value = v
+}
+
+func (self *NxmReg7Masked) GetValueMask() uint32 {
+	return self.ValueMask
+}
+
+func (self *NxmReg7Masked) SetValueMask(v uint32) {
+	self.ValueMask = v
+}
+
+func (self *NxmReg7Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Value))
+	encoder.PutUint32(uint32(self.ValueMask))
+
+	return nil
+}
+
+func DecodeNxmReg7Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg7Masked, error) {
+	_nxmreg7masked := &NxmReg7Masked{Oxm: parent}
+	if decoder.Length() < 8 {
+		return nil, fmt.Errorf("NxmReg7Masked packet too short: %d < 8", decoder.Length())
+	}
+	_nxmreg7masked.Value = uint32(decoder.ReadUint32())
+	_nxmreg7masked.ValueMask = uint32(decoder.ReadUint32())
+	return _nxmreg7masked, nil
+}
+
+func NewNxmReg7Masked() *NxmReg7Masked {
+	obj := &NxmReg7Masked{
+		Oxm: NewOxm(69384),
+	}
+	return obj
+}
+func (self *NxmReg7Masked) GetOXMName() string {
+	return "reg7_masked"
+}
+
+func (self *NxmReg7Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmReg7Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmReg7Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmReg8 struct {
+	*Oxm
+	Value uint32
+}
+
+type INxmReg8 interface {
+	goloxi.IOxm
+	GetValue() uint32
+}
+
+func (self *NxmReg8) GetValue() uint32 {
+	return self.Value
+}
+
+func (self *NxmReg8) SetValue(v uint32) {
+	self.Value = v
+}
+
+func (self *NxmReg8) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Value))
+
+	return nil
+}
+
+func DecodeNxmReg8(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg8, error) {
+	_nxmreg8 := &NxmReg8{Oxm: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("NxmReg8 packet too short: %d < 4", decoder.Length())
+	}
+	_nxmreg8.Value = uint32(decoder.ReadUint32())
+	return _nxmreg8, nil
+}
+
+func NewNxmReg8() *NxmReg8 {
+	obj := &NxmReg8{
+		Oxm: NewOxm(69636),
+	}
+	return obj
+}
+func (self *NxmReg8) GetOXMName() string {
+	return "reg8"
+}
+
+func (self *NxmReg8) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmReg8) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmReg8Masked struct {
+	*Oxm
+	Value     uint32
+	ValueMask uint32
+}
+
+type INxmReg8Masked interface {
+	goloxi.IOxm
+	GetValue() uint32
+	GetValueMask() uint32
+}
+
+func (self *NxmReg8Masked) GetValue() uint32 {
+	return self.Value
+}
+
+func (self *NxmReg8Masked) SetValue(v uint32) {
+	self.Value = v
+}
+
+func (self *NxmReg8Masked) GetValueMask() uint32 {
+	return self.ValueMask
+}
+
+func (self *NxmReg8Masked) SetValueMask(v uint32) {
+	self.ValueMask = v
+}
+
+func (self *NxmReg8Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Value))
+	encoder.PutUint32(uint32(self.ValueMask))
+
+	return nil
+}
+
+func DecodeNxmReg8Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg8Masked, error) {
+	_nxmreg8masked := &NxmReg8Masked{Oxm: parent}
+	if decoder.Length() < 8 {
+		return nil, fmt.Errorf("NxmReg8Masked packet too short: %d < 8", decoder.Length())
+	}
+	_nxmreg8masked.Value = uint32(decoder.ReadUint32())
+	_nxmreg8masked.ValueMask = uint32(decoder.ReadUint32())
+	return _nxmreg8masked, nil
+}
+
+func NewNxmReg8Masked() *NxmReg8Masked {
+	obj := &NxmReg8Masked{
+		Oxm: NewOxm(69896),
+	}
+	return obj
+}
+func (self *NxmReg8Masked) GetOXMName() string {
+	return "reg8_masked"
+}
+
+func (self *NxmReg8Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmReg8Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmReg8Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmReg9 struct {
+	*Oxm
+	Value uint32
+}
+
+type INxmReg9 interface {
+	goloxi.IOxm
+	GetValue() uint32
+}
+
+func (self *NxmReg9) GetValue() uint32 {
+	return self.Value
+}
+
+func (self *NxmReg9) SetValue(v uint32) {
+	self.Value = v
+}
+
+func (self *NxmReg9) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Value))
+
+	return nil
+}
+
+func DecodeNxmReg9(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg9, error) {
+	_nxmreg9 := &NxmReg9{Oxm: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("NxmReg9 packet too short: %d < 4", decoder.Length())
+	}
+	_nxmreg9.Value = uint32(decoder.ReadUint32())
+	return _nxmreg9, nil
+}
+
+func NewNxmReg9() *NxmReg9 {
+	obj := &NxmReg9{
+		Oxm: NewOxm(70148),
+	}
+	return obj
+}
+func (self *NxmReg9) GetOXMName() string {
+	return "reg9"
+}
+
+func (self *NxmReg9) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmReg9) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmReg9Masked struct {
+	*Oxm
+	Value     uint32
+	ValueMask uint32
+}
+
+type INxmReg9Masked interface {
+	goloxi.IOxm
+	GetValue() uint32
+	GetValueMask() uint32
+}
+
+func (self *NxmReg9Masked) GetValue() uint32 {
+	return self.Value
+}
+
+func (self *NxmReg9Masked) SetValue(v uint32) {
+	self.Value = v
+}
+
+func (self *NxmReg9Masked) GetValueMask() uint32 {
+	return self.ValueMask
+}
+
+func (self *NxmReg9Masked) SetValueMask(v uint32) {
+	self.ValueMask = v
+}
+
+func (self *NxmReg9Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Value))
+	encoder.PutUint32(uint32(self.ValueMask))
+
+	return nil
+}
+
+func DecodeNxmReg9Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg9Masked, error) {
+	_nxmreg9masked := &NxmReg9Masked{Oxm: parent}
+	if decoder.Length() < 8 {
+		return nil, fmt.Errorf("NxmReg9Masked packet too short: %d < 8", decoder.Length())
+	}
+	_nxmreg9masked.Value = uint32(decoder.ReadUint32())
+	_nxmreg9masked.ValueMask = uint32(decoder.ReadUint32())
+	return _nxmreg9masked, nil
+}
+
+func NewNxmReg9Masked() *NxmReg9Masked {
+	obj := &NxmReg9Masked{
+		Oxm: NewOxm(70408),
+	}
+	return obj
+}
+func (self *NxmReg9Masked) GetOXMName() string {
+	return "reg9_masked"
+}
+
+func (self *NxmReg9Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmReg9Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmReg9Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTcpDst struct {
+	*Oxm
+	Value uint16
+}
+
+type INxmTcpDst interface {
+	goloxi.IOxm
+	GetValue() uint16
+}
+
+func (self *NxmTcpDst) GetValue() uint16 {
+	return self.Value
+}
+
+func (self *NxmTcpDst) SetValue(v uint16) {
+	self.Value = v
+}
+
+func (self *NxmTcpDst) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Value))
+
+	return nil
+}
+
+func DecodeNxmTcpDst(parent *Oxm, decoder *goloxi.Decoder) (*NxmTcpDst, error) {
+	_nxmtcpdst := &NxmTcpDst{Oxm: parent}
+	if decoder.Length() < 2 {
+		return nil, fmt.Errorf("NxmTcpDst packet too short: %d < 2", decoder.Length())
+	}
+	_nxmtcpdst.Value = uint16(decoder.ReadUint16())
+	return _nxmtcpdst, nil
+}
+
+func NewNxmTcpDst() *NxmTcpDst {
+	obj := &NxmTcpDst{
+		Oxm: NewOxm(5122),
+	}
+	return obj
+}
+func (self *NxmTcpDst) GetOXMName() string {
+	return "tcp_dst"
+}
+
+func (self *NxmTcpDst) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTcpDst) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTcpDstMasked struct {
+	*Oxm
+	Value     uint16
+	ValueMask uint16
+}
+
+type INxmTcpDstMasked interface {
+	goloxi.IOxm
+	GetValue() uint16
+	GetValueMask() uint16
+}
+
+func (self *NxmTcpDstMasked) GetValue() uint16 {
+	return self.Value
+}
+
+func (self *NxmTcpDstMasked) SetValue(v uint16) {
+	self.Value = v
+}
+
+func (self *NxmTcpDstMasked) GetValueMask() uint16 {
+	return self.ValueMask
+}
+
+func (self *NxmTcpDstMasked) SetValueMask(v uint16) {
+	self.ValueMask = v
+}
+
+func (self *NxmTcpDstMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Value))
+	encoder.PutUint16(uint16(self.ValueMask))
+
+	return nil
+}
+
+func DecodeNxmTcpDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTcpDstMasked, error) {
+	_nxmtcpdstmasked := &NxmTcpDstMasked{Oxm: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("NxmTcpDstMasked packet too short: %d < 4", decoder.Length())
+	}
+	_nxmtcpdstmasked.Value = uint16(decoder.ReadUint16())
+	_nxmtcpdstmasked.ValueMask = uint16(decoder.ReadUint16())
+	return _nxmtcpdstmasked, nil
+}
+
+func NewNxmTcpDstMasked() *NxmTcpDstMasked {
+	obj := &NxmTcpDstMasked{
+		Oxm: NewOxm(5378),
+	}
+	return obj
+}
+func (self *NxmTcpDstMasked) GetOXMName() string {
+	return "tcp_dst_masked"
+}
+
+func (self *NxmTcpDstMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTcpDstMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmTcpDstMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTcpFlags struct {
+	*Oxm
+	Value TcpFlags
+}
+
+type INxmTcpFlags interface {
+	goloxi.IOxm
+	GetValue() TcpFlags
+}
+
+func (self *NxmTcpFlags) GetValue() TcpFlags {
+	return self.Value
+}
+
+func (self *NxmTcpFlags) SetValue(v TcpFlags) {
+	self.Value = v
+}
+
+func (self *NxmTcpFlags) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Value))
+
+	return nil
+}
+
+func DecodeNxmTcpFlags(parent *Oxm, decoder *goloxi.Decoder) (*NxmTcpFlags, error) {
+	_nxmtcpflags := &NxmTcpFlags{Oxm: parent}
+	if decoder.Length() < 2 {
+		return nil, fmt.Errorf("NxmTcpFlags packet too short: %d < 2", decoder.Length())
+	}
+	_nxmtcpflags.Value = TcpFlags(decoder.ReadUint16())
+	return _nxmtcpflags, nil
+}
+
+func NewNxmTcpFlags() *NxmTcpFlags {
+	obj := &NxmTcpFlags{
+		Oxm: NewOxm(82946),
+	}
+	return obj
+}
+func (self *NxmTcpFlags) GetOXMName() string {
+	return "tcp_flags"
+}
+
+func (self *NxmTcpFlags) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTcpFlags) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTcpFlagsMasked struct {
+	*Oxm
+	Value     TcpFlags
+	ValueMask uint16
+}
+
+type INxmTcpFlagsMasked interface {
+	goloxi.IOxm
+	GetValue() TcpFlags
+	GetValueMask() uint16
+}
+
+func (self *NxmTcpFlagsMasked) GetValue() TcpFlags {
+	return self.Value
+}
+
+func (self *NxmTcpFlagsMasked) SetValue(v TcpFlags) {
+	self.Value = v
+}
+
+func (self *NxmTcpFlagsMasked) GetValueMask() uint16 {
+	return self.ValueMask
+}
+
+func (self *NxmTcpFlagsMasked) SetValueMask(v uint16) {
+	self.ValueMask = v
+}
+
+func (self *NxmTcpFlagsMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Value))
+	encoder.PutUint16(uint16(self.ValueMask))
+
+	return nil
+}
+
+func DecodeNxmTcpFlagsMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTcpFlagsMasked, error) {
+	_nxmtcpflagsmasked := &NxmTcpFlagsMasked{Oxm: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("NxmTcpFlagsMasked packet too short: %d < 4", decoder.Length())
+	}
+	_nxmtcpflagsmasked.Value = TcpFlags(decoder.ReadUint16())
+	_nxmtcpflagsmasked.ValueMask = uint16(decoder.ReadUint16())
+	return _nxmtcpflagsmasked, nil
+}
+
+func NewNxmTcpFlagsMasked() *NxmTcpFlagsMasked {
+	obj := &NxmTcpFlagsMasked{
+		Oxm: NewOxm(83204),
+	}
+	return obj
+}
+func (self *NxmTcpFlagsMasked) GetOXMName() string {
+	return "tcp_flags_masked"
+}
+
+func (self *NxmTcpFlagsMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTcpFlagsMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmTcpFlagsMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTcpSrc struct {
+	*Oxm
+	Value uint16
+}
+
+type INxmTcpSrc interface {
+	goloxi.IOxm
+	GetValue() uint16
+}
+
+func (self *NxmTcpSrc) GetValue() uint16 {
+	return self.Value
+}
+
+func (self *NxmTcpSrc) SetValue(v uint16) {
+	self.Value = v
+}
+
+func (self *NxmTcpSrc) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Value))
+
+	return nil
+}
+
+func DecodeNxmTcpSrc(parent *Oxm, decoder *goloxi.Decoder) (*NxmTcpSrc, error) {
+	_nxmtcpsrc := &NxmTcpSrc{Oxm: parent}
+	if decoder.Length() < 2 {
+		return nil, fmt.Errorf("NxmTcpSrc packet too short: %d < 2", decoder.Length())
+	}
+	_nxmtcpsrc.Value = uint16(decoder.ReadUint16())
+	return _nxmtcpsrc, nil
+}
+
+func NewNxmTcpSrc() *NxmTcpSrc {
+	obj := &NxmTcpSrc{
+		Oxm: NewOxm(4610),
+	}
+	return obj
+}
+func (self *NxmTcpSrc) GetOXMName() string {
+	return "tcp_src"
+}
+
+func (self *NxmTcpSrc) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTcpSrc) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTcpSrcMasked struct {
+	*Oxm
+	Value     uint16
+	ValueMask uint16
+}
+
+type INxmTcpSrcMasked interface {
+	goloxi.IOxm
+	GetValue() uint16
+	GetValueMask() uint16
+}
+
+func (self *NxmTcpSrcMasked) GetValue() uint16 {
+	return self.Value
+}
+
+func (self *NxmTcpSrcMasked) SetValue(v uint16) {
+	self.Value = v
+}
+
+func (self *NxmTcpSrcMasked) GetValueMask() uint16 {
+	return self.ValueMask
+}
+
+func (self *NxmTcpSrcMasked) SetValueMask(v uint16) {
+	self.ValueMask = v
+}
+
+func (self *NxmTcpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Value))
+	encoder.PutUint16(uint16(self.ValueMask))
+
+	return nil
+}
+
+func DecodeNxmTcpSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTcpSrcMasked, error) {
+	_nxmtcpsrcmasked := &NxmTcpSrcMasked{Oxm: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("NxmTcpSrcMasked packet too short: %d < 4", decoder.Length())
+	}
+	_nxmtcpsrcmasked.Value = uint16(decoder.ReadUint16())
+	_nxmtcpsrcmasked.ValueMask = uint16(decoder.ReadUint16())
+	return _nxmtcpsrcmasked, nil
+}
+
+func NewNxmTcpSrcMasked() *NxmTcpSrcMasked {
+	obj := &NxmTcpSrcMasked{
+		Oxm: NewOxm(4868),
+	}
+	return obj
+}
+func (self *NxmTcpSrcMasked) GetOXMName() string {
+	return "tcp_src_masked"
+}
+
+func (self *NxmTcpSrcMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTcpSrcMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmTcpSrcMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunDst struct {
+	*Oxm
+	Value net.IP
+}
+
+type INxmTunDst interface {
+	goloxi.IOxm
+	GetValue() net.IP
+}
+
+func (self *NxmTunDst) GetValue() net.IP {
+	return self.Value
+}
+
+func (self *NxmTunDst) SetValue(v net.IP) {
+	self.Value = v
+}
+
+func (self *NxmTunDst) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value.To4())
+
+	return nil
+}
+
+func DecodeNxmTunDst(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunDst, error) {
+	_nxmtundst := &NxmTunDst{Oxm: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("NxmTunDst packet too short: %d < 4", decoder.Length())
+	}
+	_nxmtundst.Value = net.IP(decoder.Read(4))
+	return _nxmtundst, nil
+}
+
+func NewNxmTunDst() *NxmTunDst {
+	obj := &NxmTunDst{
+		Oxm: NewOxm(81924),
+	}
+	return obj
+}
+func (self *NxmTunDst) GetOXMName() string {
+	return "tun_dst"
+}
+
+func (self *NxmTunDst) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunDst) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunDstMasked struct {
+	*Oxm
+	Value     net.IP
+	ValueMask net.IP
+}
+
+type INxmTunDstMasked interface {
+	goloxi.IOxm
+	GetValue() net.IP
+	GetValueMask() net.IP
+}
+
+func (self *NxmTunDstMasked) GetValue() net.IP {
+	return self.Value
+}
+
+func (self *NxmTunDstMasked) SetValue(v net.IP) {
+	self.Value = v
+}
+
+func (self *NxmTunDstMasked) GetValueMask() net.IP {
+	return self.ValueMask
+}
+
+func (self *NxmTunDstMasked) SetValueMask(v net.IP) {
+	self.ValueMask = v
+}
+
+func (self *NxmTunDstMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value.To4())
+	encoder.Write(self.ValueMask.To4())
+
+	return nil
+}
+
+func DecodeNxmTunDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunDstMasked, error) {
+	_nxmtundstmasked := &NxmTunDstMasked{Oxm: parent}
+	if decoder.Length() < 8 {
+		return nil, fmt.Errorf("NxmTunDstMasked packet too short: %d < 8", decoder.Length())
+	}
+	_nxmtundstmasked.Value = net.IP(decoder.Read(4))
+	_nxmtundstmasked.ValueMask = net.IP(decoder.Read(4))
+	return _nxmtundstmasked, nil
+}
+
+func NewNxmTunDstMasked() *NxmTunDstMasked {
+	obj := &NxmTunDstMasked{
+		Oxm: NewOxm(82184),
+	}
+	return obj
+}
+func (self *NxmTunDstMasked) GetOXMName() string {
+	return "tun_dst_masked"
+}
+
+func (self *NxmTunDstMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunDstMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmTunDstMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunFlags struct {
+	*Oxm
+	Value uint16
+}
+
+type INxmTunFlags interface {
+	goloxi.IOxm
+	GetValue() uint16
+}
+
+func (self *NxmTunFlags) GetValue() uint16 {
+	return self.Value
+}
+
+func (self *NxmTunFlags) SetValue(v uint16) {
+	self.Value = v
+}
+
+func (self *NxmTunFlags) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Value))
+
+	return nil
+}
+
+func DecodeNxmTunFlags(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunFlags, error) {
+	_nxmtunflags := &NxmTunFlags{Oxm: parent}
+	if decoder.Length() < 2 {
+		return nil, fmt.Errorf("NxmTunFlags packet too short: %d < 2", decoder.Length())
+	}
+	_nxmtunflags.Value = uint16(decoder.ReadUint16())
+	return _nxmtunflags, nil
+}
+
+func NewNxmTunFlags() *NxmTunFlags {
+	obj := &NxmTunFlags{
+		Oxm: NewOxm(118786),
+	}
+	return obj
+}
+func (self *NxmTunFlags) GetOXMName() string {
+	return "tun_flags"
+}
+
+func (self *NxmTunFlags) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunFlags) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunFlagsMasked struct {
+	*Oxm
+	Value     uint16
+	ValueMask uint16
+}
+
+type INxmTunFlagsMasked interface {
+	goloxi.IOxm
+	GetValue() uint16
+	GetValueMask() uint16
+}
+
+func (self *NxmTunFlagsMasked) GetValue() uint16 {
+	return self.Value
+}
+
+func (self *NxmTunFlagsMasked) SetValue(v uint16) {
+	self.Value = v
+}
+
+func (self *NxmTunFlagsMasked) GetValueMask() uint16 {
+	return self.ValueMask
+}
+
+func (self *NxmTunFlagsMasked) SetValueMask(v uint16) {
+	self.ValueMask = v
+}
+
+func (self *NxmTunFlagsMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Value))
+	encoder.PutUint16(uint16(self.ValueMask))
+
+	return nil
+}
+
+func DecodeNxmTunFlagsMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunFlagsMasked, error) {
+	_nxmtunflagsmasked := &NxmTunFlagsMasked{Oxm: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("NxmTunFlagsMasked packet too short: %d < 4", decoder.Length())
+	}
+	_nxmtunflagsmasked.Value = uint16(decoder.ReadUint16())
+	_nxmtunflagsmasked.ValueMask = uint16(decoder.ReadUint16())
+	return _nxmtunflagsmasked, nil
+}
+
+func NewNxmTunFlagsMasked() *NxmTunFlagsMasked {
+	obj := &NxmTunFlagsMasked{
+		Oxm: NewOxm(119044),
+	}
+	return obj
+}
+func (self *NxmTunFlagsMasked) GetOXMName() string {
+	return "tun_flags_masked"
+}
+
+func (self *NxmTunFlagsMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunFlagsMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmTunFlagsMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunGbpFlags struct {
+	*Oxm
+	Value uint8
+}
+
+type INxmTunGbpFlags interface {
+	goloxi.IOxm
+	GetValue() uint8
+}
+
+func (self *NxmTunGbpFlags) GetValue() uint8 {
+	return self.Value
+}
+
+func (self *NxmTunGbpFlags) SetValue(v uint8) {
+	self.Value = v
+}
+
+func (self *NxmTunGbpFlags) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint8(uint8(self.Value))
+
+	return nil
+}
+
+func DecodeNxmTunGbpFlags(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunGbpFlags, error) {
+	_nxmtungbpflags := &NxmTunGbpFlags{Oxm: parent}
+	if decoder.Length() < 1 {
+		return nil, fmt.Errorf("NxmTunGbpFlags packet too short: %d < 1", decoder.Length())
+	}
+	_nxmtungbpflags.Value = uint8(decoder.ReadByte())
+	return _nxmtungbpflags, nil
+}
+
+func NewNxmTunGbpFlags() *NxmTunGbpFlags {
+	obj := &NxmTunGbpFlags{
+		Oxm: NewOxm(85505),
+	}
+	return obj
+}
+func (self *NxmTunGbpFlags) GetOXMName() string {
+	return "tun_gbp_flags"
+}
+
+func (self *NxmTunGbpFlags) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunGbpFlags) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunGbpFlagsMasked struct {
+	*Oxm
+	Value     uint8
+	ValueMask uint8
+}
+
+type INxmTunGbpFlagsMasked interface {
+	goloxi.IOxm
+	GetValue() uint8
+	GetValueMask() uint8
+}
+
+func (self *NxmTunGbpFlagsMasked) GetValue() uint8 {
+	return self.Value
+}
+
+func (self *NxmTunGbpFlagsMasked) SetValue(v uint8) {
+	self.Value = v
+}
+
+func (self *NxmTunGbpFlagsMasked) GetValueMask() uint8 {
+	return self.ValueMask
+}
+
+func (self *NxmTunGbpFlagsMasked) SetValueMask(v uint8) {
+	self.ValueMask = v
+}
+
+func (self *NxmTunGbpFlagsMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint8(uint8(self.Value))
+	encoder.PutUint8(uint8(self.ValueMask))
+
+	return nil
+}
+
+func DecodeNxmTunGbpFlagsMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunGbpFlagsMasked, error) {
+	_nxmtungbpflagsmasked := &NxmTunGbpFlagsMasked{Oxm: parent}
+	if decoder.Length() < 2 {
+		return nil, fmt.Errorf("NxmTunGbpFlagsMasked packet too short: %d < 2", decoder.Length())
+	}
+	_nxmtungbpflagsmasked.Value = uint8(decoder.ReadByte())
+	_nxmtungbpflagsmasked.ValueMask = uint8(decoder.ReadByte())
+	return _nxmtungbpflagsmasked, nil
+}
+
+func NewNxmTunGbpFlagsMasked() *NxmTunGbpFlagsMasked {
+	obj := &NxmTunGbpFlagsMasked{
+		Oxm: NewOxm(85762),
+	}
+	return obj
+}
+func (self *NxmTunGbpFlagsMasked) GetOXMName() string {
+	return "tun_gbp_flags_masked"
+}
+
+func (self *NxmTunGbpFlagsMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunGbpFlagsMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmTunGbpFlagsMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunGbpId struct {
+	*Oxm
+	Value uint16
+}
+
+type INxmTunGbpId interface {
+	goloxi.IOxm
+	GetValue() uint16
+}
+
+func (self *NxmTunGbpId) GetValue() uint16 {
+	return self.Value
+}
+
+func (self *NxmTunGbpId) SetValue(v uint16) {
+	self.Value = v
+}
+
+func (self *NxmTunGbpId) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Value))
+
+	return nil
+}
+
+func DecodeNxmTunGbpId(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunGbpId, error) {
+	_nxmtungbpid := &NxmTunGbpId{Oxm: parent}
+	if decoder.Length() < 2 {
+		return nil, fmt.Errorf("NxmTunGbpId packet too short: %d < 2", decoder.Length())
+	}
+	_nxmtungbpid.Value = uint16(decoder.ReadUint16())
+	return _nxmtungbpid, nil
+}
+
+func NewNxmTunGbpId() *NxmTunGbpId {
+	obj := &NxmTunGbpId{
+		Oxm: NewOxm(84994),
+	}
+	return obj
+}
+func (self *NxmTunGbpId) GetOXMName() string {
+	return "tun_gbp_id"
+}
+
+func (self *NxmTunGbpId) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunGbpId) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunGbpIdMasked struct {
+	*Oxm
+	Value     uint16
+	ValueMask uint16
+}
+
+type INxmTunGbpIdMasked interface {
+	goloxi.IOxm
+	GetValue() uint16
+	GetValueMask() uint16
+}
+
+func (self *NxmTunGbpIdMasked) GetValue() uint16 {
+	return self.Value
+}
+
+func (self *NxmTunGbpIdMasked) SetValue(v uint16) {
+	self.Value = v
+}
+
+func (self *NxmTunGbpIdMasked) GetValueMask() uint16 {
+	return self.ValueMask
+}
+
+func (self *NxmTunGbpIdMasked) SetValueMask(v uint16) {
+	self.ValueMask = v
+}
+
+func (self *NxmTunGbpIdMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Value))
+	encoder.PutUint16(uint16(self.ValueMask))
+
+	return nil
+}
+
+func DecodeNxmTunGbpIdMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunGbpIdMasked, error) {
+	_nxmtungbpidmasked := &NxmTunGbpIdMasked{Oxm: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("NxmTunGbpIdMasked packet too short: %d < 4", decoder.Length())
+	}
+	_nxmtungbpidmasked.Value = uint16(decoder.ReadUint16())
+	_nxmtungbpidmasked.ValueMask = uint16(decoder.ReadUint16())
+	return _nxmtungbpidmasked, nil
+}
+
+func NewNxmTunGbpIdMasked() *NxmTunGbpIdMasked {
+	obj := &NxmTunGbpIdMasked{
+		Oxm: NewOxm(85252),
+	}
+	return obj
+}
+func (self *NxmTunGbpIdMasked) GetOXMName() string {
+	return "tun_gbp_id_masked"
+}
+
+func (self *NxmTunGbpIdMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunGbpIdMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmTunGbpIdMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunId struct {
+	*Oxm
+	Value uint64
+}
+
+type INxmTunId interface {
+	goloxi.IOxm
+	GetValue() uint64
+}
+
+func (self *NxmTunId) GetValue() uint64 {
+	return self.Value
+}
+
+func (self *NxmTunId) SetValue(v uint64) {
+	self.Value = v
+}
+
+func (self *NxmTunId) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint64(uint64(self.Value))
+
+	return nil
+}
+
+func DecodeNxmTunId(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunId, error) {
+	_nxmtunid := &NxmTunId{Oxm: parent}
+	if decoder.Length() < 8 {
+		return nil, fmt.Errorf("NxmTunId packet too short: %d < 8", decoder.Length())
+	}
+	_nxmtunid.Value = uint64(decoder.ReadUint64())
+	return _nxmtunid, nil
+}
+
+func NewNxmTunId() *NxmTunId {
+	obj := &NxmTunId{
+		Oxm: NewOxm(73736),
+	}
+	return obj
+}
+func (self *NxmTunId) GetOXMName() string {
+	return "tun_id"
+}
+
+func (self *NxmTunId) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunId) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunIdMasked struct {
+	*Oxm
+	Value     uint64
+	ValueMask uint64
+}
+
+type INxmTunIdMasked interface {
+	goloxi.IOxm
+	GetValue() uint64
+	GetValueMask() uint64
+}
+
+func (self *NxmTunIdMasked) GetValue() uint64 {
+	return self.Value
+}
+
+func (self *NxmTunIdMasked) SetValue(v uint64) {
+	self.Value = v
+}
+
+func (self *NxmTunIdMasked) GetValueMask() uint64 {
+	return self.ValueMask
+}
+
+func (self *NxmTunIdMasked) SetValueMask(v uint64) {
+	self.ValueMask = v
+}
+
+func (self *NxmTunIdMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint64(uint64(self.Value))
+	encoder.PutUint64(uint64(self.ValueMask))
+
+	return nil
+}
+
+func DecodeNxmTunIdMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunIdMasked, error) {
+	_nxmtunidmasked := &NxmTunIdMasked{Oxm: parent}
+	if decoder.Length() < 16 {
+		return nil, fmt.Errorf("NxmTunIdMasked packet too short: %d < 16", decoder.Length())
+	}
+	_nxmtunidmasked.Value = uint64(decoder.ReadUint64())
+	_nxmtunidmasked.ValueMask = uint64(decoder.ReadUint64())
+	return _nxmtunidmasked, nil
+}
+
+func NewNxmTunIdMasked() *NxmTunIdMasked {
+	obj := &NxmTunIdMasked{
+		Oxm: NewOxm(74000),
+	}
+	return obj
+}
+func (self *NxmTunIdMasked) GetOXMName() string {
+	return "tun_id_masked"
+}
+
+func (self *NxmTunIdMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunIdMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmTunIdMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunIpv6Dst struct {
+	*Oxm
+	Value net.IP
+}
+
+type INxmTunIpv6Dst interface {
+	goloxi.IOxm
+	GetValue() net.IP
+}
+
+func (self *NxmTunIpv6Dst) GetValue() net.IP {
+	return self.Value
+}
+
+func (self *NxmTunIpv6Dst) SetValue(v net.IP) {
+	self.Value = v
+}
+
+func (self *NxmTunIpv6Dst) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value.To16())
+
+	return nil
+}
+
+func DecodeNxmTunIpv6Dst(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunIpv6Dst, error) {
+	_nxmtunipv6dst := &NxmTunIpv6Dst{Oxm: parent}
+	if decoder.Length() < 16 {
+		return nil, fmt.Errorf("NxmTunIpv6Dst packet too short: %d < 16", decoder.Length())
+	}
+	_nxmtunipv6dst.Value = net.IP(decoder.Read(16))
+	return _nxmtunipv6dst, nil
+}
+
+func NewNxmTunIpv6Dst() *NxmTunIpv6Dst {
+	obj := &NxmTunIpv6Dst{
+		Oxm: NewOxm(121872),
+	}
+	return obj
+}
+func (self *NxmTunIpv6Dst) GetOXMName() string {
+	return "tun_ipv6_dst"
+}
+
+func (self *NxmTunIpv6Dst) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunIpv6Dst) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunIpv6DstMasked struct {
+	*Oxm
+	Value     net.IP
+	ValueMask net.IP
+}
+
+type INxmTunIpv6DstMasked interface {
+	goloxi.IOxm
+	GetValue() net.IP
+	GetValueMask() net.IP
+}
+
+func (self *NxmTunIpv6DstMasked) GetValue() net.IP {
+	return self.Value
+}
+
+func (self *NxmTunIpv6DstMasked) SetValue(v net.IP) {
+	self.Value = v
+}
+
+func (self *NxmTunIpv6DstMasked) GetValueMask() net.IP {
+	return self.ValueMask
+}
+
+func (self *NxmTunIpv6DstMasked) SetValueMask(v net.IP) {
+	self.ValueMask = v
+}
+
+func (self *NxmTunIpv6DstMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value.To16())
+	encoder.Write(self.ValueMask.To16())
+
+	return nil
+}
+
+func DecodeNxmTunIpv6DstMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunIpv6DstMasked, error) {
+	_nxmtunipv6dstmasked := &NxmTunIpv6DstMasked{Oxm: parent}
+	if decoder.Length() < 32 {
+		return nil, fmt.Errorf("NxmTunIpv6DstMasked packet too short: %d < 32", decoder.Length())
+	}
+	_nxmtunipv6dstmasked.Value = net.IP(decoder.Read(16))
+	_nxmtunipv6dstmasked.ValueMask = net.IP(decoder.Read(16))
+	return _nxmtunipv6dstmasked, nil
+}
+
+func NewNxmTunIpv6DstMasked() *NxmTunIpv6DstMasked {
+	obj := &NxmTunIpv6DstMasked{
+		Oxm: NewOxm(122144),
+	}
+	return obj
+}
+func (self *NxmTunIpv6DstMasked) GetOXMName() string {
+	return "tun_ipv6_dst_masked"
+}
+
+func (self *NxmTunIpv6DstMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunIpv6DstMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmTunIpv6DstMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunIpv6Src struct {
+	*Oxm
+	Value net.IP
+}
+
+type INxmTunIpv6Src interface {
+	goloxi.IOxm
+	GetValue() net.IP
+}
+
+func (self *NxmTunIpv6Src) GetValue() net.IP {
+	return self.Value
+}
+
+func (self *NxmTunIpv6Src) SetValue(v net.IP) {
+	self.Value = v
+}
+
+func (self *NxmTunIpv6Src) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value.To16())
+
+	return nil
+}
+
+func DecodeNxmTunIpv6Src(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunIpv6Src, error) {
+	_nxmtunipv6src := &NxmTunIpv6Src{Oxm: parent}
+	if decoder.Length() < 16 {
+		return nil, fmt.Errorf("NxmTunIpv6Src packet too short: %d < 16", decoder.Length())
+	}
+	_nxmtunipv6src.Value = net.IP(decoder.Read(16))
+	return _nxmtunipv6src, nil
+}
+
+func NewNxmTunIpv6Src() *NxmTunIpv6Src {
+	obj := &NxmTunIpv6Src{
+		Oxm: NewOxm(121360),
+	}
+	return obj
+}
+func (self *NxmTunIpv6Src) GetOXMName() string {
+	return "tun_ipv6_src"
+}
+
+func (self *NxmTunIpv6Src) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunIpv6Src) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunIpv6SrcMasked struct {
+	*Oxm
+	Value     net.IP
+	ValueMask net.IP
+}
+
+type INxmTunIpv6SrcMasked interface {
+	goloxi.IOxm
+	GetValue() net.IP
+	GetValueMask() net.IP
+}
+
+func (self *NxmTunIpv6SrcMasked) GetValue() net.IP {
+	return self.Value
+}
+
+func (self *NxmTunIpv6SrcMasked) SetValue(v net.IP) {
+	self.Value = v
+}
+
+func (self *NxmTunIpv6SrcMasked) GetValueMask() net.IP {
+	return self.ValueMask
+}
+
+func (self *NxmTunIpv6SrcMasked) SetValueMask(v net.IP) {
+	self.ValueMask = v
+}
+
+func (self *NxmTunIpv6SrcMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value.To16())
+	encoder.Write(self.ValueMask.To16())
+
+	return nil
+}
+
+func DecodeNxmTunIpv6SrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunIpv6SrcMasked, error) {
+	_nxmtunipv6srcmasked := &NxmTunIpv6SrcMasked{Oxm: parent}
+	if decoder.Length() < 32 {
+		return nil, fmt.Errorf("NxmTunIpv6SrcMasked packet too short: %d < 32", decoder.Length())
+	}
+	_nxmtunipv6srcmasked.Value = net.IP(decoder.Read(16))
+	_nxmtunipv6srcmasked.ValueMask = net.IP(decoder.Read(16))
+	return _nxmtunipv6srcmasked, nil
+}
+
+func NewNxmTunIpv6SrcMasked() *NxmTunIpv6SrcMasked {
+	obj := &NxmTunIpv6SrcMasked{
+		Oxm: NewOxm(121632),
+	}
+	return obj
+}
+func (self *NxmTunIpv6SrcMasked) GetOXMName() string {
+	return "tun_ipv6_src_masked"
+}
+
+func (self *NxmTunIpv6SrcMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunIpv6SrcMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmTunIpv6SrcMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata0 struct {
+	*Oxm
+	Value []byte
+}
+
+type INxmTunMetadata0 interface {
+	goloxi.IOxm
+	GetValue() []byte
+}
+
+func (self *NxmTunMetadata0) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata0) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata0) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata0(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata0, error) {
+	_nxmtunmetadata0 := &NxmTunMetadata0{Oxm: parent}
+	_nxmtunmetadata0.Value = decoder.Read(int(_nxmtunmetadata0.TypeLen & 0xFF))
+	return _nxmtunmetadata0, nil
+}
+
+func NewNxmTunMetadata0() *NxmTunMetadata0 {
+	obj := &NxmTunMetadata0{
+		Oxm: NewOxm(86140),
+	}
+	return obj
+}
+func (self *NxmTunMetadata0) GetOXMName() string {
+	return "tun_metadata0"
+}
+
+func (self *NxmTunMetadata0) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata0) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata0Masked struct {
+	*Oxm
+	Value     []byte
+	ValueMask []byte
+}
+
+type INxmTunMetadata0Masked interface {
+	goloxi.IOxm
+	GetValue() []byte
+	GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata0Masked) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata0Masked) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata0Masked) GetValueMask() []byte {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata0Masked) SetValueMask(v []byte) {
+	self.ValueMask = v
+}
+
+func (self *NxmTunMetadata0Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata0Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata0Masked, error) {
+	_nxmtunmetadata0masked := &NxmTunMetadata0Masked{Oxm: parent}
+	_nxmtunmetadata0masked.Value = decoder.Read(int(_nxmtunmetadata0masked.TypeLen & 0xFF))
+	_nxmtunmetadata0masked.ValueMask = decoder.Read(int(_nxmtunmetadata0masked.TypeLen & 0xFF))
+	return _nxmtunmetadata0masked, nil
+}
+
+func NewNxmTunMetadata0Masked() *NxmTunMetadata0Masked {
+	obj := &NxmTunMetadata0Masked{
+		Oxm: NewOxm(86520),
+	}
+	return obj
+}
+func (self *NxmTunMetadata0Masked) GetOXMName() string {
+	return "tun_metadata0_masked"
+}
+
+func (self *NxmTunMetadata0Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata0Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata0Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata1 struct {
+	*Oxm
+	Value []byte
+}
+
+type INxmTunMetadata1 interface {
+	goloxi.IOxm
+	GetValue() []byte
+}
+
+func (self *NxmTunMetadata1) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata1) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata1) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata1(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata1, error) {
+	_nxmtunmetadata1 := &NxmTunMetadata1{Oxm: parent}
+	_nxmtunmetadata1.Value = decoder.Read(int(_nxmtunmetadata1.TypeLen & 0xFF))
+	return _nxmtunmetadata1, nil
+}
+
+func NewNxmTunMetadata1() *NxmTunMetadata1 {
+	obj := &NxmTunMetadata1{
+		Oxm: NewOxm(86652),
+	}
+	return obj
+}
+func (self *NxmTunMetadata1) GetOXMName() string {
+	return "tun_metadata1"
+}
+
+func (self *NxmTunMetadata1) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata1) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata10 struct {
+	*Oxm
+	Value []byte
+}
+
+type INxmTunMetadata10 interface {
+	goloxi.IOxm
+	GetValue() []byte
+}
+
+func (self *NxmTunMetadata10) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata10) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata10) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata10(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata10, error) {
+	_nxmtunmetadata10 := &NxmTunMetadata10{Oxm: parent}
+	_nxmtunmetadata10.Value = decoder.Read(int(_nxmtunmetadata10.TypeLen & 0xFF))
+	return _nxmtunmetadata10, nil
+}
+
+func NewNxmTunMetadata10() *NxmTunMetadata10 {
+	obj := &NxmTunMetadata10{
+		Oxm: NewOxm(91260),
+	}
+	return obj
+}
+func (self *NxmTunMetadata10) GetOXMName() string {
+	return "tun_metadata10"
+}
+
+func (self *NxmTunMetadata10) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata10) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata10Masked struct {
+	*Oxm
+	Value     []byte
+	ValueMask []byte
+}
+
+type INxmTunMetadata10Masked interface {
+	goloxi.IOxm
+	GetValue() []byte
+	GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata10Masked) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata10Masked) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata10Masked) GetValueMask() []byte {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata10Masked) SetValueMask(v []byte) {
+	self.ValueMask = v
+}
+
+func (self *NxmTunMetadata10Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata10Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata10Masked, error) {
+	_nxmtunmetadata10masked := &NxmTunMetadata10Masked{Oxm: parent}
+	_nxmtunmetadata10masked.Value = decoder.Read(int(_nxmtunmetadata10masked.TypeLen & 0xFF))
+	_nxmtunmetadata10masked.ValueMask = decoder.Read(int(_nxmtunmetadata10masked.TypeLen & 0xFF))
+	return _nxmtunmetadata10masked, nil
+}
+
+func NewNxmTunMetadata10Masked() *NxmTunMetadata10Masked {
+	obj := &NxmTunMetadata10Masked{
+		Oxm: NewOxm(91640),
+	}
+	return obj
+}
+func (self *NxmTunMetadata10Masked) GetOXMName() string {
+	return "tun_metadata10_masked"
+}
+
+func (self *NxmTunMetadata10Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata10Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata10Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata11 struct {
+	*Oxm
+	Value []byte
+}
+
+type INxmTunMetadata11 interface {
+	goloxi.IOxm
+	GetValue() []byte
+}
+
+func (self *NxmTunMetadata11) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata11) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata11) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata11(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata11, error) {
+	_nxmtunmetadata11 := &NxmTunMetadata11{Oxm: parent}
+	_nxmtunmetadata11.Value = decoder.Read(int(_nxmtunmetadata11.TypeLen & 0xFF))
+	return _nxmtunmetadata11, nil
+}
+
+func NewNxmTunMetadata11() *NxmTunMetadata11 {
+	obj := &NxmTunMetadata11{
+		Oxm: NewOxm(91772),
+	}
+	return obj
+}
+func (self *NxmTunMetadata11) GetOXMName() string {
+	return "tun_metadata11"
+}
+
+func (self *NxmTunMetadata11) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata11) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata11Masked struct {
+	*Oxm
+	Value     []byte
+	ValueMask []byte
+}
+
+type INxmTunMetadata11Masked interface {
+	goloxi.IOxm
+	GetValue() []byte
+	GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata11Masked) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata11Masked) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata11Masked) GetValueMask() []byte {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata11Masked) SetValueMask(v []byte) {
+	self.ValueMask = v
+}
+
+func (self *NxmTunMetadata11Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata11Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata11Masked, error) {
+	_nxmtunmetadata11masked := &NxmTunMetadata11Masked{Oxm: parent}
+	_nxmtunmetadata11masked.Value = decoder.Read(int(_nxmtunmetadata11masked.TypeLen & 0xFF))
+	_nxmtunmetadata11masked.ValueMask = decoder.Read(int(_nxmtunmetadata11masked.TypeLen & 0xFF))
+	return _nxmtunmetadata11masked, nil
+}
+
+func NewNxmTunMetadata11Masked() *NxmTunMetadata11Masked {
+	obj := &NxmTunMetadata11Masked{
+		Oxm: NewOxm(92152),
+	}
+	return obj
+}
+func (self *NxmTunMetadata11Masked) GetOXMName() string {
+	return "tun_metadata11_masked"
+}
+
+func (self *NxmTunMetadata11Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata11Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata11Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata12 struct {
+	*Oxm
+	Value []byte
+}
+
+type INxmTunMetadata12 interface {
+	goloxi.IOxm
+	GetValue() []byte
+}
+
+func (self *NxmTunMetadata12) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata12) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata12) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata12(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata12, error) {
+	_nxmtunmetadata12 := &NxmTunMetadata12{Oxm: parent}
+	_nxmtunmetadata12.Value = decoder.Read(int(_nxmtunmetadata12.TypeLen & 0xFF))
+	return _nxmtunmetadata12, nil
+}
+
+func NewNxmTunMetadata12() *NxmTunMetadata12 {
+	obj := &NxmTunMetadata12{
+		Oxm: NewOxm(92284),
+	}
+	return obj
+}
+func (self *NxmTunMetadata12) GetOXMName() string {
+	return "tun_metadata12"
+}
+
+func (self *NxmTunMetadata12) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata12) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata12Masked struct {
+	*Oxm
+	Value     []byte
+	ValueMask []byte
+}
+
+type INxmTunMetadata12Masked interface {
+	goloxi.IOxm
+	GetValue() []byte
+	GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata12Masked) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata12Masked) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata12Masked) GetValueMask() []byte {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata12Masked) SetValueMask(v []byte) {
+	self.ValueMask = v
+}
+
+func (self *NxmTunMetadata12Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata12Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata12Masked, error) {
+	_nxmtunmetadata12masked := &NxmTunMetadata12Masked{Oxm: parent}
+	_nxmtunmetadata12masked.Value = decoder.Read(int(_nxmtunmetadata12masked.TypeLen & 0xFF))
+	_nxmtunmetadata12masked.ValueMask = decoder.Read(int(_nxmtunmetadata12masked.TypeLen & 0xFF))
+	return _nxmtunmetadata12masked, nil
+}
+
+func NewNxmTunMetadata12Masked() *NxmTunMetadata12Masked {
+	obj := &NxmTunMetadata12Masked{
+		Oxm: NewOxm(92664),
+	}
+	return obj
+}
+func (self *NxmTunMetadata12Masked) GetOXMName() string {
+	return "tun_metadata12_masked"
+}
+
+func (self *NxmTunMetadata12Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata12Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata12Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata13 struct {
+	*Oxm
+	Value []byte
+}
+
+type INxmTunMetadata13 interface {
+	goloxi.IOxm
+	GetValue() []byte
+}
+
+func (self *NxmTunMetadata13) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata13) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata13) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata13(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata13, error) {
+	_nxmtunmetadata13 := &NxmTunMetadata13{Oxm: parent}
+	_nxmtunmetadata13.Value = decoder.Read(int(_nxmtunmetadata13.TypeLen & 0xFF))
+	return _nxmtunmetadata13, nil
+}
+
+func NewNxmTunMetadata13() *NxmTunMetadata13 {
+	obj := &NxmTunMetadata13{
+		Oxm: NewOxm(92796),
+	}
+	return obj
+}
+func (self *NxmTunMetadata13) GetOXMName() string {
+	return "tun_metadata13"
+}
+
+func (self *NxmTunMetadata13) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata13) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata13Masked struct {
+	*Oxm
+	Value     []byte
+	ValueMask []byte
+}
+
+type INxmTunMetadata13Masked interface {
+	goloxi.IOxm
+	GetValue() []byte
+	GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata13Masked) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata13Masked) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata13Masked) GetValueMask() []byte {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata13Masked) SetValueMask(v []byte) {
+	self.ValueMask = v
+}
+
+func (self *NxmTunMetadata13Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata13Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata13Masked, error) {
+	_nxmtunmetadata13masked := &NxmTunMetadata13Masked{Oxm: parent}
+	_nxmtunmetadata13masked.Value = decoder.Read(int(_nxmtunmetadata13masked.TypeLen & 0xFF))
+	_nxmtunmetadata13masked.ValueMask = decoder.Read(int(_nxmtunmetadata13masked.TypeLen & 0xFF))
+	return _nxmtunmetadata13masked, nil
+}
+
+func NewNxmTunMetadata13Masked() *NxmTunMetadata13Masked {
+	obj := &NxmTunMetadata13Masked{
+		Oxm: NewOxm(93176),
+	}
+	return obj
+}
+func (self *NxmTunMetadata13Masked) GetOXMName() string {
+	return "tun_metadata13_masked"
+}
+
+func (self *NxmTunMetadata13Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata13Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata13Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata14 struct {
+	*Oxm
+	Value []byte
+}
+
+type INxmTunMetadata14 interface {
+	goloxi.IOxm
+	GetValue() []byte
+}
+
+func (self *NxmTunMetadata14) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata14) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata14) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata14(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata14, error) {
+	_nxmtunmetadata14 := &NxmTunMetadata14{Oxm: parent}
+	_nxmtunmetadata14.Value = decoder.Read(int(_nxmtunmetadata14.TypeLen & 0xFF))
+	return _nxmtunmetadata14, nil
+}
+
+func NewNxmTunMetadata14() *NxmTunMetadata14 {
+	obj := &NxmTunMetadata14{
+		Oxm: NewOxm(93308),
+	}
+	return obj
+}
+func (self *NxmTunMetadata14) GetOXMName() string {
+	return "tun_metadata14"
+}
+
+func (self *NxmTunMetadata14) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata14) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata14Masked struct {
+	*Oxm
+	Value     []byte
+	ValueMask []byte
+}
+
+type INxmTunMetadata14Masked interface {
+	goloxi.IOxm
+	GetValue() []byte
+	GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata14Masked) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata14Masked) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata14Masked) GetValueMask() []byte {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata14Masked) SetValueMask(v []byte) {
+	self.ValueMask = v
+}
+
+func (self *NxmTunMetadata14Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata14Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata14Masked, error) {
+	_nxmtunmetadata14masked := &NxmTunMetadata14Masked{Oxm: parent}
+	_nxmtunmetadata14masked.Value = decoder.Read(int(_nxmtunmetadata14masked.TypeLen & 0xFF))
+	_nxmtunmetadata14masked.ValueMask = decoder.Read(int(_nxmtunmetadata14masked.TypeLen & 0xFF))
+	return _nxmtunmetadata14masked, nil
+}
+
+func NewNxmTunMetadata14Masked() *NxmTunMetadata14Masked {
+	obj := &NxmTunMetadata14Masked{
+		Oxm: NewOxm(93688),
+	}
+	return obj
+}
+func (self *NxmTunMetadata14Masked) GetOXMName() string {
+	return "tun_metadata14_masked"
+}
+
+func (self *NxmTunMetadata14Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata14Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata14Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata15 struct {
+	*Oxm
+	Value []byte
+}
+
+type INxmTunMetadata15 interface {
+	goloxi.IOxm
+	GetValue() []byte
+}
+
+func (self *NxmTunMetadata15) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata15) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata15) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata15(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata15, error) {
+	_nxmtunmetadata15 := &NxmTunMetadata15{Oxm: parent}
+	_nxmtunmetadata15.Value = decoder.Read(int(_nxmtunmetadata15.TypeLen & 0xFF))
+	return _nxmtunmetadata15, nil
+}
+
+func NewNxmTunMetadata15() *NxmTunMetadata15 {
+	obj := &NxmTunMetadata15{
+		Oxm: NewOxm(93820),
+	}
+	return obj
+}
+func (self *NxmTunMetadata15) GetOXMName() string {
+	return "tun_metadata15"
+}
+
+func (self *NxmTunMetadata15) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata15) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata15Masked struct {
+	*Oxm
+	Value     []byte
+	ValueMask []byte
+}
+
+type INxmTunMetadata15Masked interface {
+	goloxi.IOxm
+	GetValue() []byte
+	GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata15Masked) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata15Masked) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata15Masked) GetValueMask() []byte {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata15Masked) SetValueMask(v []byte) {
+	self.ValueMask = v
+}
+
+func (self *NxmTunMetadata15Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata15Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata15Masked, error) {
+	_nxmtunmetadata15masked := &NxmTunMetadata15Masked{Oxm: parent}
+	_nxmtunmetadata15masked.Value = decoder.Read(int(_nxmtunmetadata15masked.TypeLen & 0xFF))
+	_nxmtunmetadata15masked.ValueMask = decoder.Read(int(_nxmtunmetadata15masked.TypeLen & 0xFF))
+	return _nxmtunmetadata15masked, nil
+}
+
+func NewNxmTunMetadata15Masked() *NxmTunMetadata15Masked {
+	obj := &NxmTunMetadata15Masked{
+		Oxm: NewOxm(94200),
+	}
+	return obj
+}
+func (self *NxmTunMetadata15Masked) GetOXMName() string {
+	return "tun_metadata15_masked"
+}
+
+func (self *NxmTunMetadata15Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata15Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata15Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata16 struct {
+	*Oxm
+	Value []byte
+}
+
+type INxmTunMetadata16 interface {
+	goloxi.IOxm
+	GetValue() []byte
+}
+
+func (self *NxmTunMetadata16) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata16) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata16) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata16(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata16, error) {
+	_nxmtunmetadata16 := &NxmTunMetadata16{Oxm: parent}
+	_nxmtunmetadata16.Value = decoder.Read(int(_nxmtunmetadata16.TypeLen & 0xFF))
+	return _nxmtunmetadata16, nil
+}
+
+func NewNxmTunMetadata16() *NxmTunMetadata16 {
+	obj := &NxmTunMetadata16{
+		Oxm: NewOxm(94332),
+	}
+	return obj
+}
+func (self *NxmTunMetadata16) GetOXMName() string {
+	return "tun_metadata16"
+}
+
+func (self *NxmTunMetadata16) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata16) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata16Masked struct {
+	*Oxm
+	Value     []byte
+	ValueMask []byte
+}
+
+type INxmTunMetadata16Masked interface {
+	goloxi.IOxm
+	GetValue() []byte
+	GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata16Masked) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata16Masked) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata16Masked) GetValueMask() []byte {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata16Masked) SetValueMask(v []byte) {
+	self.ValueMask = v
+}
+
+func (self *NxmTunMetadata16Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata16Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata16Masked, error) {
+	_nxmtunmetadata16masked := &NxmTunMetadata16Masked{Oxm: parent}
+	_nxmtunmetadata16masked.Value = decoder.Read(int(_nxmtunmetadata16masked.TypeLen & 0xFF))
+	_nxmtunmetadata16masked.ValueMask = decoder.Read(int(_nxmtunmetadata16masked.TypeLen & 0xFF))
+	return _nxmtunmetadata16masked, nil
+}
+
+func NewNxmTunMetadata16Masked() *NxmTunMetadata16Masked {
+	obj := &NxmTunMetadata16Masked{
+		Oxm: NewOxm(94712),
+	}
+	return obj
+}
+func (self *NxmTunMetadata16Masked) GetOXMName() string {
+	return "tun_metadata16_masked"
+}
+
+func (self *NxmTunMetadata16Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata16Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata16Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata17 struct {
+	*Oxm
+	Value []byte
+}
+
+type INxmTunMetadata17 interface {
+	goloxi.IOxm
+	GetValue() []byte
+}
+
+func (self *NxmTunMetadata17) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata17) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata17) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata17(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata17, error) {
+	_nxmtunmetadata17 := &NxmTunMetadata17{Oxm: parent}
+	_nxmtunmetadata17.Value = decoder.Read(int(_nxmtunmetadata17.TypeLen & 0xFF))
+	return _nxmtunmetadata17, nil
+}
+
+func NewNxmTunMetadata17() *NxmTunMetadata17 {
+	obj := &NxmTunMetadata17{
+		Oxm: NewOxm(94844),
+	}
+	return obj
+}
+func (self *NxmTunMetadata17) GetOXMName() string {
+	return "tun_metadata17"
+}
+
+func (self *NxmTunMetadata17) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata17) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata17Masked struct {
+	*Oxm
+	Value     []byte
+	ValueMask []byte
+}
+
+type INxmTunMetadata17Masked interface {
+	goloxi.IOxm
+	GetValue() []byte
+	GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata17Masked) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata17Masked) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata17Masked) GetValueMask() []byte {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata17Masked) SetValueMask(v []byte) {
+	self.ValueMask = v
+}
+
+func (self *NxmTunMetadata17Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata17Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata17Masked, error) {
+	_nxmtunmetadata17masked := &NxmTunMetadata17Masked{Oxm: parent}
+	_nxmtunmetadata17masked.Value = decoder.Read(int(_nxmtunmetadata17masked.TypeLen & 0xFF))
+	_nxmtunmetadata17masked.ValueMask = decoder.Read(int(_nxmtunmetadata17masked.TypeLen & 0xFF))
+	return _nxmtunmetadata17masked, nil
+}
+
+func NewNxmTunMetadata17Masked() *NxmTunMetadata17Masked {
+	obj := &NxmTunMetadata17Masked{
+		Oxm: NewOxm(95224),
+	}
+	return obj
+}
+func (self *NxmTunMetadata17Masked) GetOXMName() string {
+	return "tun_metadata17_masked"
+}
+
+func (self *NxmTunMetadata17Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata17Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata17Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata18 struct {
+	*Oxm
+	Value []byte
+}
+
+type INxmTunMetadata18 interface {
+	goloxi.IOxm
+	GetValue() []byte
+}
+
+func (self *NxmTunMetadata18) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata18) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata18) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata18(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata18, error) {
+	_nxmtunmetadata18 := &NxmTunMetadata18{Oxm: parent}
+	_nxmtunmetadata18.Value = decoder.Read(int(_nxmtunmetadata18.TypeLen & 0xFF))
+	return _nxmtunmetadata18, nil
+}
+
+func NewNxmTunMetadata18() *NxmTunMetadata18 {
+	obj := &NxmTunMetadata18{
+		Oxm: NewOxm(95356),
+	}
+	return obj
+}
+func (self *NxmTunMetadata18) GetOXMName() string {
+	return "tun_metadata18"
+}
+
+func (self *NxmTunMetadata18) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata18) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata18Masked struct {
+	*Oxm
+	Value     []byte
+	ValueMask []byte
+}
+
+type INxmTunMetadata18Masked interface {
+	goloxi.IOxm
+	GetValue() []byte
+	GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata18Masked) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata18Masked) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata18Masked) GetValueMask() []byte {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata18Masked) SetValueMask(v []byte) {
+	self.ValueMask = v
+}
+
+func (self *NxmTunMetadata18Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata18Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata18Masked, error) {
+	_nxmtunmetadata18masked := &NxmTunMetadata18Masked{Oxm: parent}
+	_nxmtunmetadata18masked.Value = decoder.Read(int(_nxmtunmetadata18masked.TypeLen & 0xFF))
+	_nxmtunmetadata18masked.ValueMask = decoder.Read(int(_nxmtunmetadata18masked.TypeLen & 0xFF))
+	return _nxmtunmetadata18masked, nil
+}
+
+func NewNxmTunMetadata18Masked() *NxmTunMetadata18Masked {
+	obj := &NxmTunMetadata18Masked{
+		Oxm: NewOxm(95736),
+	}
+	return obj
+}
+func (self *NxmTunMetadata18Masked) GetOXMName() string {
+	return "tun_metadata18_masked"
+}
+
+func (self *NxmTunMetadata18Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata18Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata18Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata19 struct {
+	*Oxm
+	Value []byte
+}
+
+type INxmTunMetadata19 interface {
+	goloxi.IOxm
+	GetValue() []byte
+}
+
+func (self *NxmTunMetadata19) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata19) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata19) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata19(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata19, error) {
+	_nxmtunmetadata19 := &NxmTunMetadata19{Oxm: parent}
+	_nxmtunmetadata19.Value = decoder.Read(int(_nxmtunmetadata19.TypeLen & 0xFF))
+	return _nxmtunmetadata19, nil
+}
+
+func NewNxmTunMetadata19() *NxmTunMetadata19 {
+	obj := &NxmTunMetadata19{
+		Oxm: NewOxm(95868),
+	}
+	return obj
+}
+func (self *NxmTunMetadata19) GetOXMName() string {
+	return "tun_metadata19"
+}
+
+func (self *NxmTunMetadata19) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata19) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata19Masked struct {
+	*Oxm
+	Value     []byte
+	ValueMask []byte
+}
+
+type INxmTunMetadata19Masked interface {
+	goloxi.IOxm
+	GetValue() []byte
+	GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata19Masked) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata19Masked) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata19Masked) GetValueMask() []byte {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata19Masked) SetValueMask(v []byte) {
+	self.ValueMask = v
+}
+
+func (self *NxmTunMetadata19Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata19Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata19Masked, error) {
+	_nxmtunmetadata19masked := &NxmTunMetadata19Masked{Oxm: parent}
+	_nxmtunmetadata19masked.Value = decoder.Read(int(_nxmtunmetadata19masked.TypeLen & 0xFF))
+	_nxmtunmetadata19masked.ValueMask = decoder.Read(int(_nxmtunmetadata19masked.TypeLen & 0xFF))
+	return _nxmtunmetadata19masked, nil
+}
+
+func NewNxmTunMetadata19Masked() *NxmTunMetadata19Masked {
+	obj := &NxmTunMetadata19Masked{
+		Oxm: NewOxm(96248),
+	}
+	return obj
+}
+func (self *NxmTunMetadata19Masked) GetOXMName() string {
+	return "tun_metadata19_masked"
+}
+
+func (self *NxmTunMetadata19Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata19Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata19Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata1Masked struct {
+	*Oxm
+	Value     []byte
+	ValueMask []byte
+}
+
+type INxmTunMetadata1Masked interface {
+	goloxi.IOxm
+	GetValue() []byte
+	GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata1Masked) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata1Masked) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata1Masked) GetValueMask() []byte {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata1Masked) SetValueMask(v []byte) {
+	self.ValueMask = v
+}
+
+func (self *NxmTunMetadata1Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata1Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata1Masked, error) {
+	_nxmtunmetadata1masked := &NxmTunMetadata1Masked{Oxm: parent}
+	_nxmtunmetadata1masked.Value = decoder.Read(int(_nxmtunmetadata1masked.TypeLen & 0xFF))
+	_nxmtunmetadata1masked.ValueMask = decoder.Read(int(_nxmtunmetadata1masked.TypeLen & 0xFF))
+	return _nxmtunmetadata1masked, nil
+}
+
+func NewNxmTunMetadata1Masked() *NxmTunMetadata1Masked {
+	obj := &NxmTunMetadata1Masked{
+		Oxm: NewOxm(87032),
+	}
+	return obj
+}
+func (self *NxmTunMetadata1Masked) GetOXMName() string {
+	return "tun_metadata1_masked"
+}
+
+func (self *NxmTunMetadata1Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata1Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata1Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata2 struct {
+	*Oxm
+	Value []byte
+}
+
+type INxmTunMetadata2 interface {
+	goloxi.IOxm
+	GetValue() []byte
+}
+
+func (self *NxmTunMetadata2) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata2) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata2) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata2(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata2, error) {
+	_nxmtunmetadata2 := &NxmTunMetadata2{Oxm: parent}
+	_nxmtunmetadata2.Value = decoder.Read(int(_nxmtunmetadata2.TypeLen & 0xFF))
+	return _nxmtunmetadata2, nil
+}
+
+func NewNxmTunMetadata2() *NxmTunMetadata2 {
+	obj := &NxmTunMetadata2{
+		Oxm: NewOxm(87164),
+	}
+	return obj
+}
+func (self *NxmTunMetadata2) GetOXMName() string {
+	return "tun_metadata2"
+}
+
+func (self *NxmTunMetadata2) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata2) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata20 struct {
+	*Oxm
+	Value []byte
+}
+
+type INxmTunMetadata20 interface {
+	goloxi.IOxm
+	GetValue() []byte
+}
+
+func (self *NxmTunMetadata20) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata20) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata20) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata20(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata20, error) {
+	_nxmtunmetadata20 := &NxmTunMetadata20{Oxm: parent}
+	_nxmtunmetadata20.Value = decoder.Read(int(_nxmtunmetadata20.TypeLen & 0xFF))
+	return _nxmtunmetadata20, nil
+}
+
+func NewNxmTunMetadata20() *NxmTunMetadata20 {
+	obj := &NxmTunMetadata20{
+		Oxm: NewOxm(96380),
+	}
+	return obj
+}
+func (self *NxmTunMetadata20) GetOXMName() string {
+	return "tun_metadata20"
+}
+
+func (self *NxmTunMetadata20) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata20) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata20Masked struct {
+	*Oxm
+	Value     []byte
+	ValueMask []byte
+}
+
+type INxmTunMetadata20Masked interface {
+	goloxi.IOxm
+	GetValue() []byte
+	GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata20Masked) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata20Masked) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata20Masked) GetValueMask() []byte {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata20Masked) SetValueMask(v []byte) {
+	self.ValueMask = v
+}
+
+func (self *NxmTunMetadata20Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata20Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata20Masked, error) {
+	_nxmtunmetadata20masked := &NxmTunMetadata20Masked{Oxm: parent}
+	_nxmtunmetadata20masked.Value = decoder.Read(int(_nxmtunmetadata20masked.TypeLen & 0xFF))
+	_nxmtunmetadata20masked.ValueMask = decoder.Read(int(_nxmtunmetadata20masked.TypeLen & 0xFF))
+	return _nxmtunmetadata20masked, nil
+}
+
+func NewNxmTunMetadata20Masked() *NxmTunMetadata20Masked {
+	obj := &NxmTunMetadata20Masked{
+		Oxm: NewOxm(96760),
+	}
+	return obj
+}
+func (self *NxmTunMetadata20Masked) GetOXMName() string {
+	return "tun_metadata20_masked"
+}
+
+func (self *NxmTunMetadata20Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata20Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata20Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata21 struct {
+	*Oxm
+	Value []byte
+}
+
+type INxmTunMetadata21 interface {
+	goloxi.IOxm
+	GetValue() []byte
+}
+
+func (self *NxmTunMetadata21) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata21) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata21) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata21(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata21, error) {
+	_nxmtunmetadata21 := &NxmTunMetadata21{Oxm: parent}
+	_nxmtunmetadata21.Value = decoder.Read(int(_nxmtunmetadata21.TypeLen & 0xFF))
+	return _nxmtunmetadata21, nil
+}
+
+func NewNxmTunMetadata21() *NxmTunMetadata21 {
+	obj := &NxmTunMetadata21{
+		Oxm: NewOxm(96892),
+	}
+	return obj
+}
+func (self *NxmTunMetadata21) GetOXMName() string {
+	return "tun_metadata21"
+}
+
+func (self *NxmTunMetadata21) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata21) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata21Masked struct {
+	*Oxm
+	Value     []byte
+	ValueMask []byte
+}
+
+type INxmTunMetadata21Masked interface {
+	goloxi.IOxm
+	GetValue() []byte
+	GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata21Masked) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata21Masked) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata21Masked) GetValueMask() []byte {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata21Masked) SetValueMask(v []byte) {
+	self.ValueMask = v
+}
+
+func (self *NxmTunMetadata21Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata21Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata21Masked, error) {
+	_nxmtunmetadata21masked := &NxmTunMetadata21Masked{Oxm: parent}
+	_nxmtunmetadata21masked.Value = decoder.Read(int(_nxmtunmetadata21masked.TypeLen & 0xFF))
+	_nxmtunmetadata21masked.ValueMask = decoder.Read(int(_nxmtunmetadata21masked.TypeLen & 0xFF))
+	return _nxmtunmetadata21masked, nil
+}
+
+func NewNxmTunMetadata21Masked() *NxmTunMetadata21Masked {
+	obj := &NxmTunMetadata21Masked{
+		Oxm: NewOxm(97272),
+	}
+	return obj
+}
+func (self *NxmTunMetadata21Masked) GetOXMName() string {
+	return "tun_metadata21_masked"
+}
+
+func (self *NxmTunMetadata21Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata21Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata21Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata22 struct {
+	*Oxm
+	Value []byte
+}
+
+type INxmTunMetadata22 interface {
+	goloxi.IOxm
+	GetValue() []byte
+}
+
+func (self *NxmTunMetadata22) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata22) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata22) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata22(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata22, error) {
+	_nxmtunmetadata22 := &NxmTunMetadata22{Oxm: parent}
+	_nxmtunmetadata22.Value = decoder.Read(int(_nxmtunmetadata22.TypeLen & 0xFF))
+	return _nxmtunmetadata22, nil
+}
+
+func NewNxmTunMetadata22() *NxmTunMetadata22 {
+	obj := &NxmTunMetadata22{
+		Oxm: NewOxm(97404),
+	}
+	return obj
+}
+func (self *NxmTunMetadata22) GetOXMName() string {
+	return "tun_metadata22"
+}
+
+func (self *NxmTunMetadata22) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata22) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata22Masked struct {
+	*Oxm
+	Value     []byte
+	ValueMask []byte
+}
+
+type INxmTunMetadata22Masked interface {
+	goloxi.IOxm
+	GetValue() []byte
+	GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata22Masked) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata22Masked) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata22Masked) GetValueMask() []byte {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata22Masked) SetValueMask(v []byte) {
+	self.ValueMask = v
+}
+
+func (self *NxmTunMetadata22Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata22Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata22Masked, error) {
+	_nxmtunmetadata22masked := &NxmTunMetadata22Masked{Oxm: parent}
+	_nxmtunmetadata22masked.Value = decoder.Read(int(_nxmtunmetadata22masked.TypeLen & 0xFF))
+	_nxmtunmetadata22masked.ValueMask = decoder.Read(int(_nxmtunmetadata22masked.TypeLen & 0xFF))
+	return _nxmtunmetadata22masked, nil
+}
+
+func NewNxmTunMetadata22Masked() *NxmTunMetadata22Masked {
+	obj := &NxmTunMetadata22Masked{
+		Oxm: NewOxm(97784),
+	}
+	return obj
+}
+func (self *NxmTunMetadata22Masked) GetOXMName() string {
+	return "tun_metadata22_masked"
+}
+
+func (self *NxmTunMetadata22Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata22Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata22Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata23 struct {
+	*Oxm
+	Value []byte
+}
+
+type INxmTunMetadata23 interface {
+	goloxi.IOxm
+	GetValue() []byte
+}
+
+func (self *NxmTunMetadata23) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata23) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata23) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata23(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata23, error) {
+	_nxmtunmetadata23 := &NxmTunMetadata23{Oxm: parent}
+	_nxmtunmetadata23.Value = decoder.Read(int(_nxmtunmetadata23.TypeLen & 0xFF))
+	return _nxmtunmetadata23, nil
+}
+
+func NewNxmTunMetadata23() *NxmTunMetadata23 {
+	obj := &NxmTunMetadata23{
+		Oxm: NewOxm(97916),
+	}
+	return obj
+}
+func (self *NxmTunMetadata23) GetOXMName() string {
+	return "tun_metadata23"
+}
+
+func (self *NxmTunMetadata23) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata23) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata23Masked struct {
+	*Oxm
+	Value     []byte
+	ValueMask []byte
+}
+
+type INxmTunMetadata23Masked interface {
+	goloxi.IOxm
+	GetValue() []byte
+	GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata23Masked) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata23Masked) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata23Masked) GetValueMask() []byte {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata23Masked) SetValueMask(v []byte) {
+	self.ValueMask = v
+}
+
+func (self *NxmTunMetadata23Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata23Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata23Masked, error) {
+	_nxmtunmetadata23masked := &NxmTunMetadata23Masked{Oxm: parent}
+	_nxmtunmetadata23masked.Value = decoder.Read(int(_nxmtunmetadata23masked.TypeLen & 0xFF))
+	_nxmtunmetadata23masked.ValueMask = decoder.Read(int(_nxmtunmetadata23masked.TypeLen & 0xFF))
+	return _nxmtunmetadata23masked, nil
+}
+
+func NewNxmTunMetadata23Masked() *NxmTunMetadata23Masked {
+	obj := &NxmTunMetadata23Masked{
+		Oxm: NewOxm(98296),
+	}
+	return obj
+}
+func (self *NxmTunMetadata23Masked) GetOXMName() string {
+	return "tun_metadata23_masked"
+}
+
+func (self *NxmTunMetadata23Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata23Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata23Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata24 struct {
+	*Oxm
+	Value []byte
+}
+
+type INxmTunMetadata24 interface {
+	goloxi.IOxm
+	GetValue() []byte
+}
+
+func (self *NxmTunMetadata24) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata24) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata24) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata24(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata24, error) {
+	_nxmtunmetadata24 := &NxmTunMetadata24{Oxm: parent}
+	_nxmtunmetadata24.Value = decoder.Read(int(_nxmtunmetadata24.TypeLen & 0xFF))
+	return _nxmtunmetadata24, nil
+}
+
+func NewNxmTunMetadata24() *NxmTunMetadata24 {
+	obj := &NxmTunMetadata24{
+		Oxm: NewOxm(98428),
+	}
+	return obj
+}
+func (self *NxmTunMetadata24) GetOXMName() string {
+	return "tun_metadata24"
+}
+
+func (self *NxmTunMetadata24) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata24) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata24Masked struct {
+	*Oxm
+	Value     []byte
+	ValueMask []byte
+}
+
+type INxmTunMetadata24Masked interface {
+	goloxi.IOxm
+	GetValue() []byte
+	GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata24Masked) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata24Masked) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata24Masked) GetValueMask() []byte {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata24Masked) SetValueMask(v []byte) {
+	self.ValueMask = v
+}
+
+func (self *NxmTunMetadata24Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata24Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata24Masked, error) {
+	_nxmtunmetadata24masked := &NxmTunMetadata24Masked{Oxm: parent}
+	_nxmtunmetadata24masked.Value = decoder.Read(int(_nxmtunmetadata24masked.TypeLen & 0xFF))
+	_nxmtunmetadata24masked.ValueMask = decoder.Read(int(_nxmtunmetadata24masked.TypeLen & 0xFF))
+	return _nxmtunmetadata24masked, nil
+}
+
+func NewNxmTunMetadata24Masked() *NxmTunMetadata24Masked {
+	obj := &NxmTunMetadata24Masked{
+		Oxm: NewOxm(98808),
+	}
+	return obj
+}
+func (self *NxmTunMetadata24Masked) GetOXMName() string {
+	return "tun_metadata24_masked"
+}
+
+func (self *NxmTunMetadata24Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata24Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata24Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata25 struct {
+	*Oxm
+	Value []byte
+}
+
+type INxmTunMetadata25 interface {
+	goloxi.IOxm
+	GetValue() []byte
+}
+
+func (self *NxmTunMetadata25) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata25) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata25) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata25(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata25, error) {
+	_nxmtunmetadata25 := &NxmTunMetadata25{Oxm: parent}
+	_nxmtunmetadata25.Value = decoder.Read(int(_nxmtunmetadata25.TypeLen & 0xFF))
+	return _nxmtunmetadata25, nil
+}
+
+func NewNxmTunMetadata25() *NxmTunMetadata25 {
+	obj := &NxmTunMetadata25{
+		Oxm: NewOxm(98940),
+	}
+	return obj
+}
+func (self *NxmTunMetadata25) GetOXMName() string {
+	return "tun_metadata25"
+}
+
+func (self *NxmTunMetadata25) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata25) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata25Masked struct {
+	*Oxm
+	Value     []byte
+	ValueMask []byte
+}
+
+type INxmTunMetadata25Masked interface {
+	goloxi.IOxm
+	GetValue() []byte
+	GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata25Masked) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata25Masked) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata25Masked) GetValueMask() []byte {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata25Masked) SetValueMask(v []byte) {
+	self.ValueMask = v
+}
+
+func (self *NxmTunMetadata25Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata25Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata25Masked, error) {
+	_nxmtunmetadata25masked := &NxmTunMetadata25Masked{Oxm: parent}
+	_nxmtunmetadata25masked.Value = decoder.Read(int(_nxmtunmetadata25masked.TypeLen & 0xFF))
+	_nxmtunmetadata25masked.ValueMask = decoder.Read(int(_nxmtunmetadata25masked.TypeLen & 0xFF))
+	return _nxmtunmetadata25masked, nil
+}
+
+func NewNxmTunMetadata25Masked() *NxmTunMetadata25Masked {
+	obj := &NxmTunMetadata25Masked{
+		Oxm: NewOxm(99320),
+	}
+	return obj
+}
+func (self *NxmTunMetadata25Masked) GetOXMName() string {
+	return "tun_metadata25_masked"
+}
+
+func (self *NxmTunMetadata25Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata25Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata25Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata26 struct {
+	*Oxm
+	Value []byte
+}
+
+type INxmTunMetadata26 interface {
+	goloxi.IOxm
+	GetValue() []byte
+}
+
+func (self *NxmTunMetadata26) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata26) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata26) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata26(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata26, error) {
+	_nxmtunmetadata26 := &NxmTunMetadata26{Oxm: parent}
+	_nxmtunmetadata26.Value = decoder.Read(int(_nxmtunmetadata26.TypeLen & 0xFF))
+	return _nxmtunmetadata26, nil
+}
+
+func NewNxmTunMetadata26() *NxmTunMetadata26 {
+	obj := &NxmTunMetadata26{
+		Oxm: NewOxm(99452),
+	}
+	return obj
+}
+func (self *NxmTunMetadata26) GetOXMName() string {
+	return "tun_metadata26"
+}
+
+func (self *NxmTunMetadata26) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata26) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata26Masked struct {
+	*Oxm
+	Value     []byte
+	ValueMask []byte
+}
+
+type INxmTunMetadata26Masked interface {
+	goloxi.IOxm
+	GetValue() []byte
+	GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata26Masked) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata26Masked) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata26Masked) GetValueMask() []byte {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata26Masked) SetValueMask(v []byte) {
+	self.ValueMask = v
+}
+
+func (self *NxmTunMetadata26Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata26Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata26Masked, error) {
+	_nxmtunmetadata26masked := &NxmTunMetadata26Masked{Oxm: parent}
+	_nxmtunmetadata26masked.Value = decoder.Read(int(_nxmtunmetadata26masked.TypeLen & 0xFF))
+	_nxmtunmetadata26masked.ValueMask = decoder.Read(int(_nxmtunmetadata26masked.TypeLen & 0xFF))
+	return _nxmtunmetadata26masked, nil
+}
+
+func NewNxmTunMetadata26Masked() *NxmTunMetadata26Masked {
+	obj := &NxmTunMetadata26Masked{
+		Oxm: NewOxm(99832),
+	}
+	return obj
+}
+func (self *NxmTunMetadata26Masked) GetOXMName() string {
+	return "tun_metadata26_masked"
+}
+
+func (self *NxmTunMetadata26Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata26Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata26Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata27 struct {
+	*Oxm
+	Value []byte
+}
+
+type INxmTunMetadata27 interface {
+	goloxi.IOxm
+	GetValue() []byte
+}
+
+func (self *NxmTunMetadata27) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata27) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata27) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata27(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata27, error) {
+	_nxmtunmetadata27 := &NxmTunMetadata27{Oxm: parent}
+	_nxmtunmetadata27.Value = decoder.Read(int(_nxmtunmetadata27.TypeLen & 0xFF))
+	return _nxmtunmetadata27, nil
+}
+
+func NewNxmTunMetadata27() *NxmTunMetadata27 {
+	obj := &NxmTunMetadata27{
+		Oxm: NewOxm(99964),
+	}
+	return obj
+}
+func (self *NxmTunMetadata27) GetOXMName() string {
+	return "tun_metadata27"
+}
+
+func (self *NxmTunMetadata27) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata27) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata27Masked struct {
+	*Oxm
+	Value     []byte
+	ValueMask []byte
+}
+
+type INxmTunMetadata27Masked interface {
+	goloxi.IOxm
+	GetValue() []byte
+	GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata27Masked) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata27Masked) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata27Masked) GetValueMask() []byte {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata27Masked) SetValueMask(v []byte) {
+	self.ValueMask = v
+}
+
+func (self *NxmTunMetadata27Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata27Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata27Masked, error) {
+	_nxmtunmetadata27masked := &NxmTunMetadata27Masked{Oxm: parent}
+	_nxmtunmetadata27masked.Value = decoder.Read(int(_nxmtunmetadata27masked.TypeLen & 0xFF))
+	_nxmtunmetadata27masked.ValueMask = decoder.Read(int(_nxmtunmetadata27masked.TypeLen & 0xFF))
+	return _nxmtunmetadata27masked, nil
+}
+
+func NewNxmTunMetadata27Masked() *NxmTunMetadata27Masked {
+	obj := &NxmTunMetadata27Masked{
+		Oxm: NewOxm(100344),
+	}
+	return obj
+}
+func (self *NxmTunMetadata27Masked) GetOXMName() string {
+	return "tun_metadata27_masked"
+}
+
+func (self *NxmTunMetadata27Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata27Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata27Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata28 struct {
+	*Oxm
+	Value []byte
+}
+
+type INxmTunMetadata28 interface {
+	goloxi.IOxm
+	GetValue() []byte
+}
+
+func (self *NxmTunMetadata28) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata28) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata28) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata28(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata28, error) {
+	_nxmtunmetadata28 := &NxmTunMetadata28{Oxm: parent}
+	_nxmtunmetadata28.Value = decoder.Read(int(_nxmtunmetadata28.TypeLen & 0xFF))
+	return _nxmtunmetadata28, nil
+}
+
+func NewNxmTunMetadata28() *NxmTunMetadata28 {
+	obj := &NxmTunMetadata28{
+		Oxm: NewOxm(100476),
+	}
+	return obj
+}
+func (self *NxmTunMetadata28) GetOXMName() string {
+	return "tun_metadata28"
+}
+
+func (self *NxmTunMetadata28) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata28) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata28Masked struct {
+	*Oxm
+	Value     []byte
+	ValueMask []byte
+}
+
+type INxmTunMetadata28Masked interface {
+	goloxi.IOxm
+	GetValue() []byte
+	GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata28Masked) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata28Masked) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata28Masked) GetValueMask() []byte {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata28Masked) SetValueMask(v []byte) {
+	self.ValueMask = v
+}
+
+func (self *NxmTunMetadata28Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata28Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata28Masked, error) {
+	_nxmtunmetadata28masked := &NxmTunMetadata28Masked{Oxm: parent}
+	_nxmtunmetadata28masked.Value = decoder.Read(int(_nxmtunmetadata28masked.TypeLen & 0xFF))
+	_nxmtunmetadata28masked.ValueMask = decoder.Read(int(_nxmtunmetadata28masked.TypeLen & 0xFF))
+	return _nxmtunmetadata28masked, nil
+}
+
+func NewNxmTunMetadata28Masked() *NxmTunMetadata28Masked {
+	obj := &NxmTunMetadata28Masked{
+		Oxm: NewOxm(100856),
+	}
+	return obj
+}
+func (self *NxmTunMetadata28Masked) GetOXMName() string {
+	return "tun_metadata28_masked"
+}
+
+func (self *NxmTunMetadata28Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata28Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata28Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata29 struct {
+	*Oxm
+	Value []byte
+}
+
+type INxmTunMetadata29 interface {
+	goloxi.IOxm
+	GetValue() []byte
+}
+
+func (self *NxmTunMetadata29) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata29) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata29) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata29(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata29, error) {
+	_nxmtunmetadata29 := &NxmTunMetadata29{Oxm: parent}
+	_nxmtunmetadata29.Value = decoder.Read(int(_nxmtunmetadata29.TypeLen & 0xFF))
+	return _nxmtunmetadata29, nil
+}
+
+func NewNxmTunMetadata29() *NxmTunMetadata29 {
+	obj := &NxmTunMetadata29{
+		Oxm: NewOxm(100988),
+	}
+	return obj
+}
+func (self *NxmTunMetadata29) GetOXMName() string {
+	return "tun_metadata29"
+}
+
+func (self *NxmTunMetadata29) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata29) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata29Masked struct {
+	*Oxm
+	Value     []byte
+	ValueMask []byte
+}
+
+type INxmTunMetadata29Masked interface {
+	goloxi.IOxm
+	GetValue() []byte
+	GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata29Masked) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata29Masked) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata29Masked) GetValueMask() []byte {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata29Masked) SetValueMask(v []byte) {
+	self.ValueMask = v
+}
+
+func (self *NxmTunMetadata29Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata29Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata29Masked, error) {
+	_nxmtunmetadata29masked := &NxmTunMetadata29Masked{Oxm: parent}
+	_nxmtunmetadata29masked.Value = decoder.Read(int(_nxmtunmetadata29masked.TypeLen & 0xFF))
+	_nxmtunmetadata29masked.ValueMask = decoder.Read(int(_nxmtunmetadata29masked.TypeLen & 0xFF))
+	return _nxmtunmetadata29masked, nil
+}
+
+func NewNxmTunMetadata29Masked() *NxmTunMetadata29Masked {
+	obj := &NxmTunMetadata29Masked{
+		Oxm: NewOxm(101368),
+	}
+	return obj
+}
+func (self *NxmTunMetadata29Masked) GetOXMName() string {
+	return "tun_metadata29_masked"
+}
+
+func (self *NxmTunMetadata29Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata29Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata29Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata2Masked struct {
+	*Oxm
+	Value     []byte
+	ValueMask []byte
+}
+
+type INxmTunMetadata2Masked interface {
+	goloxi.IOxm
+	GetValue() []byte
+	GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata2Masked) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata2Masked) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata2Masked) GetValueMask() []byte {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata2Masked) SetValueMask(v []byte) {
+	self.ValueMask = v
+}
+
+func (self *NxmTunMetadata2Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata2Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata2Masked, error) {
+	_nxmtunmetadata2masked := &NxmTunMetadata2Masked{Oxm: parent}
+	_nxmtunmetadata2masked.Value = decoder.Read(int(_nxmtunmetadata2masked.TypeLen & 0xFF))
+	_nxmtunmetadata2masked.ValueMask = decoder.Read(int(_nxmtunmetadata2masked.TypeLen & 0xFF))
+	return _nxmtunmetadata2masked, nil
+}
+
+func NewNxmTunMetadata2Masked() *NxmTunMetadata2Masked {
+	obj := &NxmTunMetadata2Masked{
+		Oxm: NewOxm(87544),
+	}
+	return obj
+}
+func (self *NxmTunMetadata2Masked) GetOXMName() string {
+	return "tun_metadata2_masked"
+}
+
+func (self *NxmTunMetadata2Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata2Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata2Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata3 struct {
+	*Oxm
+	Value []byte
+}
+
+type INxmTunMetadata3 interface {
+	goloxi.IOxm
+	GetValue() []byte
+}
+
+func (self *NxmTunMetadata3) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata3) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata3) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata3(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata3, error) {
+	_nxmtunmetadata3 := &NxmTunMetadata3{Oxm: parent}
+	_nxmtunmetadata3.Value = decoder.Read(int(_nxmtunmetadata3.TypeLen & 0xFF))
+	return _nxmtunmetadata3, nil
+}
+
+func NewNxmTunMetadata3() *NxmTunMetadata3 {
+	obj := &NxmTunMetadata3{
+		Oxm: NewOxm(87676),
+	}
+	return obj
+}
+func (self *NxmTunMetadata3) GetOXMName() string {
+	return "tun_metadata3"
+}
+
+func (self *NxmTunMetadata3) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata3) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata30 struct {
+	*Oxm
+	Value []byte
+}
+
+type INxmTunMetadata30 interface {
+	goloxi.IOxm
+	GetValue() []byte
+}
+
+func (self *NxmTunMetadata30) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata30) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata30) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata30(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata30, error) {
+	_nxmtunmetadata30 := &NxmTunMetadata30{Oxm: parent}
+	_nxmtunmetadata30.Value = decoder.Read(int(_nxmtunmetadata30.TypeLen & 0xFF))
+	return _nxmtunmetadata30, nil
+}
+
+func NewNxmTunMetadata30() *NxmTunMetadata30 {
+	obj := &NxmTunMetadata30{
+		Oxm: NewOxm(101500),
+	}
+	return obj
+}
+func (self *NxmTunMetadata30) GetOXMName() string {
+	return "tun_metadata30"
+}
+
+func (self *NxmTunMetadata30) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata30) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata30Masked struct {
+	*Oxm
+	Value     []byte
+	ValueMask []byte
+}
+
+type INxmTunMetadata30Masked interface {
+	goloxi.IOxm
+	GetValue() []byte
+	GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata30Masked) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata30Masked) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata30Masked) GetValueMask() []byte {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata30Masked) SetValueMask(v []byte) {
+	self.ValueMask = v
+}
+
+func (self *NxmTunMetadata30Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata30Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata30Masked, error) {
+	_nxmtunmetadata30masked := &NxmTunMetadata30Masked{Oxm: parent}
+	_nxmtunmetadata30masked.Value = decoder.Read(int(_nxmtunmetadata30masked.TypeLen & 0xFF))
+	_nxmtunmetadata30masked.ValueMask = decoder.Read(int(_nxmtunmetadata30masked.TypeLen & 0xFF))
+	return _nxmtunmetadata30masked, nil
+}
+
+func NewNxmTunMetadata30Masked() *NxmTunMetadata30Masked {
+	obj := &NxmTunMetadata30Masked{
+		Oxm: NewOxm(101880),
+	}
+	return obj
+}
+func (self *NxmTunMetadata30Masked) GetOXMName() string {
+	return "tun_metadata30_masked"
+}
+
+func (self *NxmTunMetadata30Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata30Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata30Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata31 struct {
+	*Oxm
+	Value []byte
+}
+
+type INxmTunMetadata31 interface {
+	goloxi.IOxm
+	GetValue() []byte
+}
+
+func (self *NxmTunMetadata31) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata31) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata31) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata31(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata31, error) {
+	_nxmtunmetadata31 := &NxmTunMetadata31{Oxm: parent}
+	_nxmtunmetadata31.Value = decoder.Read(int(_nxmtunmetadata31.TypeLen & 0xFF))
+	return _nxmtunmetadata31, nil
+}
+
+func NewNxmTunMetadata31() *NxmTunMetadata31 {
+	obj := &NxmTunMetadata31{
+		Oxm: NewOxm(102012),
+	}
+	return obj
+}
+func (self *NxmTunMetadata31) GetOXMName() string {
+	return "tun_metadata31"
+}
+
+func (self *NxmTunMetadata31) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata31) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata31Masked struct {
+	*Oxm
+	Value     []byte
+	ValueMask []byte
+}
+
+type INxmTunMetadata31Masked interface {
+	goloxi.IOxm
+	GetValue() []byte
+	GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata31Masked) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata31Masked) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata31Masked) GetValueMask() []byte {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata31Masked) SetValueMask(v []byte) {
+	self.ValueMask = v
+}
+
+func (self *NxmTunMetadata31Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata31Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata31Masked, error) {
+	_nxmtunmetadata31masked := &NxmTunMetadata31Masked{Oxm: parent}
+	_nxmtunmetadata31masked.Value = decoder.Read(int(_nxmtunmetadata31masked.TypeLen & 0xFF))
+	_nxmtunmetadata31masked.ValueMask = decoder.Read(int(_nxmtunmetadata31masked.TypeLen & 0xFF))
+	return _nxmtunmetadata31masked, nil
+}
+
+func NewNxmTunMetadata31Masked() *NxmTunMetadata31Masked {
+	obj := &NxmTunMetadata31Masked{
+		Oxm: NewOxm(102392),
+	}
+	return obj
+}
+func (self *NxmTunMetadata31Masked) GetOXMName() string {
+	return "tun_metadata31_masked"
+}
+
+func (self *NxmTunMetadata31Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata31Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata31Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata32 struct {
+	*Oxm
+	Value []byte
+}
+
+type INxmTunMetadata32 interface {
+	goloxi.IOxm
+	GetValue() []byte
+}
+
+func (self *NxmTunMetadata32) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata32) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata32) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata32(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata32, error) {
+	_nxmtunmetadata32 := &NxmTunMetadata32{Oxm: parent}
+	_nxmtunmetadata32.Value = decoder.Read(int(_nxmtunmetadata32.TypeLen & 0xFF))
+	return _nxmtunmetadata32, nil
+}
+
+func NewNxmTunMetadata32() *NxmTunMetadata32 {
+	obj := &NxmTunMetadata32{
+		Oxm: NewOxm(102524),
+	}
+	return obj
+}
+func (self *NxmTunMetadata32) GetOXMName() string {
+	return "tun_metadata32"
+}
+
+func (self *NxmTunMetadata32) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata32) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata32Masked struct {
+	*Oxm
+	Value     []byte
+	ValueMask []byte
+}
+
+type INxmTunMetadata32Masked interface {
+	goloxi.IOxm
+	GetValue() []byte
+	GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata32Masked) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata32Masked) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata32Masked) GetValueMask() []byte {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata32Masked) SetValueMask(v []byte) {
+	self.ValueMask = v
+}
+
+func (self *NxmTunMetadata32Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata32Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata32Masked, error) {
+	_nxmtunmetadata32masked := &NxmTunMetadata32Masked{Oxm: parent}
+	_nxmtunmetadata32masked.Value = decoder.Read(int(_nxmtunmetadata32masked.TypeLen & 0xFF))
+	_nxmtunmetadata32masked.ValueMask = decoder.Read(int(_nxmtunmetadata32masked.TypeLen & 0xFF))
+	return _nxmtunmetadata32masked, nil
+}
+
+func NewNxmTunMetadata32Masked() *NxmTunMetadata32Masked {
+	obj := &NxmTunMetadata32Masked{
+		Oxm: NewOxm(102904),
+	}
+	return obj
+}
+func (self *NxmTunMetadata32Masked) GetOXMName() string {
+	return "tun_metadata32_masked"
+}
+
+func (self *NxmTunMetadata32Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata32Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata32Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata33 struct {
+	*Oxm
+	Value []byte
+}
+
+type INxmTunMetadata33 interface {
+	goloxi.IOxm
+	GetValue() []byte
+}
+
+func (self *NxmTunMetadata33) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata33) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata33) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata33(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata33, error) {
+	_nxmtunmetadata33 := &NxmTunMetadata33{Oxm: parent}
+	_nxmtunmetadata33.Value = decoder.Read(int(_nxmtunmetadata33.TypeLen & 0xFF))
+	return _nxmtunmetadata33, nil
+}
+
+func NewNxmTunMetadata33() *NxmTunMetadata33 {
+	obj := &NxmTunMetadata33{
+		Oxm: NewOxm(103036),
+	}
+	return obj
+}
+func (self *NxmTunMetadata33) GetOXMName() string {
+	return "tun_metadata33"
+}
+
+func (self *NxmTunMetadata33) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata33) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata33Masked struct {
+	*Oxm
+	Value     []byte
+	ValueMask []byte
+}
+
+type INxmTunMetadata33Masked interface {
+	goloxi.IOxm
+	GetValue() []byte
+	GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata33Masked) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata33Masked) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata33Masked) GetValueMask() []byte {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata33Masked) SetValueMask(v []byte) {
+	self.ValueMask = v
+}
+
+func (self *NxmTunMetadata33Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata33Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata33Masked, error) {
+	_nxmtunmetadata33masked := &NxmTunMetadata33Masked{Oxm: parent}
+	_nxmtunmetadata33masked.Value = decoder.Read(int(_nxmtunmetadata33masked.TypeLen & 0xFF))
+	_nxmtunmetadata33masked.ValueMask = decoder.Read(int(_nxmtunmetadata33masked.TypeLen & 0xFF))
+	return _nxmtunmetadata33masked, nil
+}
+
+func NewNxmTunMetadata33Masked() *NxmTunMetadata33Masked {
+	obj := &NxmTunMetadata33Masked{
+		Oxm: NewOxm(103416),
+	}
+	return obj
+}
+func (self *NxmTunMetadata33Masked) GetOXMName() string {
+	return "tun_metadata33_masked"
+}
+
+func (self *NxmTunMetadata33Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata33Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata33Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata34 struct {
+	*Oxm
+	Value []byte
+}
+
+type INxmTunMetadata34 interface {
+	goloxi.IOxm
+	GetValue() []byte
+}
+
+func (self *NxmTunMetadata34) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata34) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata34) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata34(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata34, error) {
+	_nxmtunmetadata34 := &NxmTunMetadata34{Oxm: parent}
+	_nxmtunmetadata34.Value = decoder.Read(int(_nxmtunmetadata34.TypeLen & 0xFF))
+	return _nxmtunmetadata34, nil
+}
+
+func NewNxmTunMetadata34() *NxmTunMetadata34 {
+	obj := &NxmTunMetadata34{
+		Oxm: NewOxm(103548),
+	}
+	return obj
+}
+func (self *NxmTunMetadata34) GetOXMName() string {
+	return "tun_metadata34"
+}
+
+func (self *NxmTunMetadata34) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata34) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata34Masked struct {
+	*Oxm
+	Value     []byte
+	ValueMask []byte
+}
+
+type INxmTunMetadata34Masked interface {
+	goloxi.IOxm
+	GetValue() []byte
+	GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata34Masked) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata34Masked) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata34Masked) GetValueMask() []byte {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata34Masked) SetValueMask(v []byte) {
+	self.ValueMask = v
+}
+
+func (self *NxmTunMetadata34Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata34Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata34Masked, error) {
+	_nxmtunmetadata34masked := &NxmTunMetadata34Masked{Oxm: parent}
+	_nxmtunmetadata34masked.Value = decoder.Read(int(_nxmtunmetadata34masked.TypeLen & 0xFF))
+	_nxmtunmetadata34masked.ValueMask = decoder.Read(int(_nxmtunmetadata34masked.TypeLen & 0xFF))
+	return _nxmtunmetadata34masked, nil
+}
+
+func NewNxmTunMetadata34Masked() *NxmTunMetadata34Masked {
+	obj := &NxmTunMetadata34Masked{
+		Oxm: NewOxm(103928),
+	}
+	return obj
+}
+func (self *NxmTunMetadata34Masked) GetOXMName() string {
+	return "tun_metadata34_masked"
+}
+
+func (self *NxmTunMetadata34Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata34Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata34Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata35 struct {
+	*Oxm
+	Value []byte
+}
+
+type INxmTunMetadata35 interface {
+	goloxi.IOxm
+	GetValue() []byte
+}
+
+func (self *NxmTunMetadata35) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata35) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata35) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata35(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata35, error) {
+	_nxmtunmetadata35 := &NxmTunMetadata35{Oxm: parent}
+	_nxmtunmetadata35.Value = decoder.Read(int(_nxmtunmetadata35.TypeLen & 0xFF))
+	return _nxmtunmetadata35, nil
+}
+
+func NewNxmTunMetadata35() *NxmTunMetadata35 {
+	obj := &NxmTunMetadata35{
+		Oxm: NewOxm(104060),
+	}
+	return obj
+}
+func (self *NxmTunMetadata35) GetOXMName() string {
+	return "tun_metadata35"
+}
+
+func (self *NxmTunMetadata35) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata35) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata35Masked struct {
+	*Oxm
+	Value     []byte
+	ValueMask []byte
+}
+
+type INxmTunMetadata35Masked interface {
+	goloxi.IOxm
+	GetValue() []byte
+	GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata35Masked) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata35Masked) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata35Masked) GetValueMask() []byte {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata35Masked) SetValueMask(v []byte) {
+	self.ValueMask = v
+}
+
+func (self *NxmTunMetadata35Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata35Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata35Masked, error) {
+	_nxmtunmetadata35masked := &NxmTunMetadata35Masked{Oxm: parent}
+	_nxmtunmetadata35masked.Value = decoder.Read(int(_nxmtunmetadata35masked.TypeLen & 0xFF))
+	_nxmtunmetadata35masked.ValueMask = decoder.Read(int(_nxmtunmetadata35masked.TypeLen & 0xFF))
+	return _nxmtunmetadata35masked, nil
+}
+
+func NewNxmTunMetadata35Masked() *NxmTunMetadata35Masked {
+	obj := &NxmTunMetadata35Masked{
+		Oxm: NewOxm(104440),
+	}
+	return obj
+}
+func (self *NxmTunMetadata35Masked) GetOXMName() string {
+	return "tun_metadata35_masked"
+}
+
+func (self *NxmTunMetadata35Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata35Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata35Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata36 struct {
+	*Oxm
+	Value []byte
+}
+
+type INxmTunMetadata36 interface {
+	goloxi.IOxm
+	GetValue() []byte
+}
+
+func (self *NxmTunMetadata36) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata36) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata36) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata36(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata36, error) {
+	_nxmtunmetadata36 := &NxmTunMetadata36{Oxm: parent}
+	_nxmtunmetadata36.Value = decoder.Read(int(_nxmtunmetadata36.TypeLen & 0xFF))
+	return _nxmtunmetadata36, nil
+}
+
+func NewNxmTunMetadata36() *NxmTunMetadata36 {
+	obj := &NxmTunMetadata36{
+		Oxm: NewOxm(104572),
+	}
+	return obj
+}
+func (self *NxmTunMetadata36) GetOXMName() string {
+	return "tun_metadata36"
+}
+
+func (self *NxmTunMetadata36) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata36) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata36Masked struct {
+	*Oxm
+	Value     []byte
+	ValueMask []byte
+}
+
+type INxmTunMetadata36Masked interface {
+	goloxi.IOxm
+	GetValue() []byte
+	GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata36Masked) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata36Masked) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata36Masked) GetValueMask() []byte {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata36Masked) SetValueMask(v []byte) {
+	self.ValueMask = v
+}
+
+func (self *NxmTunMetadata36Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata36Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata36Masked, error) {
+	_nxmtunmetadata36masked := &NxmTunMetadata36Masked{Oxm: parent}
+	_nxmtunmetadata36masked.Value = decoder.Read(int(_nxmtunmetadata36masked.TypeLen & 0xFF))
+	_nxmtunmetadata36masked.ValueMask = decoder.Read(int(_nxmtunmetadata36masked.TypeLen & 0xFF))
+	return _nxmtunmetadata36masked, nil
+}
+
+func NewNxmTunMetadata36Masked() *NxmTunMetadata36Masked {
+	obj := &NxmTunMetadata36Masked{
+		Oxm: NewOxm(104952),
+	}
+	return obj
+}
+func (self *NxmTunMetadata36Masked) GetOXMName() string {
+	return "tun_metadata36_masked"
+}
+
+func (self *NxmTunMetadata36Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata36Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata36Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata37 struct {
+	*Oxm
+	Value []byte
+}
+
+type INxmTunMetadata37 interface {
+	goloxi.IOxm
+	GetValue() []byte
+}
+
+func (self *NxmTunMetadata37) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata37) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata37) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata37(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata37, error) {
+	_nxmtunmetadata37 := &NxmTunMetadata37{Oxm: parent}
+	_nxmtunmetadata37.Value = decoder.Read(int(_nxmtunmetadata37.TypeLen & 0xFF))
+	return _nxmtunmetadata37, nil
+}
+
+func NewNxmTunMetadata37() *NxmTunMetadata37 {
+	obj := &NxmTunMetadata37{
+		Oxm: NewOxm(105084),
+	}
+	return obj
+}
+func (self *NxmTunMetadata37) GetOXMName() string {
+	return "tun_metadata37"
+}
+
+func (self *NxmTunMetadata37) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata37) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata37Masked struct {
+	*Oxm
+	Value     []byte
+	ValueMask []byte
+}
+
+type INxmTunMetadata37Masked interface {
+	goloxi.IOxm
+	GetValue() []byte
+	GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata37Masked) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata37Masked) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata37Masked) GetValueMask() []byte {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata37Masked) SetValueMask(v []byte) {
+	self.ValueMask = v
+}
+
+func (self *NxmTunMetadata37Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata37Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata37Masked, error) {
+	_nxmtunmetadata37masked := &NxmTunMetadata37Masked{Oxm: parent}
+	_nxmtunmetadata37masked.Value = decoder.Read(int(_nxmtunmetadata37masked.TypeLen & 0xFF))
+	_nxmtunmetadata37masked.ValueMask = decoder.Read(int(_nxmtunmetadata37masked.TypeLen & 0xFF))
+	return _nxmtunmetadata37masked, nil
+}
+
+func NewNxmTunMetadata37Masked() *NxmTunMetadata37Masked {
+	obj := &NxmTunMetadata37Masked{
+		Oxm: NewOxm(105464),
+	}
+	return obj
+}
+func (self *NxmTunMetadata37Masked) GetOXMName() string {
+	return "tun_metadata37_masked"
+}
+
+func (self *NxmTunMetadata37Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata37Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata37Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata38 struct {
+	*Oxm
+	Value []byte
+}
+
+type INxmTunMetadata38 interface {
+	goloxi.IOxm
+	GetValue() []byte
+}
+
+func (self *NxmTunMetadata38) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata38) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata38) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata38(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata38, error) {
+	_nxmtunmetadata38 := &NxmTunMetadata38{Oxm: parent}
+	_nxmtunmetadata38.Value = decoder.Read(int(_nxmtunmetadata38.TypeLen & 0xFF))
+	return _nxmtunmetadata38, nil
+}
+
+func NewNxmTunMetadata38() *NxmTunMetadata38 {
+	obj := &NxmTunMetadata38{
+		Oxm: NewOxm(105596),
+	}
+	return obj
+}
+func (self *NxmTunMetadata38) GetOXMName() string {
+	return "tun_metadata38"
+}
+
+func (self *NxmTunMetadata38) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata38) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata38Masked struct {
+	*Oxm
+	Value     []byte
+	ValueMask []byte
+}
+
+type INxmTunMetadata38Masked interface {
+	goloxi.IOxm
+	GetValue() []byte
+	GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata38Masked) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata38Masked) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata38Masked) GetValueMask() []byte {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata38Masked) SetValueMask(v []byte) {
+	self.ValueMask = v
+}
+
+func (self *NxmTunMetadata38Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata38Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata38Masked, error) {
+	_nxmtunmetadata38masked := &NxmTunMetadata38Masked{Oxm: parent}
+	_nxmtunmetadata38masked.Value = decoder.Read(int(_nxmtunmetadata38masked.TypeLen & 0xFF))
+	_nxmtunmetadata38masked.ValueMask = decoder.Read(int(_nxmtunmetadata38masked.TypeLen & 0xFF))
+	return _nxmtunmetadata38masked, nil
+}
+
+func NewNxmTunMetadata38Masked() *NxmTunMetadata38Masked {
+	obj := &NxmTunMetadata38Masked{
+		Oxm: NewOxm(105976),
+	}
+	return obj
+}
+func (self *NxmTunMetadata38Masked) GetOXMName() string {
+	return "tun_metadata38_masked"
+}
+
+func (self *NxmTunMetadata38Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata38Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata38Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata39 struct {
+	*Oxm
+	Value []byte
+}
+
+type INxmTunMetadata39 interface {
+	goloxi.IOxm
+	GetValue() []byte
+}
+
+func (self *NxmTunMetadata39) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata39) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata39) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata39(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata39, error) {
+	_nxmtunmetadata39 := &NxmTunMetadata39{Oxm: parent}
+	_nxmtunmetadata39.Value = decoder.Read(int(_nxmtunmetadata39.TypeLen & 0xFF))
+	return _nxmtunmetadata39, nil
+}
+
+func NewNxmTunMetadata39() *NxmTunMetadata39 {
+	obj := &NxmTunMetadata39{
+		Oxm: NewOxm(106108),
+	}
+	return obj
+}
+func (self *NxmTunMetadata39) GetOXMName() string {
+	return "tun_metadata39"
+}
+
+func (self *NxmTunMetadata39) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata39) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata39Masked struct {
+	*Oxm
+	Value     []byte
+	ValueMask []byte
+}
+
+type INxmTunMetadata39Masked interface {
+	goloxi.IOxm
+	GetValue() []byte
+	GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata39Masked) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata39Masked) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata39Masked) GetValueMask() []byte {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata39Masked) SetValueMask(v []byte) {
+	self.ValueMask = v
+}
+
+func (self *NxmTunMetadata39Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata39Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata39Masked, error) {
+	_nxmtunmetadata39masked := &NxmTunMetadata39Masked{Oxm: parent}
+	_nxmtunmetadata39masked.Value = decoder.Read(int(_nxmtunmetadata39masked.TypeLen & 0xFF))
+	_nxmtunmetadata39masked.ValueMask = decoder.Read(int(_nxmtunmetadata39masked.TypeLen & 0xFF))
+	return _nxmtunmetadata39masked, nil
+}
+
+func NewNxmTunMetadata39Masked() *NxmTunMetadata39Masked {
+	obj := &NxmTunMetadata39Masked{
+		Oxm: NewOxm(106488),
+	}
+	return obj
+}
+func (self *NxmTunMetadata39Masked) GetOXMName() string {
+	return "tun_metadata39_masked"
+}
+
+func (self *NxmTunMetadata39Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata39Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata39Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata3Masked struct {
+	*Oxm
+	Value     []byte
+	ValueMask []byte
+}
+
+type INxmTunMetadata3Masked interface {
+	goloxi.IOxm
+	GetValue() []byte
+	GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata3Masked) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata3Masked) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata3Masked) GetValueMask() []byte {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata3Masked) SetValueMask(v []byte) {
+	self.ValueMask = v
+}
+
+func (self *NxmTunMetadata3Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata3Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata3Masked, error) {
+	_nxmtunmetadata3masked := &NxmTunMetadata3Masked{Oxm: parent}
+	_nxmtunmetadata3masked.Value = decoder.Read(int(_nxmtunmetadata3masked.TypeLen & 0xFF))
+	_nxmtunmetadata3masked.ValueMask = decoder.Read(int(_nxmtunmetadata3masked.TypeLen & 0xFF))
+	return _nxmtunmetadata3masked, nil
+}
+
+func NewNxmTunMetadata3Masked() *NxmTunMetadata3Masked {
+	obj := &NxmTunMetadata3Masked{
+		Oxm: NewOxm(88056),
+	}
+	return obj
+}
+func (self *NxmTunMetadata3Masked) GetOXMName() string {
+	return "tun_metadata3_masked"
+}
+
+func (self *NxmTunMetadata3Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata3Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata3Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata4 struct {
+	*Oxm
+	Value []byte
+}
+
+type INxmTunMetadata4 interface {
+	goloxi.IOxm
+	GetValue() []byte
+}
+
+func (self *NxmTunMetadata4) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata4) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata4) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata4(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata4, error) {
+	_nxmtunmetadata4 := &NxmTunMetadata4{Oxm: parent}
+	_nxmtunmetadata4.Value = decoder.Read(int(_nxmtunmetadata4.TypeLen & 0xFF))
+	return _nxmtunmetadata4, nil
+}
+
+func NewNxmTunMetadata4() *NxmTunMetadata4 {
+	obj := &NxmTunMetadata4{
+		Oxm: NewOxm(88188),
+	}
+	return obj
+}
+func (self *NxmTunMetadata4) GetOXMName() string {
+	return "tun_metadata4"
+}
+
+func (self *NxmTunMetadata4) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata4) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata40 struct {
+	*Oxm
+	Value []byte
+}
+
+type INxmTunMetadata40 interface {
+	goloxi.IOxm
+	GetValue() []byte
+}
+
+func (self *NxmTunMetadata40) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata40) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata40) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata40(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata40, error) {
+	_nxmtunmetadata40 := &NxmTunMetadata40{Oxm: parent}
+	_nxmtunmetadata40.Value = decoder.Read(int(_nxmtunmetadata40.TypeLen & 0xFF))
+	return _nxmtunmetadata40, nil
+}
+
+func NewNxmTunMetadata40() *NxmTunMetadata40 {
+	obj := &NxmTunMetadata40{
+		Oxm: NewOxm(106620),
+	}
+	return obj
+}
+func (self *NxmTunMetadata40) GetOXMName() string {
+	return "tun_metadata40"
+}
+
+func (self *NxmTunMetadata40) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata40) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata40Masked struct {
+	*Oxm
+	Value     []byte
+	ValueMask []byte
+}
+
+type INxmTunMetadata40Masked interface {
+	goloxi.IOxm
+	GetValue() []byte
+	GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata40Masked) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata40Masked) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata40Masked) GetValueMask() []byte {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata40Masked) SetValueMask(v []byte) {
+	self.ValueMask = v
+}
+
+func (self *NxmTunMetadata40Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata40Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata40Masked, error) {
+	_nxmtunmetadata40masked := &NxmTunMetadata40Masked{Oxm: parent}
+	_nxmtunmetadata40masked.Value = decoder.Read(int(_nxmtunmetadata40masked.TypeLen & 0xFF))
+	_nxmtunmetadata40masked.ValueMask = decoder.Read(int(_nxmtunmetadata40masked.TypeLen & 0xFF))
+	return _nxmtunmetadata40masked, nil
+}
+
+func NewNxmTunMetadata40Masked() *NxmTunMetadata40Masked {
+	obj := &NxmTunMetadata40Masked{
+		Oxm: NewOxm(107000),
+	}
+	return obj
+}
+func (self *NxmTunMetadata40Masked) GetOXMName() string {
+	return "tun_metadata40_masked"
+}
+
+func (self *NxmTunMetadata40Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata40Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata40Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata41 struct {
+	*Oxm
+	Value []byte
+}
+
+type INxmTunMetadata41 interface {
+	goloxi.IOxm
+	GetValue() []byte
+}
+
+func (self *NxmTunMetadata41) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata41) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata41) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata41(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata41, error) {
+	_nxmtunmetadata41 := &NxmTunMetadata41{Oxm: parent}
+	_nxmtunmetadata41.Value = decoder.Read(int(_nxmtunmetadata41.TypeLen & 0xFF))
+	return _nxmtunmetadata41, nil
+}
+
+func NewNxmTunMetadata41() *NxmTunMetadata41 {
+	obj := &NxmTunMetadata41{
+		Oxm: NewOxm(107132),
+	}
+	return obj
+}
+func (self *NxmTunMetadata41) GetOXMName() string {
+	return "tun_metadata41"
+}
+
+func (self *NxmTunMetadata41) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata41) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata41Masked struct {
+	*Oxm
+	Value     []byte
+	ValueMask []byte
+}
+
+type INxmTunMetadata41Masked interface {
+	goloxi.IOxm
+	GetValue() []byte
+	GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata41Masked) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata41Masked) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata41Masked) GetValueMask() []byte {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata41Masked) SetValueMask(v []byte) {
+	self.ValueMask = v
+}
+
+func (self *NxmTunMetadata41Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata41Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata41Masked, error) {
+	_nxmtunmetadata41masked := &NxmTunMetadata41Masked{Oxm: parent}
+	_nxmtunmetadata41masked.Value = decoder.Read(int(_nxmtunmetadata41masked.TypeLen & 0xFF))
+	_nxmtunmetadata41masked.ValueMask = decoder.Read(int(_nxmtunmetadata41masked.TypeLen & 0xFF))
+	return _nxmtunmetadata41masked, nil
+}
+
+func NewNxmTunMetadata41Masked() *NxmTunMetadata41Masked {
+	obj := &NxmTunMetadata41Masked{
+		Oxm: NewOxm(107512),
+	}
+	return obj
+}
+func (self *NxmTunMetadata41Masked) GetOXMName() string {
+	return "tun_metadata41_masked"
+}
+
+func (self *NxmTunMetadata41Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata41Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata41Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata42 struct {
+	*Oxm
+	Value []byte
+}
+
+type INxmTunMetadata42 interface {
+	goloxi.IOxm
+	GetValue() []byte
+}
+
+func (self *NxmTunMetadata42) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata42) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata42) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata42(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata42, error) {
+	_nxmtunmetadata42 := &NxmTunMetadata42{Oxm: parent}
+	_nxmtunmetadata42.Value = decoder.Read(int(_nxmtunmetadata42.TypeLen & 0xFF))
+	return _nxmtunmetadata42, nil
+}
+
+func NewNxmTunMetadata42() *NxmTunMetadata42 {
+	obj := &NxmTunMetadata42{
+		Oxm: NewOxm(107644),
+	}
+	return obj
+}
+func (self *NxmTunMetadata42) GetOXMName() string {
+	return "tun_metadata42"
+}
+
+func (self *NxmTunMetadata42) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata42) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata42Masked struct {
+	*Oxm
+	Value     []byte
+	ValueMask []byte
+}
+
+type INxmTunMetadata42Masked interface {
+	goloxi.IOxm
+	GetValue() []byte
+	GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata42Masked) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata42Masked) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata42Masked) GetValueMask() []byte {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata42Masked) SetValueMask(v []byte) {
+	self.ValueMask = v
+}
+
+func (self *NxmTunMetadata42Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata42Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata42Masked, error) {
+	_nxmtunmetadata42masked := &NxmTunMetadata42Masked{Oxm: parent}
+	_nxmtunmetadata42masked.Value = decoder.Read(int(_nxmtunmetadata42masked.TypeLen & 0xFF))
+	_nxmtunmetadata42masked.ValueMask = decoder.Read(int(_nxmtunmetadata42masked.TypeLen & 0xFF))
+	return _nxmtunmetadata42masked, nil
+}
+
+func NewNxmTunMetadata42Masked() *NxmTunMetadata42Masked {
+	obj := &NxmTunMetadata42Masked{
+		Oxm: NewOxm(108024),
+	}
+	return obj
+}
+func (self *NxmTunMetadata42Masked) GetOXMName() string {
+	return "tun_metadata42_masked"
+}
+
+func (self *NxmTunMetadata42Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata42Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata42Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata43 struct {
+	*Oxm
+	Value []byte
+}
+
+type INxmTunMetadata43 interface {
+	goloxi.IOxm
+	GetValue() []byte
+}
+
+func (self *NxmTunMetadata43) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata43) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata43) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata43(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata43, error) {
+	_nxmtunmetadata43 := &NxmTunMetadata43{Oxm: parent}
+	_nxmtunmetadata43.Value = decoder.Read(int(_nxmtunmetadata43.TypeLen & 0xFF))
+	return _nxmtunmetadata43, nil
+}
+
+func NewNxmTunMetadata43() *NxmTunMetadata43 {
+	obj := &NxmTunMetadata43{
+		Oxm: NewOxm(108156),
+	}
+	return obj
+}
+func (self *NxmTunMetadata43) GetOXMName() string {
+	return "tun_metadata43"
+}
+
+func (self *NxmTunMetadata43) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata43) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata43Masked struct {
+	*Oxm
+	Value     []byte
+	ValueMask []byte
+}
+
+type INxmTunMetadata43Masked interface {
+	goloxi.IOxm
+	GetValue() []byte
+	GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata43Masked) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata43Masked) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata43Masked) GetValueMask() []byte {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata43Masked) SetValueMask(v []byte) {
+	self.ValueMask = v
+}
+
+func (self *NxmTunMetadata43Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata43Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata43Masked, error) {
+	_nxmtunmetadata43masked := &NxmTunMetadata43Masked{Oxm: parent}
+	_nxmtunmetadata43masked.Value = decoder.Read(int(_nxmtunmetadata43masked.TypeLen & 0xFF))
+	_nxmtunmetadata43masked.ValueMask = decoder.Read(int(_nxmtunmetadata43masked.TypeLen & 0xFF))
+	return _nxmtunmetadata43masked, nil
+}
+
+func NewNxmTunMetadata43Masked() *NxmTunMetadata43Masked {
+	obj := &NxmTunMetadata43Masked{
+		Oxm: NewOxm(108536),
+	}
+	return obj
+}
+func (self *NxmTunMetadata43Masked) GetOXMName() string {
+	return "tun_metadata43_masked"
+}
+
+func (self *NxmTunMetadata43Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata43Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata43Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata44 struct {
+	*Oxm
+	Value []byte
+}
+
+type INxmTunMetadata44 interface {
+	goloxi.IOxm
+	GetValue() []byte
+}
+
+func (self *NxmTunMetadata44) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata44) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata44) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata44(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata44, error) {
+	_nxmtunmetadata44 := &NxmTunMetadata44{Oxm: parent}
+	_nxmtunmetadata44.Value = decoder.Read(int(_nxmtunmetadata44.TypeLen & 0xFF))
+	return _nxmtunmetadata44, nil
+}
+
+func NewNxmTunMetadata44() *NxmTunMetadata44 {
+	obj := &NxmTunMetadata44{
+		Oxm: NewOxm(108668),
+	}
+	return obj
+}
+func (self *NxmTunMetadata44) GetOXMName() string {
+	return "tun_metadata44"
+}
+
+func (self *NxmTunMetadata44) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata44) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata44Masked struct {
+	*Oxm
+	Value     []byte
+	ValueMask []byte
+}
+
+type INxmTunMetadata44Masked interface {
+	goloxi.IOxm
+	GetValue() []byte
+	GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata44Masked) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata44Masked) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata44Masked) GetValueMask() []byte {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata44Masked) SetValueMask(v []byte) {
+	self.ValueMask = v
+}
+
+func (self *NxmTunMetadata44Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata44Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata44Masked, error) {
+	_nxmtunmetadata44masked := &NxmTunMetadata44Masked{Oxm: parent}
+	_nxmtunmetadata44masked.Value = decoder.Read(int(_nxmtunmetadata44masked.TypeLen & 0xFF))
+	_nxmtunmetadata44masked.ValueMask = decoder.Read(int(_nxmtunmetadata44masked.TypeLen & 0xFF))
+	return _nxmtunmetadata44masked, nil
+}
+
+func NewNxmTunMetadata44Masked() *NxmTunMetadata44Masked {
+	obj := &NxmTunMetadata44Masked{
+		Oxm: NewOxm(109048),
+	}
+	return obj
+}
+func (self *NxmTunMetadata44Masked) GetOXMName() string {
+	return "tun_metadata44_masked"
+}
+
+func (self *NxmTunMetadata44Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata44Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata44Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata45 struct {
+	*Oxm
+	Value []byte
+}
+
+type INxmTunMetadata45 interface {
+	goloxi.IOxm
+	GetValue() []byte
+}
+
+func (self *NxmTunMetadata45) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata45) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata45) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata45(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata45, error) {
+	_nxmtunmetadata45 := &NxmTunMetadata45{Oxm: parent}
+	_nxmtunmetadata45.Value = decoder.Read(int(_nxmtunmetadata45.TypeLen & 0xFF))
+	return _nxmtunmetadata45, nil
+}
+
+func NewNxmTunMetadata45() *NxmTunMetadata45 {
+	obj := &NxmTunMetadata45{
+		Oxm: NewOxm(109180),
+	}
+	return obj
+}
+func (self *NxmTunMetadata45) GetOXMName() string {
+	return "tun_metadata45"
+}
+
+func (self *NxmTunMetadata45) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata45) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata45Masked struct {
+	*Oxm
+	Value     []byte
+	ValueMask []byte
+}
+
+type INxmTunMetadata45Masked interface {
+	goloxi.IOxm
+	GetValue() []byte
+	GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata45Masked) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata45Masked) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata45Masked) GetValueMask() []byte {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata45Masked) SetValueMask(v []byte) {
+	self.ValueMask = v
+}
+
+func (self *NxmTunMetadata45Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata45Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata45Masked, error) {
+	_nxmtunmetadata45masked := &NxmTunMetadata45Masked{Oxm: parent}
+	_nxmtunmetadata45masked.Value = decoder.Read(int(_nxmtunmetadata45masked.TypeLen & 0xFF))
+	_nxmtunmetadata45masked.ValueMask = decoder.Read(int(_nxmtunmetadata45masked.TypeLen & 0xFF))
+	return _nxmtunmetadata45masked, nil
+}
+
+func NewNxmTunMetadata45Masked() *NxmTunMetadata45Masked {
+	obj := &NxmTunMetadata45Masked{
+		Oxm: NewOxm(109560),
+	}
+	return obj
+}
+func (self *NxmTunMetadata45Masked) GetOXMName() string {
+	return "tun_metadata45_masked"
+}
+
+func (self *NxmTunMetadata45Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata45Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata45Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata46 struct {
+	*Oxm
+	Value []byte
+}
+
+type INxmTunMetadata46 interface {
+	goloxi.IOxm
+	GetValue() []byte
+}
+
+func (self *NxmTunMetadata46) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata46) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata46) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata46(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata46, error) {
+	_nxmtunmetadata46 := &NxmTunMetadata46{Oxm: parent}
+	_nxmtunmetadata46.Value = decoder.Read(int(_nxmtunmetadata46.TypeLen & 0xFF))
+	return _nxmtunmetadata46, nil
+}
+
+func NewNxmTunMetadata46() *NxmTunMetadata46 {
+	obj := &NxmTunMetadata46{
+		Oxm: NewOxm(109692),
+	}
+	return obj
+}
+func (self *NxmTunMetadata46) GetOXMName() string {
+	return "tun_metadata46"
+}
+
+func (self *NxmTunMetadata46) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata46) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata46Masked struct {
+	*Oxm
+	Value     []byte
+	ValueMask []byte
+}
+
+type INxmTunMetadata46Masked interface {
+	goloxi.IOxm
+	GetValue() []byte
+	GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata46Masked) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata46Masked) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata46Masked) GetValueMask() []byte {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata46Masked) SetValueMask(v []byte) {
+	self.ValueMask = v
+}
+
+func (self *NxmTunMetadata46Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata46Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata46Masked, error) {
+	_nxmtunmetadata46masked := &NxmTunMetadata46Masked{Oxm: parent}
+	_nxmtunmetadata46masked.Value = decoder.Read(int(_nxmtunmetadata46masked.TypeLen & 0xFF))
+	_nxmtunmetadata46masked.ValueMask = decoder.Read(int(_nxmtunmetadata46masked.TypeLen & 0xFF))
+	return _nxmtunmetadata46masked, nil
+}
+
+func NewNxmTunMetadata46Masked() *NxmTunMetadata46Masked {
+	obj := &NxmTunMetadata46Masked{
+		Oxm: NewOxm(110072),
+	}
+	return obj
+}
+func (self *NxmTunMetadata46Masked) GetOXMName() string {
+	return "tun_metadata46_masked"
+}
+
+func (self *NxmTunMetadata46Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata46Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata46Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata47 struct {
+	*Oxm
+	Value []byte
+}
+
+type INxmTunMetadata47 interface {
+	goloxi.IOxm
+	GetValue() []byte
+}
+
+func (self *NxmTunMetadata47) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata47) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata47) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata47(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata47, error) {
+	_nxmtunmetadata47 := &NxmTunMetadata47{Oxm: parent}
+	_nxmtunmetadata47.Value = decoder.Read(int(_nxmtunmetadata47.TypeLen & 0xFF))
+	return _nxmtunmetadata47, nil
+}
+
+func NewNxmTunMetadata47() *NxmTunMetadata47 {
+	obj := &NxmTunMetadata47{
+		Oxm: NewOxm(110204),
+	}
+	return obj
+}
+func (self *NxmTunMetadata47) GetOXMName() string {
+	return "tun_metadata47"
+}
+
+func (self *NxmTunMetadata47) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata47) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata47Masked struct {
+	*Oxm
+	Value     []byte
+	ValueMask []byte
+}
+
+type INxmTunMetadata47Masked interface {
+	goloxi.IOxm
+	GetValue() []byte
+	GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata47Masked) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata47Masked) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata47Masked) GetValueMask() []byte {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata47Masked) SetValueMask(v []byte) {
+	self.ValueMask = v
+}
+
+func (self *NxmTunMetadata47Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata47Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata47Masked, error) {
+	_nxmtunmetadata47masked := &NxmTunMetadata47Masked{Oxm: parent}
+	_nxmtunmetadata47masked.Value = decoder.Read(int(_nxmtunmetadata47masked.TypeLen & 0xFF))
+	_nxmtunmetadata47masked.ValueMask = decoder.Read(int(_nxmtunmetadata47masked.TypeLen & 0xFF))
+	return _nxmtunmetadata47masked, nil
+}
+
+func NewNxmTunMetadata47Masked() *NxmTunMetadata47Masked {
+	obj := &NxmTunMetadata47Masked{
+		Oxm: NewOxm(110584),
+	}
+	return obj
+}
+func (self *NxmTunMetadata47Masked) GetOXMName() string {
+	return "tun_metadata47_masked"
+}
+
+func (self *NxmTunMetadata47Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata47Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata47Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata48 struct {
+	*Oxm
+	Value []byte
+}
+
+type INxmTunMetadata48 interface {
+	goloxi.IOxm
+	GetValue() []byte
+}
+
+func (self *NxmTunMetadata48) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata48) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata48) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata48(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata48, error) {
+	_nxmtunmetadata48 := &NxmTunMetadata48{Oxm: parent}
+	_nxmtunmetadata48.Value = decoder.Read(int(_nxmtunmetadata48.TypeLen & 0xFF))
+	return _nxmtunmetadata48, nil
+}
+
+func NewNxmTunMetadata48() *NxmTunMetadata48 {
+	obj := &NxmTunMetadata48{
+		Oxm: NewOxm(110716),
+	}
+	return obj
+}
+func (self *NxmTunMetadata48) GetOXMName() string {
+	return "tun_metadata48"
+}
+
+func (self *NxmTunMetadata48) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata48) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata48Masked struct {
+	*Oxm
+	Value     []byte
+	ValueMask []byte
+}
+
+type INxmTunMetadata48Masked interface {
+	goloxi.IOxm
+	GetValue() []byte
+	GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata48Masked) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata48Masked) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata48Masked) GetValueMask() []byte {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata48Masked) SetValueMask(v []byte) {
+	self.ValueMask = v
+}
+
+func (self *NxmTunMetadata48Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata48Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata48Masked, error) {
+	_nxmtunmetadata48masked := &NxmTunMetadata48Masked{Oxm: parent}
+	_nxmtunmetadata48masked.Value = decoder.Read(int(_nxmtunmetadata48masked.TypeLen & 0xFF))
+	_nxmtunmetadata48masked.ValueMask = decoder.Read(int(_nxmtunmetadata48masked.TypeLen & 0xFF))
+	return _nxmtunmetadata48masked, nil
+}
+
+func NewNxmTunMetadata48Masked() *NxmTunMetadata48Masked {
+	obj := &NxmTunMetadata48Masked{
+		Oxm: NewOxm(111096),
+	}
+	return obj
+}
+func (self *NxmTunMetadata48Masked) GetOXMName() string {
+	return "tun_metadata48_masked"
+}
+
+func (self *NxmTunMetadata48Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata48Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata48Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata49 struct {
+	*Oxm
+	Value []byte
+}
+
+type INxmTunMetadata49 interface {
+	goloxi.IOxm
+	GetValue() []byte
+}
+
+func (self *NxmTunMetadata49) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata49) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata49) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata49(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata49, error) {
+	_nxmtunmetadata49 := &NxmTunMetadata49{Oxm: parent}
+	_nxmtunmetadata49.Value = decoder.Read(int(_nxmtunmetadata49.TypeLen & 0xFF))
+	return _nxmtunmetadata49, nil
+}
+
+func NewNxmTunMetadata49() *NxmTunMetadata49 {
+	obj := &NxmTunMetadata49{
+		Oxm: NewOxm(111228),
+	}
+	return obj
+}
+func (self *NxmTunMetadata49) GetOXMName() string {
+	return "tun_metadata49"
+}
+
+func (self *NxmTunMetadata49) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata49) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata49Masked struct {
+	*Oxm
+	Value     []byte
+	ValueMask []byte
+}
+
+type INxmTunMetadata49Masked interface {
+	goloxi.IOxm
+	GetValue() []byte
+	GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata49Masked) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata49Masked) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata49Masked) GetValueMask() []byte {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata49Masked) SetValueMask(v []byte) {
+	self.ValueMask = v
+}
+
+func (self *NxmTunMetadata49Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata49Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata49Masked, error) {
+	_nxmtunmetadata49masked := &NxmTunMetadata49Masked{Oxm: parent}
+	_nxmtunmetadata49masked.Value = decoder.Read(int(_nxmtunmetadata49masked.TypeLen & 0xFF))
+	_nxmtunmetadata49masked.ValueMask = decoder.Read(int(_nxmtunmetadata49masked.TypeLen & 0xFF))
+	return _nxmtunmetadata49masked, nil
+}
+
+func NewNxmTunMetadata49Masked() *NxmTunMetadata49Masked {
+	obj := &NxmTunMetadata49Masked{
+		Oxm: NewOxm(111608),
+	}
+	return obj
+}
+func (self *NxmTunMetadata49Masked) GetOXMName() string {
+	return "tun_metadata49_masked"
+}
+
+func (self *NxmTunMetadata49Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata49Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata49Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata4Masked struct {
+	*Oxm
+	Value     []byte
+	ValueMask []byte
+}
+
+type INxmTunMetadata4Masked interface {
+	goloxi.IOxm
+	GetValue() []byte
+	GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata4Masked) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata4Masked) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata4Masked) GetValueMask() []byte {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata4Masked) SetValueMask(v []byte) {
+	self.ValueMask = v
+}
+
+func (self *NxmTunMetadata4Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata4Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata4Masked, error) {
+	_nxmtunmetadata4masked := &NxmTunMetadata4Masked{Oxm: parent}
+	_nxmtunmetadata4masked.Value = decoder.Read(int(_nxmtunmetadata4masked.TypeLen & 0xFF))
+	_nxmtunmetadata4masked.ValueMask = decoder.Read(int(_nxmtunmetadata4masked.TypeLen & 0xFF))
+	return _nxmtunmetadata4masked, nil
+}
+
+func NewNxmTunMetadata4Masked() *NxmTunMetadata4Masked {
+	obj := &NxmTunMetadata4Masked{
+		Oxm: NewOxm(88568),
+	}
+	return obj
+}
+func (self *NxmTunMetadata4Masked) GetOXMName() string {
+	return "tun_metadata4_masked"
+}
+
+func (self *NxmTunMetadata4Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata4Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata4Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata5 struct {
+	*Oxm
+	Value []byte
+}
+
+type INxmTunMetadata5 interface {
+	goloxi.IOxm
+	GetValue() []byte
+}
+
+func (self *NxmTunMetadata5) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata5) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata5) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata5(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata5, error) {
+	_nxmtunmetadata5 := &NxmTunMetadata5{Oxm: parent}
+	_nxmtunmetadata5.Value = decoder.Read(int(_nxmtunmetadata5.TypeLen & 0xFF))
+	return _nxmtunmetadata5, nil
+}
+
+func NewNxmTunMetadata5() *NxmTunMetadata5 {
+	obj := &NxmTunMetadata5{
+		Oxm: NewOxm(88700),
+	}
+	return obj
+}
+func (self *NxmTunMetadata5) GetOXMName() string {
+	return "tun_metadata5"
+}
+
+func (self *NxmTunMetadata5) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata5) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata50 struct {
+	*Oxm
+	Value []byte
+}
+
+type INxmTunMetadata50 interface {
+	goloxi.IOxm
+	GetValue() []byte
+}
+
+func (self *NxmTunMetadata50) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata50) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata50) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata50(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata50, error) {
+	_nxmtunmetadata50 := &NxmTunMetadata50{Oxm: parent}
+	_nxmtunmetadata50.Value = decoder.Read(int(_nxmtunmetadata50.TypeLen & 0xFF))
+	return _nxmtunmetadata50, nil
+}
+
+func NewNxmTunMetadata50() *NxmTunMetadata50 {
+	obj := &NxmTunMetadata50{
+		Oxm: NewOxm(111740),
+	}
+	return obj
+}
+func (self *NxmTunMetadata50) GetOXMName() string {
+	return "tun_metadata50"
+}
+
+func (self *NxmTunMetadata50) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata50) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata50Masked struct {
+	*Oxm
+	Value     []byte
+	ValueMask []byte
+}
+
+type INxmTunMetadata50Masked interface {
+	goloxi.IOxm
+	GetValue() []byte
+	GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata50Masked) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata50Masked) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata50Masked) GetValueMask() []byte {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata50Masked) SetValueMask(v []byte) {
+	self.ValueMask = v
+}
+
+func (self *NxmTunMetadata50Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata50Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata50Masked, error) {
+	_nxmtunmetadata50masked := &NxmTunMetadata50Masked{Oxm: parent}
+	_nxmtunmetadata50masked.Value = decoder.Read(int(_nxmtunmetadata50masked.TypeLen & 0xFF))
+	_nxmtunmetadata50masked.ValueMask = decoder.Read(int(_nxmtunmetadata50masked.TypeLen & 0xFF))
+	return _nxmtunmetadata50masked, nil
+}
+
+func NewNxmTunMetadata50Masked() *NxmTunMetadata50Masked {
+	obj := &NxmTunMetadata50Masked{
+		Oxm: NewOxm(112120),
+	}
+	return obj
+}
+func (self *NxmTunMetadata50Masked) GetOXMName() string {
+	return "tun_metadata50_masked"
+}
+
+func (self *NxmTunMetadata50Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata50Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata50Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata51 struct {
+	*Oxm
+	Value []byte
+}
+
+type INxmTunMetadata51 interface {
+	goloxi.IOxm
+	GetValue() []byte
+}
+
+func (self *NxmTunMetadata51) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata51) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata51) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata51(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata51, error) {
+	_nxmtunmetadata51 := &NxmTunMetadata51{Oxm: parent}
+	_nxmtunmetadata51.Value = decoder.Read(int(_nxmtunmetadata51.TypeLen & 0xFF))
+	return _nxmtunmetadata51, nil
+}
+
+func NewNxmTunMetadata51() *NxmTunMetadata51 {
+	obj := &NxmTunMetadata51{
+		Oxm: NewOxm(112252),
+	}
+	return obj
+}
+func (self *NxmTunMetadata51) GetOXMName() string {
+	return "tun_metadata51"
+}
+
+func (self *NxmTunMetadata51) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata51) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata51Masked struct {
+	*Oxm
+	Value     []byte
+	ValueMask []byte
+}
+
+type INxmTunMetadata51Masked interface {
+	goloxi.IOxm
+	GetValue() []byte
+	GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata51Masked) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata51Masked) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata51Masked) GetValueMask() []byte {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata51Masked) SetValueMask(v []byte) {
+	self.ValueMask = v
+}
+
+func (self *NxmTunMetadata51Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata51Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata51Masked, error) {
+	_nxmtunmetadata51masked := &NxmTunMetadata51Masked{Oxm: parent}
+	_nxmtunmetadata51masked.Value = decoder.Read(int(_nxmtunmetadata51masked.TypeLen & 0xFF))
+	_nxmtunmetadata51masked.ValueMask = decoder.Read(int(_nxmtunmetadata51masked.TypeLen & 0xFF))
+	return _nxmtunmetadata51masked, nil
+}
+
+func NewNxmTunMetadata51Masked() *NxmTunMetadata51Masked {
+	obj := &NxmTunMetadata51Masked{
+		Oxm: NewOxm(112632),
+	}
+	return obj
+}
+func (self *NxmTunMetadata51Masked) GetOXMName() string {
+	return "tun_metadata51_masked"
+}
+
+func (self *NxmTunMetadata51Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata51Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata51Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata52 struct {
+	*Oxm
+	Value []byte
+}
+
+type INxmTunMetadata52 interface {
+	goloxi.IOxm
+	GetValue() []byte
+}
+
+func (self *NxmTunMetadata52) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata52) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata52) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata52(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata52, error) {
+	_nxmtunmetadata52 := &NxmTunMetadata52{Oxm: parent}
+	_nxmtunmetadata52.Value = decoder.Read(int(_nxmtunmetadata52.TypeLen & 0xFF))
+	return _nxmtunmetadata52, nil
+}
+
+func NewNxmTunMetadata52() *NxmTunMetadata52 {
+	obj := &NxmTunMetadata52{
+		Oxm: NewOxm(112764),
+	}
+	return obj
+}
+func (self *NxmTunMetadata52) GetOXMName() string {
+	return "tun_metadata52"
+}
+
+func (self *NxmTunMetadata52) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata52) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata52Masked struct {
+	*Oxm
+	Value     []byte
+	ValueMask []byte
+}
+
+type INxmTunMetadata52Masked interface {
+	goloxi.IOxm
+	GetValue() []byte
+	GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata52Masked) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata52Masked) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata52Masked) GetValueMask() []byte {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata52Masked) SetValueMask(v []byte) {
+	self.ValueMask = v
+}
+
+func (self *NxmTunMetadata52Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata52Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata52Masked, error) {
+	_nxmtunmetadata52masked := &NxmTunMetadata52Masked{Oxm: parent}
+	_nxmtunmetadata52masked.Value = decoder.Read(int(_nxmtunmetadata52masked.TypeLen & 0xFF))
+	_nxmtunmetadata52masked.ValueMask = decoder.Read(int(_nxmtunmetadata52masked.TypeLen & 0xFF))
+	return _nxmtunmetadata52masked, nil
+}
+
+func NewNxmTunMetadata52Masked() *NxmTunMetadata52Masked {
+	obj := &NxmTunMetadata52Masked{
+		Oxm: NewOxm(113144),
+	}
+	return obj
+}
+func (self *NxmTunMetadata52Masked) GetOXMName() string {
+	return "tun_metadata52_masked"
+}
+
+func (self *NxmTunMetadata52Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata52Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata52Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata53 struct {
+	*Oxm
+	Value []byte
+}
+
+type INxmTunMetadata53 interface {
+	goloxi.IOxm
+	GetValue() []byte
+}
+
+func (self *NxmTunMetadata53) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata53) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata53) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata53(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata53, error) {
+	_nxmtunmetadata53 := &NxmTunMetadata53{Oxm: parent}
+	_nxmtunmetadata53.Value = decoder.Read(int(_nxmtunmetadata53.TypeLen & 0xFF))
+	return _nxmtunmetadata53, nil
+}
+
+func NewNxmTunMetadata53() *NxmTunMetadata53 {
+	obj := &NxmTunMetadata53{
+		Oxm: NewOxm(113276),
+	}
+	return obj
+}
+func (self *NxmTunMetadata53) GetOXMName() string {
+	return "tun_metadata53"
+}
+
+func (self *NxmTunMetadata53) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata53) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata53Masked struct {
+	*Oxm
+	Value     []byte
+	ValueMask []byte
+}
+
+type INxmTunMetadata53Masked interface {
+	goloxi.IOxm
+	GetValue() []byte
+	GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata53Masked) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata53Masked) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata53Masked) GetValueMask() []byte {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata53Masked) SetValueMask(v []byte) {
+	self.ValueMask = v
+}
+
+func (self *NxmTunMetadata53Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata53Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata53Masked, error) {
+	_nxmtunmetadata53masked := &NxmTunMetadata53Masked{Oxm: parent}
+	_nxmtunmetadata53masked.Value = decoder.Read(int(_nxmtunmetadata53masked.TypeLen & 0xFF))
+	_nxmtunmetadata53masked.ValueMask = decoder.Read(int(_nxmtunmetadata53masked.TypeLen & 0xFF))
+	return _nxmtunmetadata53masked, nil
+}
+
+func NewNxmTunMetadata53Masked() *NxmTunMetadata53Masked {
+	obj := &NxmTunMetadata53Masked{
+		Oxm: NewOxm(113656),
+	}
+	return obj
+}
+func (self *NxmTunMetadata53Masked) GetOXMName() string {
+	return "tun_metadata53_masked"
+}
+
+func (self *NxmTunMetadata53Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata53Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata53Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata54 struct {
+	*Oxm
+	Value []byte
+}
+
+type INxmTunMetadata54 interface {
+	goloxi.IOxm
+	GetValue() []byte
+}
+
+func (self *NxmTunMetadata54) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata54) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata54) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata54(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata54, error) {
+	_nxmtunmetadata54 := &NxmTunMetadata54{Oxm: parent}
+	_nxmtunmetadata54.Value = decoder.Read(int(_nxmtunmetadata54.TypeLen & 0xFF))
+	return _nxmtunmetadata54, nil
+}
+
+func NewNxmTunMetadata54() *NxmTunMetadata54 {
+	obj := &NxmTunMetadata54{
+		Oxm: NewOxm(113788),
+	}
+	return obj
+}
+func (self *NxmTunMetadata54) GetOXMName() string {
+	return "tun_metadata54"
+}
+
+func (self *NxmTunMetadata54) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata54) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata54Masked struct {
+	*Oxm
+	Value     []byte
+	ValueMask []byte
+}
+
+type INxmTunMetadata54Masked interface {
+	goloxi.IOxm
+	GetValue() []byte
+	GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata54Masked) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata54Masked) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata54Masked) GetValueMask() []byte {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata54Masked) SetValueMask(v []byte) {
+	self.ValueMask = v
+}
+
+func (self *NxmTunMetadata54Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata54Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata54Masked, error) {
+	_nxmtunmetadata54masked := &NxmTunMetadata54Masked{Oxm: parent}
+	_nxmtunmetadata54masked.Value = decoder.Read(int(_nxmtunmetadata54masked.TypeLen & 0xFF))
+	_nxmtunmetadata54masked.ValueMask = decoder.Read(int(_nxmtunmetadata54masked.TypeLen & 0xFF))
+	return _nxmtunmetadata54masked, nil
+}
+
+func NewNxmTunMetadata54Masked() *NxmTunMetadata54Masked {
+	obj := &NxmTunMetadata54Masked{
+		Oxm: NewOxm(114168),
+	}
+	return obj
+}
+func (self *NxmTunMetadata54Masked) GetOXMName() string {
+	return "tun_metadata54_masked"
+}
+
+func (self *NxmTunMetadata54Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata54Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata54Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata55 struct {
+	*Oxm
+	Value []byte
+}
+
+type INxmTunMetadata55 interface {
+	goloxi.IOxm
+	GetValue() []byte
+}
+
+func (self *NxmTunMetadata55) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata55) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata55) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata55(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata55, error) {
+	_nxmtunmetadata55 := &NxmTunMetadata55{Oxm: parent}
+	_nxmtunmetadata55.Value = decoder.Read(int(_nxmtunmetadata55.TypeLen & 0xFF))
+	return _nxmtunmetadata55, nil
+}
+
+func NewNxmTunMetadata55() *NxmTunMetadata55 {
+	obj := &NxmTunMetadata55{
+		Oxm: NewOxm(114300),
+	}
+	return obj
+}
+func (self *NxmTunMetadata55) GetOXMName() string {
+	return "tun_metadata55"
+}
+
+func (self *NxmTunMetadata55) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata55) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata55Masked struct {
+	*Oxm
+	Value     []byte
+	ValueMask []byte
+}
+
+type INxmTunMetadata55Masked interface {
+	goloxi.IOxm
+	GetValue() []byte
+	GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata55Masked) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata55Masked) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata55Masked) GetValueMask() []byte {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata55Masked) SetValueMask(v []byte) {
+	self.ValueMask = v
+}
+
+func (self *NxmTunMetadata55Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata55Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata55Masked, error) {
+	_nxmtunmetadata55masked := &NxmTunMetadata55Masked{Oxm: parent}
+	_nxmtunmetadata55masked.Value = decoder.Read(int(_nxmtunmetadata55masked.TypeLen & 0xFF))
+	_nxmtunmetadata55masked.ValueMask = decoder.Read(int(_nxmtunmetadata55masked.TypeLen & 0xFF))
+	return _nxmtunmetadata55masked, nil
+}
+
+func NewNxmTunMetadata55Masked() *NxmTunMetadata55Masked {
+	obj := &NxmTunMetadata55Masked{
+		Oxm: NewOxm(114680),
+	}
+	return obj
+}
+func (self *NxmTunMetadata55Masked) GetOXMName() string {
+	return "tun_metadata55_masked"
+}
+
+func (self *NxmTunMetadata55Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata55Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata55Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata56 struct {
+	*Oxm
+	Value []byte
+}
+
+type INxmTunMetadata56 interface {
+	goloxi.IOxm
+	GetValue() []byte
+}
+
+func (self *NxmTunMetadata56) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata56) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata56) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata56(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata56, error) {
+	_nxmtunmetadata56 := &NxmTunMetadata56{Oxm: parent}
+	_nxmtunmetadata56.Value = decoder.Read(int(_nxmtunmetadata56.TypeLen & 0xFF))
+	return _nxmtunmetadata56, nil
+}
+
+func NewNxmTunMetadata56() *NxmTunMetadata56 {
+	obj := &NxmTunMetadata56{
+		Oxm: NewOxm(114812),
+	}
+	return obj
+}
+func (self *NxmTunMetadata56) GetOXMName() string {
+	return "tun_metadata56"
+}
+
+func (self *NxmTunMetadata56) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata56) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata56Masked struct {
+	*Oxm
+	Value     []byte
+	ValueMask []byte
+}
+
+type INxmTunMetadata56Masked interface {
+	goloxi.IOxm
+	GetValue() []byte
+	GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata56Masked) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata56Masked) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata56Masked) GetValueMask() []byte {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata56Masked) SetValueMask(v []byte) {
+	self.ValueMask = v
+}
+
+func (self *NxmTunMetadata56Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata56Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata56Masked, error) {
+	_nxmtunmetadata56masked := &NxmTunMetadata56Masked{Oxm: parent}
+	_nxmtunmetadata56masked.Value = decoder.Read(int(_nxmtunmetadata56masked.TypeLen & 0xFF))
+	_nxmtunmetadata56masked.ValueMask = decoder.Read(int(_nxmtunmetadata56masked.TypeLen & 0xFF))
+	return _nxmtunmetadata56masked, nil
+}
+
+func NewNxmTunMetadata56Masked() *NxmTunMetadata56Masked {
+	obj := &NxmTunMetadata56Masked{
+		Oxm: NewOxm(115192),
+	}
+	return obj
+}
+func (self *NxmTunMetadata56Masked) GetOXMName() string {
+	return "tun_metadata56_masked"
+}
+
+func (self *NxmTunMetadata56Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata56Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata56Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata57 struct {
+	*Oxm
+	Value []byte
+}
+
+type INxmTunMetadata57 interface {
+	goloxi.IOxm
+	GetValue() []byte
+}
+
+func (self *NxmTunMetadata57) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata57) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata57) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata57(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata57, error) {
+	_nxmtunmetadata57 := &NxmTunMetadata57{Oxm: parent}
+	_nxmtunmetadata57.Value = decoder.Read(int(_nxmtunmetadata57.TypeLen & 0xFF))
+	return _nxmtunmetadata57, nil
+}
+
+func NewNxmTunMetadata57() *NxmTunMetadata57 {
+	obj := &NxmTunMetadata57{
+		Oxm: NewOxm(115324),
+	}
+	return obj
+}
+func (self *NxmTunMetadata57) GetOXMName() string {
+	return "tun_metadata57"
+}
+
+func (self *NxmTunMetadata57) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata57) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata57Masked struct {
+	*Oxm
+	Value     []byte
+	ValueMask []byte
+}
+
+type INxmTunMetadata57Masked interface {
+	goloxi.IOxm
+	GetValue() []byte
+	GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata57Masked) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata57Masked) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata57Masked) GetValueMask() []byte {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata57Masked) SetValueMask(v []byte) {
+	self.ValueMask = v
+}
+
+func (self *NxmTunMetadata57Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata57Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata57Masked, error) {
+	_nxmtunmetadata57masked := &NxmTunMetadata57Masked{Oxm: parent}
+	_nxmtunmetadata57masked.Value = decoder.Read(int(_nxmtunmetadata57masked.TypeLen & 0xFF))
+	_nxmtunmetadata57masked.ValueMask = decoder.Read(int(_nxmtunmetadata57masked.TypeLen & 0xFF))
+	return _nxmtunmetadata57masked, nil
+}
+
+func NewNxmTunMetadata57Masked() *NxmTunMetadata57Masked {
+	obj := &NxmTunMetadata57Masked{
+		Oxm: NewOxm(115704),
+	}
+	return obj
+}
+func (self *NxmTunMetadata57Masked) GetOXMName() string {
+	return "tun_metadata57_masked"
+}
+
+func (self *NxmTunMetadata57Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata57Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata57Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata58 struct {
+	*Oxm
+	Value []byte
+}
+
+type INxmTunMetadata58 interface {
+	goloxi.IOxm
+	GetValue() []byte
+}
+
+func (self *NxmTunMetadata58) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata58) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata58) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata58(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata58, error) {
+	_nxmtunmetadata58 := &NxmTunMetadata58{Oxm: parent}
+	_nxmtunmetadata58.Value = decoder.Read(int(_nxmtunmetadata58.TypeLen & 0xFF))
+	return _nxmtunmetadata58, nil
+}
+
+func NewNxmTunMetadata58() *NxmTunMetadata58 {
+	obj := &NxmTunMetadata58{
+		Oxm: NewOxm(115836),
+	}
+	return obj
+}
+func (self *NxmTunMetadata58) GetOXMName() string {
+	return "tun_metadata58"
+}
+
+func (self *NxmTunMetadata58) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata58) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata58Masked struct {
+	*Oxm
+	Value     []byte
+	ValueMask []byte
+}
+
+type INxmTunMetadata58Masked interface {
+	goloxi.IOxm
+	GetValue() []byte
+	GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata58Masked) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata58Masked) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata58Masked) GetValueMask() []byte {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata58Masked) SetValueMask(v []byte) {
+	self.ValueMask = v
+}
+
+func (self *NxmTunMetadata58Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata58Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata58Masked, error) {
+	_nxmtunmetadata58masked := &NxmTunMetadata58Masked{Oxm: parent}
+	_nxmtunmetadata58masked.Value = decoder.Read(int(_nxmtunmetadata58masked.TypeLen & 0xFF))
+	_nxmtunmetadata58masked.ValueMask = decoder.Read(int(_nxmtunmetadata58masked.TypeLen & 0xFF))
+	return _nxmtunmetadata58masked, nil
+}
+
+func NewNxmTunMetadata58Masked() *NxmTunMetadata58Masked {
+	obj := &NxmTunMetadata58Masked{
+		Oxm: NewOxm(116216),
+	}
+	return obj
+}
+func (self *NxmTunMetadata58Masked) GetOXMName() string {
+	return "tun_metadata58_masked"
+}
+
+func (self *NxmTunMetadata58Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata58Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata58Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata59 struct {
+	*Oxm
+	Value []byte
+}
+
+type INxmTunMetadata59 interface {
+	goloxi.IOxm
+	GetValue() []byte
+}
+
+func (self *NxmTunMetadata59) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata59) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata59) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata59(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata59, error) {
+	_nxmtunmetadata59 := &NxmTunMetadata59{Oxm: parent}
+	_nxmtunmetadata59.Value = decoder.Read(int(_nxmtunmetadata59.TypeLen & 0xFF))
+	return _nxmtunmetadata59, nil
+}
+
+func NewNxmTunMetadata59() *NxmTunMetadata59 {
+	obj := &NxmTunMetadata59{
+		Oxm: NewOxm(116348),
+	}
+	return obj
+}
+func (self *NxmTunMetadata59) GetOXMName() string {
+	return "tun_metadata59"
+}
+
+func (self *NxmTunMetadata59) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata59) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata59Masked struct {
+	*Oxm
+	Value     []byte
+	ValueMask []byte
+}
+
+type INxmTunMetadata59Masked interface {
+	goloxi.IOxm
+	GetValue() []byte
+	GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata59Masked) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata59Masked) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata59Masked) GetValueMask() []byte {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata59Masked) SetValueMask(v []byte) {
+	self.ValueMask = v
+}
+
+func (self *NxmTunMetadata59Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata59Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata59Masked, error) {
+	_nxmtunmetadata59masked := &NxmTunMetadata59Masked{Oxm: parent}
+	_nxmtunmetadata59masked.Value = decoder.Read(int(_nxmtunmetadata59masked.TypeLen & 0xFF))
+	_nxmtunmetadata59masked.ValueMask = decoder.Read(int(_nxmtunmetadata59masked.TypeLen & 0xFF))
+	return _nxmtunmetadata59masked, nil
+}
+
+func NewNxmTunMetadata59Masked() *NxmTunMetadata59Masked {
+	obj := &NxmTunMetadata59Masked{
+		Oxm: NewOxm(116728),
+	}
+	return obj
+}
+func (self *NxmTunMetadata59Masked) GetOXMName() string {
+	return "tun_metadata59_masked"
+}
+
+func (self *NxmTunMetadata59Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata59Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata59Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata5Masked struct {
+	*Oxm
+	Value     []byte
+	ValueMask []byte
+}
+
+type INxmTunMetadata5Masked interface {
+	goloxi.IOxm
+	GetValue() []byte
+	GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata5Masked) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata5Masked) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata5Masked) GetValueMask() []byte {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata5Masked) SetValueMask(v []byte) {
+	self.ValueMask = v
+}
+
+func (self *NxmTunMetadata5Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata5Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata5Masked, error) {
+	_nxmtunmetadata5masked := &NxmTunMetadata5Masked{Oxm: parent}
+	_nxmtunmetadata5masked.Value = decoder.Read(int(_nxmtunmetadata5masked.TypeLen & 0xFF))
+	_nxmtunmetadata5masked.ValueMask = decoder.Read(int(_nxmtunmetadata5masked.TypeLen & 0xFF))
+	return _nxmtunmetadata5masked, nil
+}
+
+func NewNxmTunMetadata5Masked() *NxmTunMetadata5Masked {
+	obj := &NxmTunMetadata5Masked{
+		Oxm: NewOxm(89080),
+	}
+	return obj
+}
+func (self *NxmTunMetadata5Masked) GetOXMName() string {
+	return "tun_metadata5_masked"
+}
+
+func (self *NxmTunMetadata5Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata5Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata5Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata6 struct {
+	*Oxm
+	Value []byte
+}
+
+type INxmTunMetadata6 interface {
+	goloxi.IOxm
+	GetValue() []byte
+}
+
+func (self *NxmTunMetadata6) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata6) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata6) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata6(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata6, error) {
+	_nxmtunmetadata6 := &NxmTunMetadata6{Oxm: parent}
+	_nxmtunmetadata6.Value = decoder.Read(int(_nxmtunmetadata6.TypeLen & 0xFF))
+	return _nxmtunmetadata6, nil
+}
+
+func NewNxmTunMetadata6() *NxmTunMetadata6 {
+	obj := &NxmTunMetadata6{
+		Oxm: NewOxm(89212),
+	}
+	return obj
+}
+func (self *NxmTunMetadata6) GetOXMName() string {
+	return "tun_metadata6"
+}
+
+func (self *NxmTunMetadata6) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata6) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata60 struct {
+	*Oxm
+	Value []byte
+}
+
+type INxmTunMetadata60 interface {
+	goloxi.IOxm
+	GetValue() []byte
+}
+
+func (self *NxmTunMetadata60) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata60) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata60) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata60(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata60, error) {
+	_nxmtunmetadata60 := &NxmTunMetadata60{Oxm: parent}
+	_nxmtunmetadata60.Value = decoder.Read(int(_nxmtunmetadata60.TypeLen & 0xFF))
+	return _nxmtunmetadata60, nil
+}
+
+func NewNxmTunMetadata60() *NxmTunMetadata60 {
+	obj := &NxmTunMetadata60{
+		Oxm: NewOxm(116860),
+	}
+	return obj
+}
+func (self *NxmTunMetadata60) GetOXMName() string {
+	return "tun_metadata60"
+}
+
+func (self *NxmTunMetadata60) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata60) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata60Masked struct {
+	*Oxm
+	Value     []byte
+	ValueMask []byte
+}
+
+type INxmTunMetadata60Masked interface {
+	goloxi.IOxm
+	GetValue() []byte
+	GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata60Masked) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata60Masked) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata60Masked) GetValueMask() []byte {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata60Masked) SetValueMask(v []byte) {
+	self.ValueMask = v
+}
+
+func (self *NxmTunMetadata60Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata60Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata60Masked, error) {
+	_nxmtunmetadata60masked := &NxmTunMetadata60Masked{Oxm: parent}
+	_nxmtunmetadata60masked.Value = decoder.Read(int(_nxmtunmetadata60masked.TypeLen & 0xFF))
+	_nxmtunmetadata60masked.ValueMask = decoder.Read(int(_nxmtunmetadata60masked.TypeLen & 0xFF))
+	return _nxmtunmetadata60masked, nil
+}
+
+func NewNxmTunMetadata60Masked() *NxmTunMetadata60Masked {
+	obj := &NxmTunMetadata60Masked{
+		Oxm: NewOxm(117240),
+	}
+	return obj
+}
+func (self *NxmTunMetadata60Masked) GetOXMName() string {
+	return "tun_metadata60_masked"
+}
+
+func (self *NxmTunMetadata60Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata60Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata60Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata61 struct {
+	*Oxm
+	Value []byte
+}
+
+type INxmTunMetadata61 interface {
+	goloxi.IOxm
+	GetValue() []byte
+}
+
+func (self *NxmTunMetadata61) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata61) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata61) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata61(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata61, error) {
+	_nxmtunmetadata61 := &NxmTunMetadata61{Oxm: parent}
+	_nxmtunmetadata61.Value = decoder.Read(int(_nxmtunmetadata61.TypeLen & 0xFF))
+	return _nxmtunmetadata61, nil
+}
+
+func NewNxmTunMetadata61() *NxmTunMetadata61 {
+	obj := &NxmTunMetadata61{
+		Oxm: NewOxm(117372),
+	}
+	return obj
+}
+func (self *NxmTunMetadata61) GetOXMName() string {
+	return "tun_metadata61"
+}
+
+func (self *NxmTunMetadata61) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata61) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata61Masked struct {
+	*Oxm
+	Value     []byte
+	ValueMask []byte
+}
+
+type INxmTunMetadata61Masked interface {
+	goloxi.IOxm
+	GetValue() []byte
+	GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata61Masked) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata61Masked) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata61Masked) GetValueMask() []byte {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata61Masked) SetValueMask(v []byte) {
+	self.ValueMask = v
+}
+
+func (self *NxmTunMetadata61Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata61Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata61Masked, error) {
+	_nxmtunmetadata61masked := &NxmTunMetadata61Masked{Oxm: parent}
+	_nxmtunmetadata61masked.Value = decoder.Read(int(_nxmtunmetadata61masked.TypeLen & 0xFF))
+	_nxmtunmetadata61masked.ValueMask = decoder.Read(int(_nxmtunmetadata61masked.TypeLen & 0xFF))
+	return _nxmtunmetadata61masked, nil
+}
+
+func NewNxmTunMetadata61Masked() *NxmTunMetadata61Masked {
+	obj := &NxmTunMetadata61Masked{
+		Oxm: NewOxm(117752),
+	}
+	return obj
+}
+func (self *NxmTunMetadata61Masked) GetOXMName() string {
+	return "tun_metadata61_masked"
+}
+
+func (self *NxmTunMetadata61Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata61Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata61Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata62 struct {
+	*Oxm
+	Value []byte
+}
+
+type INxmTunMetadata62 interface {
+	goloxi.IOxm
+	GetValue() []byte
+}
+
+func (self *NxmTunMetadata62) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata62) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata62) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata62(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata62, error) {
+	_nxmtunmetadata62 := &NxmTunMetadata62{Oxm: parent}
+	_nxmtunmetadata62.Value = decoder.Read(int(_nxmtunmetadata62.TypeLen & 0xFF))
+	return _nxmtunmetadata62, nil
+}
+
+func NewNxmTunMetadata62() *NxmTunMetadata62 {
+	obj := &NxmTunMetadata62{
+		Oxm: NewOxm(117884),
+	}
+	return obj
+}
+func (self *NxmTunMetadata62) GetOXMName() string {
+	return "tun_metadata62"
+}
+
+func (self *NxmTunMetadata62) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata62) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata62Masked struct {
+	*Oxm
+	Value     []byte
+	ValueMask []byte
+}
+
+type INxmTunMetadata62Masked interface {
+	goloxi.IOxm
+	GetValue() []byte
+	GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata62Masked) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata62Masked) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata62Masked) GetValueMask() []byte {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata62Masked) SetValueMask(v []byte) {
+	self.ValueMask = v
+}
+
+func (self *NxmTunMetadata62Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata62Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata62Masked, error) {
+	_nxmtunmetadata62masked := &NxmTunMetadata62Masked{Oxm: parent}
+	_nxmtunmetadata62masked.Value = decoder.Read(int(_nxmtunmetadata62masked.TypeLen & 0xFF))
+	_nxmtunmetadata62masked.ValueMask = decoder.Read(int(_nxmtunmetadata62masked.TypeLen & 0xFF))
+	return _nxmtunmetadata62masked, nil
+}
+
+func NewNxmTunMetadata62Masked() *NxmTunMetadata62Masked {
+	obj := &NxmTunMetadata62Masked{
+		Oxm: NewOxm(118264),
+	}
+	return obj
+}
+func (self *NxmTunMetadata62Masked) GetOXMName() string {
+	return "tun_metadata62_masked"
+}
+
+func (self *NxmTunMetadata62Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata62Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata62Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata63 struct {
+	*Oxm
+	Value []byte
+}
+
+type INxmTunMetadata63 interface {
+	goloxi.IOxm
+	GetValue() []byte
+}
+
+func (self *NxmTunMetadata63) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata63) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata63) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata63(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata63, error) {
+	_nxmtunmetadata63 := &NxmTunMetadata63{Oxm: parent}
+	_nxmtunmetadata63.Value = decoder.Read(int(_nxmtunmetadata63.TypeLen & 0xFF))
+	return _nxmtunmetadata63, nil
+}
+
+func NewNxmTunMetadata63() *NxmTunMetadata63 {
+	obj := &NxmTunMetadata63{
+		Oxm: NewOxm(118396),
+	}
+	return obj
+}
+func (self *NxmTunMetadata63) GetOXMName() string {
+	return "tun_metadata63"
+}
+
+func (self *NxmTunMetadata63) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata63) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata63Masked struct {
+	*Oxm
+	Value     []byte
+	ValueMask []byte
+}
+
+type INxmTunMetadata63Masked interface {
+	goloxi.IOxm
+	GetValue() []byte
+	GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata63Masked) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata63Masked) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata63Masked) GetValueMask() []byte {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata63Masked) SetValueMask(v []byte) {
+	self.ValueMask = v
+}
+
+func (self *NxmTunMetadata63Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata63Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata63Masked, error) {
+	_nxmtunmetadata63masked := &NxmTunMetadata63Masked{Oxm: parent}
+	_nxmtunmetadata63masked.Value = decoder.Read(int(_nxmtunmetadata63masked.TypeLen & 0xFF))
+	_nxmtunmetadata63masked.ValueMask = decoder.Read(int(_nxmtunmetadata63masked.TypeLen & 0xFF))
+	return _nxmtunmetadata63masked, nil
+}
+
+func NewNxmTunMetadata63Masked() *NxmTunMetadata63Masked {
+	obj := &NxmTunMetadata63Masked{
+		Oxm: NewOxm(118776),
+	}
+	return obj
+}
+func (self *NxmTunMetadata63Masked) GetOXMName() string {
+	return "tun_metadata63_masked"
+}
+
+func (self *NxmTunMetadata63Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata63Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata63Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata6Masked struct {
+	*Oxm
+	Value     []byte
+	ValueMask []byte
+}
+
+type INxmTunMetadata6Masked interface {
+	goloxi.IOxm
+	GetValue() []byte
+	GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata6Masked) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata6Masked) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata6Masked) GetValueMask() []byte {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata6Masked) SetValueMask(v []byte) {
+	self.ValueMask = v
+}
+
+func (self *NxmTunMetadata6Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata6Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata6Masked, error) {
+	_nxmtunmetadata6masked := &NxmTunMetadata6Masked{Oxm: parent}
+	_nxmtunmetadata6masked.Value = decoder.Read(int(_nxmtunmetadata6masked.TypeLen & 0xFF))
+	_nxmtunmetadata6masked.ValueMask = decoder.Read(int(_nxmtunmetadata6masked.TypeLen & 0xFF))
+	return _nxmtunmetadata6masked, nil
+}
+
+func NewNxmTunMetadata6Masked() *NxmTunMetadata6Masked {
+	obj := &NxmTunMetadata6Masked{
+		Oxm: NewOxm(89592),
+	}
+	return obj
+}
+func (self *NxmTunMetadata6Masked) GetOXMName() string {
+	return "tun_metadata6_masked"
+}
+
+func (self *NxmTunMetadata6Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata6Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata6Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata7 struct {
+	*Oxm
+	Value []byte
+}
+
+type INxmTunMetadata7 interface {
+	goloxi.IOxm
+	GetValue() []byte
+}
+
+func (self *NxmTunMetadata7) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata7) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata7) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata7(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata7, error) {
+	_nxmtunmetadata7 := &NxmTunMetadata7{Oxm: parent}
+	_nxmtunmetadata7.Value = decoder.Read(int(_nxmtunmetadata7.TypeLen & 0xFF))
+	return _nxmtunmetadata7, nil
+}
+
+func NewNxmTunMetadata7() *NxmTunMetadata7 {
+	obj := &NxmTunMetadata7{
+		Oxm: NewOxm(89724),
+	}
+	return obj
+}
+func (self *NxmTunMetadata7) GetOXMName() string {
+	return "tun_metadata7"
+}
+
+func (self *NxmTunMetadata7) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata7) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata7Masked struct {
+	*Oxm
+	Value     []byte
+	ValueMask []byte
+}
+
+type INxmTunMetadata7Masked interface {
+	goloxi.IOxm
+	GetValue() []byte
+	GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata7Masked) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata7Masked) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata7Masked) GetValueMask() []byte {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata7Masked) SetValueMask(v []byte) {
+	self.ValueMask = v
+}
+
+func (self *NxmTunMetadata7Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata7Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata7Masked, error) {
+	_nxmtunmetadata7masked := &NxmTunMetadata7Masked{Oxm: parent}
+	_nxmtunmetadata7masked.Value = decoder.Read(int(_nxmtunmetadata7masked.TypeLen & 0xFF))
+	_nxmtunmetadata7masked.ValueMask = decoder.Read(int(_nxmtunmetadata7masked.TypeLen & 0xFF))
+	return _nxmtunmetadata7masked, nil
+}
+
+func NewNxmTunMetadata7Masked() *NxmTunMetadata7Masked {
+	obj := &NxmTunMetadata7Masked{
+		Oxm: NewOxm(90104),
+	}
+	return obj
+}
+func (self *NxmTunMetadata7Masked) GetOXMName() string {
+	return "tun_metadata7_masked"
+}
+
+func (self *NxmTunMetadata7Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata7Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata7Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata8 struct {
+	*Oxm
+	Value []byte
+}
+
+type INxmTunMetadata8 interface {
+	goloxi.IOxm
+	GetValue() []byte
+}
+
+func (self *NxmTunMetadata8) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata8) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata8) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata8(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata8, error) {
+	_nxmtunmetadata8 := &NxmTunMetadata8{Oxm: parent}
+	_nxmtunmetadata8.Value = decoder.Read(int(_nxmtunmetadata8.TypeLen & 0xFF))
+	return _nxmtunmetadata8, nil
+}
+
+func NewNxmTunMetadata8() *NxmTunMetadata8 {
+	obj := &NxmTunMetadata8{
+		Oxm: NewOxm(90236),
+	}
+	return obj
+}
+func (self *NxmTunMetadata8) GetOXMName() string {
+	return "tun_metadata8"
+}
+
+func (self *NxmTunMetadata8) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata8) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata8Masked struct {
+	*Oxm
+	Value     []byte
+	ValueMask []byte
+}
+
+type INxmTunMetadata8Masked interface {
+	goloxi.IOxm
+	GetValue() []byte
+	GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata8Masked) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata8Masked) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata8Masked) GetValueMask() []byte {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata8Masked) SetValueMask(v []byte) {
+	self.ValueMask = v
+}
+
+func (self *NxmTunMetadata8Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata8Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata8Masked, error) {
+	_nxmtunmetadata8masked := &NxmTunMetadata8Masked{Oxm: parent}
+	_nxmtunmetadata8masked.Value = decoder.Read(int(_nxmtunmetadata8masked.TypeLen & 0xFF))
+	_nxmtunmetadata8masked.ValueMask = decoder.Read(int(_nxmtunmetadata8masked.TypeLen & 0xFF))
+	return _nxmtunmetadata8masked, nil
+}
+
+func NewNxmTunMetadata8Masked() *NxmTunMetadata8Masked {
+	obj := &NxmTunMetadata8Masked{
+		Oxm: NewOxm(90616),
+	}
+	return obj
+}
+func (self *NxmTunMetadata8Masked) GetOXMName() string {
+	return "tun_metadata8_masked"
+}
+
+func (self *NxmTunMetadata8Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata8Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata8Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunMetadata9 struct {
+	*Oxm
+	Value []byte
+}
+
+type INxmTunMetadata9 interface {
+	goloxi.IOxm
+	GetValue() []byte
+}
+
+func (self *NxmTunMetadata9) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata9) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata9) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata9(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata9, error) {
+	_nxmtunmetadata9 := &NxmTunMetadata9{Oxm: parent}
+	_nxmtunmetadata9.Value = decoder.Read(int(_nxmtunmetadata9.TypeLen & 0xFF))
+	return _nxmtunmetadata9, nil
+}
+
+func NewNxmTunMetadata9() *NxmTunMetadata9 {
+	obj := &NxmTunMetadata9{
+		Oxm: NewOxm(90748),
+	}
+	return obj
+}
+func (self *NxmTunMetadata9) GetOXMName() string {
+	return "tun_metadata9"
+}
+
+func (self *NxmTunMetadata9) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata9) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunMetadata9Masked struct {
+	*Oxm
+	Value     []byte
+	ValueMask []byte
+}
+
+type INxmTunMetadata9Masked interface {
+	goloxi.IOxm
+	GetValue() []byte
+	GetValueMask() []byte
+}
+
+func (self *NxmTunMetadata9Masked) GetValue() []byte {
+	return self.Value
+}
+
+func (self *NxmTunMetadata9Masked) SetValue(v []byte) {
+	self.Value = v
+}
+
+func (self *NxmTunMetadata9Masked) GetValueMask() []byte {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata9Masked) SetValueMask(v []byte) {
+	self.ValueMask = v
+}
+
+func (self *NxmTunMetadata9Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeNxmTunMetadata9Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata9Masked, error) {
+	_nxmtunmetadata9masked := &NxmTunMetadata9Masked{Oxm: parent}
+	_nxmtunmetadata9masked.Value = decoder.Read(int(_nxmtunmetadata9masked.TypeLen & 0xFF))
+	_nxmtunmetadata9masked.ValueMask = decoder.Read(int(_nxmtunmetadata9masked.TypeLen & 0xFF))
+	return _nxmtunmetadata9masked, nil
+}
+
+func NewNxmTunMetadata9Masked() *NxmTunMetadata9Masked {
+	obj := &NxmTunMetadata9Masked{
+		Oxm: NewOxm(91128),
+	}
+	return obj
+}
+func (self *NxmTunMetadata9Masked) GetOXMName() string {
+	return "tun_metadata9_masked"
+}
+
+func (self *NxmTunMetadata9Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunMetadata9Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmTunMetadata9Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmTunSrc struct {
+	*Oxm
+	Value net.IP
+}
+
+type INxmTunSrc interface {
+	goloxi.IOxm
+	GetValue() net.IP
+}
+
+func (self *NxmTunSrc) GetValue() net.IP {
+	return self.Value
+}
+
+func (self *NxmTunSrc) SetValue(v net.IP) {
+	self.Value = v
+}
+
+func (self *NxmTunSrc) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value.To4())
+
+	return nil
+}
+
+func DecodeNxmTunSrc(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunSrc, error) {
+	_nxmtunsrc := &NxmTunSrc{Oxm: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("NxmTunSrc packet too short: %d < 4", decoder.Length())
+	}
+	_nxmtunsrc.Value = net.IP(decoder.Read(4))
+	return _nxmtunsrc, nil
+}
+
+func NewNxmTunSrc() *NxmTunSrc {
+	obj := &NxmTunSrc{
+		Oxm: NewOxm(81412),
+	}
+	return obj
+}
+func (self *NxmTunSrc) GetOXMName() string {
+	return "tun_src"
+}
+
+func (self *NxmTunSrc) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunSrc) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmTunSrcMasked struct {
+	*Oxm
+	Value     net.IP
+	ValueMask net.IP
+}
+
+type INxmTunSrcMasked interface {
+	goloxi.IOxm
+	GetValue() net.IP
+	GetValueMask() net.IP
+}
+
+func (self *NxmTunSrcMasked) GetValue() net.IP {
+	return self.Value
+}
+
+func (self *NxmTunSrcMasked) SetValue(v net.IP) {
+	self.Value = v
+}
+
+func (self *NxmTunSrcMasked) GetValueMask() net.IP {
+	return self.ValueMask
+}
+
+func (self *NxmTunSrcMasked) SetValueMask(v net.IP) {
+	self.ValueMask = v
+}
+
+func (self *NxmTunSrcMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value.To4())
+	encoder.Write(self.ValueMask.To4())
+
+	return nil
+}
+
+func DecodeNxmTunSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunSrcMasked, error) {
+	_nxmtunsrcmasked := &NxmTunSrcMasked{Oxm: parent}
+	if decoder.Length() < 8 {
+		return nil, fmt.Errorf("NxmTunSrcMasked packet too short: %d < 8", decoder.Length())
+	}
+	_nxmtunsrcmasked.Value = net.IP(decoder.Read(4))
+	_nxmtunsrcmasked.ValueMask = net.IP(decoder.Read(4))
+	return _nxmtunsrcmasked, nil
+}
+
+func NewNxmTunSrcMasked() *NxmTunSrcMasked {
+	obj := &NxmTunSrcMasked{
+		Oxm: NewOxm(81672),
+	}
+	return obj
+}
+func (self *NxmTunSrcMasked) GetOXMName() string {
+	return "tun_src_masked"
+}
+
+func (self *NxmTunSrcMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmTunSrcMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmTunSrcMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmUdpDst struct {
+	*Oxm
+	Value uint16
+}
+
+type INxmUdpDst interface {
+	goloxi.IOxm
+	GetValue() uint16
+}
+
+func (self *NxmUdpDst) GetValue() uint16 {
+	return self.Value
+}
+
+func (self *NxmUdpDst) SetValue(v uint16) {
+	self.Value = v
+}
+
+func (self *NxmUdpDst) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Value))
+
+	return nil
+}
+
+func DecodeNxmUdpDst(parent *Oxm, decoder *goloxi.Decoder) (*NxmUdpDst, error) {
+	_nxmudpdst := &NxmUdpDst{Oxm: parent}
+	if decoder.Length() < 2 {
+		return nil, fmt.Errorf("NxmUdpDst packet too short: %d < 2", decoder.Length())
+	}
+	_nxmudpdst.Value = uint16(decoder.ReadUint16())
+	return _nxmudpdst, nil
+}
+
+func NewNxmUdpDst() *NxmUdpDst {
+	obj := &NxmUdpDst{
+		Oxm: NewOxm(6146),
+	}
+	return obj
+}
+func (self *NxmUdpDst) GetOXMName() string {
+	return "udp_dst"
+}
+
+func (self *NxmUdpDst) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmUdpDst) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmUdpDstMasked struct {
+	*Oxm
+	Value     uint16
+	ValueMask uint16
+}
+
+type INxmUdpDstMasked interface {
+	goloxi.IOxm
+	GetValue() uint16
+	GetValueMask() uint16
+}
+
+func (self *NxmUdpDstMasked) GetValue() uint16 {
+	return self.Value
+}
+
+func (self *NxmUdpDstMasked) SetValue(v uint16) {
+	self.Value = v
+}
+
+func (self *NxmUdpDstMasked) GetValueMask() uint16 {
+	return self.ValueMask
+}
+
+func (self *NxmUdpDstMasked) SetValueMask(v uint16) {
+	self.ValueMask = v
+}
+
+func (self *NxmUdpDstMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Value))
+	encoder.PutUint16(uint16(self.ValueMask))
+
+	return nil
+}
+
+func DecodeNxmUdpDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmUdpDstMasked, error) {
+	_nxmudpdstmasked := &NxmUdpDstMasked{Oxm: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("NxmUdpDstMasked packet too short: %d < 4", decoder.Length())
+	}
+	_nxmudpdstmasked.Value = uint16(decoder.ReadUint16())
+	_nxmudpdstmasked.ValueMask = uint16(decoder.ReadUint16())
+	return _nxmudpdstmasked, nil
+}
+
+func NewNxmUdpDstMasked() *NxmUdpDstMasked {
+	obj := &NxmUdpDstMasked{
+		Oxm: NewOxm(6404),
+	}
+	return obj
+}
+func (self *NxmUdpDstMasked) GetOXMName() string {
+	return "udp_dst_masked"
+}
+
+func (self *NxmUdpDstMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmUdpDstMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmUdpDstMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmUdpSrc struct {
+	*Oxm
+	Value uint16
+}
+
+type INxmUdpSrc interface {
+	goloxi.IOxm
+	GetValue() uint16
+}
+
+func (self *NxmUdpSrc) GetValue() uint16 {
+	return self.Value
+}
+
+func (self *NxmUdpSrc) SetValue(v uint16) {
+	self.Value = v
+}
+
+func (self *NxmUdpSrc) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Value))
+
+	return nil
+}
+
+func DecodeNxmUdpSrc(parent *Oxm, decoder *goloxi.Decoder) (*NxmUdpSrc, error) {
+	_nxmudpsrc := &NxmUdpSrc{Oxm: parent}
+	if decoder.Length() < 2 {
+		return nil, fmt.Errorf("NxmUdpSrc packet too short: %d < 2", decoder.Length())
+	}
+	_nxmudpsrc.Value = uint16(decoder.ReadUint16())
+	return _nxmudpsrc, nil
+}
+
+func NewNxmUdpSrc() *NxmUdpSrc {
+	obj := &NxmUdpSrc{
+		Oxm: NewOxm(5634),
+	}
+	return obj
+}
+func (self *NxmUdpSrc) GetOXMName() string {
+	return "udp_src"
+}
+
+func (self *NxmUdpSrc) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmUdpSrc) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmUdpSrcMasked struct {
+	*Oxm
+	Value     uint16
+	ValueMask uint16
+}
+
+type INxmUdpSrcMasked interface {
+	goloxi.IOxm
+	GetValue() uint16
+	GetValueMask() uint16
+}
+
+func (self *NxmUdpSrcMasked) GetValue() uint16 {
+	return self.Value
+}
+
+func (self *NxmUdpSrcMasked) SetValue(v uint16) {
+	self.Value = v
+}
+
+func (self *NxmUdpSrcMasked) GetValueMask() uint16 {
+	return self.ValueMask
+}
+
+func (self *NxmUdpSrcMasked) SetValueMask(v uint16) {
+	self.ValueMask = v
+}
+
+func (self *NxmUdpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Value))
+	encoder.PutUint16(uint16(self.ValueMask))
+
+	return nil
+}
+
+func DecodeNxmUdpSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmUdpSrcMasked, error) {
+	_nxmudpsrcmasked := &NxmUdpSrcMasked{Oxm: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("NxmUdpSrcMasked packet too short: %d < 4", decoder.Length())
+	}
+	_nxmudpsrcmasked.Value = uint16(decoder.ReadUint16())
+	_nxmudpsrcmasked.ValueMask = uint16(decoder.ReadUint16())
+	return _nxmudpsrcmasked, nil
+}
+
+func NewNxmUdpSrcMasked() *NxmUdpSrcMasked {
+	obj := &NxmUdpSrcMasked{
+		Oxm: NewOxm(5892),
+	}
+	return obj
+}
+func (self *NxmUdpSrcMasked) GetOXMName() string {
+	return "udp_src_masked"
+}
+
+func (self *NxmUdpSrcMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmUdpSrcMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmUdpSrcMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmVlanTci struct {
+	*Oxm
+	Value uint16
+}
+
+type INxmVlanTci interface {
+	goloxi.IOxm
+	GetValue() uint16
+}
+
+func (self *NxmVlanTci) GetValue() uint16 {
+	return self.Value
+}
+
+func (self *NxmVlanTci) SetValue(v uint16) {
+	self.Value = v
+}
+
+func (self *NxmVlanTci) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Value))
+
+	return nil
+}
+
+func DecodeNxmVlanTci(parent *Oxm, decoder *goloxi.Decoder) (*NxmVlanTci, error) {
+	_nxmvlantci := &NxmVlanTci{Oxm: parent}
+	if decoder.Length() < 2 {
+		return nil, fmt.Errorf("NxmVlanTci packet too short: %d < 2", decoder.Length())
+	}
+	_nxmvlantci.Value = uint16(decoder.ReadUint16())
+	return _nxmvlantci, nil
+}
+
+func NewNxmVlanTci() *NxmVlanTci {
+	obj := &NxmVlanTci{
+		Oxm: NewOxm(2050),
+	}
+	return obj
+}
+func (self *NxmVlanTci) GetOXMName() string {
+	return "vlan_tci"
+}
+
+func (self *NxmVlanTci) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmVlanTci) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmVlanTciMasked struct {
+	*Oxm
+	Value     uint16
+	ValueMask uint16
+}
+
+type INxmVlanTciMasked interface {
+	goloxi.IOxm
+	GetValue() uint16
+	GetValueMask() uint16
+}
+
+func (self *NxmVlanTciMasked) GetValue() uint16 {
+	return self.Value
+}
+
+func (self *NxmVlanTciMasked) SetValue(v uint16) {
+	self.Value = v
+}
+
+func (self *NxmVlanTciMasked) GetValueMask() uint16 {
+	return self.ValueMask
+}
+
+func (self *NxmVlanTciMasked) SetValueMask(v uint16) {
+	self.ValueMask = v
+}
+
+func (self *NxmVlanTciMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Value))
+	encoder.PutUint16(uint16(self.ValueMask))
+
+	return nil
+}
+
+func DecodeNxmVlanTciMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmVlanTciMasked, error) {
+	_nxmvlantcimasked := &NxmVlanTciMasked{Oxm: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("NxmVlanTciMasked packet too short: %d < 4", decoder.Length())
+	}
+	_nxmvlantcimasked.Value = uint16(decoder.ReadUint16())
+	_nxmvlantcimasked.ValueMask = uint16(decoder.ReadUint16())
+	return _nxmvlantcimasked, nil
+}
+
+func NewNxmVlanTciMasked() *NxmVlanTciMasked {
+	obj := &NxmVlanTciMasked{
+		Oxm: NewOxm(2308),
+	}
+	return obj
+}
+func (self *NxmVlanTciMasked) GetOXMName() string {
+	return "vlan_tci_masked"
+}
+
+func (self *NxmVlanTciMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmVlanTciMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmVlanTciMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmXxreg0 struct {
+	*Oxm
+	Value uint128
+}
+
+type INxmXxreg0 interface {
+	goloxi.IOxm
+	GetValue() uint128
+}
+
+func (self *NxmXxreg0) GetValue() uint128 {
+	return self.Value
+}
+
+func (self *NxmXxreg0) SetValue(v uint128) {
+	self.Value = v
+}
+
+func (self *NxmXxreg0) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint128(uint128(self.Value))
+
+	return nil
+}
+
+func DecodeNxmXxreg0(parent *Oxm, decoder *goloxi.Decoder) (*NxmXxreg0, error) {
+	_nxmxxreg0 := &NxmXxreg0{Oxm: parent}
+	if decoder.Length() < 16 {
+		return nil, fmt.Errorf("NxmXxreg0 packet too short: %d < 16", decoder.Length())
+	}
+	_nxmxxreg0.Value = uint128(decoder.ReadUint128())
+	return _nxmxxreg0, nil
+}
+
+func NewNxmXxreg0() *NxmXxreg0 {
+	obj := &NxmXxreg0{
+		Oxm: NewOxm(122384),
+	}
+	return obj
+}
+func (self *NxmXxreg0) GetOXMName() string {
+	return "xxreg0"
+}
+
+func (self *NxmXxreg0) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmXxreg0) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmXxreg0Masked struct {
+	*Oxm
+	Value     uint128
+	ValueMask uint128
+}
+
+type INxmXxreg0Masked interface {
+	goloxi.IOxm
+	GetValue() uint128
+	GetValueMask() uint128
+}
+
+func (self *NxmXxreg0Masked) GetValue() uint128 {
+	return self.Value
+}
+
+func (self *NxmXxreg0Masked) SetValue(v uint128) {
+	self.Value = v
+}
+
+func (self *NxmXxreg0Masked) GetValueMask() uint128 {
+	return self.ValueMask
+}
+
+func (self *NxmXxreg0Masked) SetValueMask(v uint128) {
+	self.ValueMask = v
+}
+
+func (self *NxmXxreg0Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint128(uint128(self.Value))
+	encoder.PutUint128(uint128(self.ValueMask))
+
+	return nil
+}
+
+func DecodeNxmXxreg0Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmXxreg0Masked, error) {
+	_nxmxxreg0masked := &NxmXxreg0Masked{Oxm: parent}
+	if decoder.Length() < 32 {
+		return nil, fmt.Errorf("NxmXxreg0Masked packet too short: %d < 32", decoder.Length())
+	}
+	_nxmxxreg0masked.Value = uint128(decoder.ReadUint128())
+	_nxmxxreg0masked.ValueMask = uint128(decoder.ReadUint128())
+	return _nxmxxreg0masked, nil
+}
+
+func NewNxmXxreg0Masked() *NxmXxreg0Masked {
+	obj := &NxmXxreg0Masked{
+		Oxm: NewOxm(122656),
+	}
+	return obj
+}
+func (self *NxmXxreg0Masked) GetOXMName() string {
+	return "xxreg0_masked"
+}
+
+func (self *NxmXxreg0Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmXxreg0Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmXxreg0Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmXxreg1 struct {
+	*Oxm
+	Value uint128
+}
+
+type INxmXxreg1 interface {
+	goloxi.IOxm
+	GetValue() uint128
+}
+
+func (self *NxmXxreg1) GetValue() uint128 {
+	return self.Value
+}
+
+func (self *NxmXxreg1) SetValue(v uint128) {
+	self.Value = v
+}
+
+func (self *NxmXxreg1) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint128(uint128(self.Value))
+
+	return nil
+}
+
+func DecodeNxmXxreg1(parent *Oxm, decoder *goloxi.Decoder) (*NxmXxreg1, error) {
+	_nxmxxreg1 := &NxmXxreg1{Oxm: parent}
+	if decoder.Length() < 16 {
+		return nil, fmt.Errorf("NxmXxreg1 packet too short: %d < 16", decoder.Length())
+	}
+	_nxmxxreg1.Value = uint128(decoder.ReadUint128())
+	return _nxmxxreg1, nil
+}
+
+func NewNxmXxreg1() *NxmXxreg1 {
+	obj := &NxmXxreg1{
+		Oxm: NewOxm(122896),
+	}
+	return obj
+}
+func (self *NxmXxreg1) GetOXMName() string {
+	return "xxreg1"
+}
+
+func (self *NxmXxreg1) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmXxreg1) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmXxreg1Masked struct {
+	*Oxm
+	Value     uint128
+	ValueMask uint128
+}
+
+type INxmXxreg1Masked interface {
+	goloxi.IOxm
+	GetValue() uint128
+	GetValueMask() uint128
+}
+
+func (self *NxmXxreg1Masked) GetValue() uint128 {
+	return self.Value
+}
+
+func (self *NxmXxreg1Masked) SetValue(v uint128) {
+	self.Value = v
+}
+
+func (self *NxmXxreg1Masked) GetValueMask() uint128 {
+	return self.ValueMask
+}
+
+func (self *NxmXxreg1Masked) SetValueMask(v uint128) {
+	self.ValueMask = v
+}
+
+func (self *NxmXxreg1Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint128(uint128(self.Value))
+	encoder.PutUint128(uint128(self.ValueMask))
+
+	return nil
+}
+
+func DecodeNxmXxreg1Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmXxreg1Masked, error) {
+	_nxmxxreg1masked := &NxmXxreg1Masked{Oxm: parent}
+	if decoder.Length() < 32 {
+		return nil, fmt.Errorf("NxmXxreg1Masked packet too short: %d < 32", decoder.Length())
+	}
+	_nxmxxreg1masked.Value = uint128(decoder.ReadUint128())
+	_nxmxxreg1masked.ValueMask = uint128(decoder.ReadUint128())
+	return _nxmxxreg1masked, nil
+}
+
+func NewNxmXxreg1Masked() *NxmXxreg1Masked {
+	obj := &NxmXxreg1Masked{
+		Oxm: NewOxm(123168),
+	}
+	return obj
+}
+func (self *NxmXxreg1Masked) GetOXMName() string {
+	return "xxreg1_masked"
+}
+
+func (self *NxmXxreg1Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmXxreg1Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmXxreg1Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmXxreg2 struct {
+	*Oxm
+	Value uint128
+}
+
+type INxmXxreg2 interface {
+	goloxi.IOxm
+	GetValue() uint128
+}
+
+func (self *NxmXxreg2) GetValue() uint128 {
+	return self.Value
+}
+
+func (self *NxmXxreg2) SetValue(v uint128) {
+	self.Value = v
+}
+
+func (self *NxmXxreg2) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint128(uint128(self.Value))
+
+	return nil
+}
+
+func DecodeNxmXxreg2(parent *Oxm, decoder *goloxi.Decoder) (*NxmXxreg2, error) {
+	_nxmxxreg2 := &NxmXxreg2{Oxm: parent}
+	if decoder.Length() < 16 {
+		return nil, fmt.Errorf("NxmXxreg2 packet too short: %d < 16", decoder.Length())
+	}
+	_nxmxxreg2.Value = uint128(decoder.ReadUint128())
+	return _nxmxxreg2, nil
+}
+
+func NewNxmXxreg2() *NxmXxreg2 {
+	obj := &NxmXxreg2{
+		Oxm: NewOxm(123408),
+	}
+	return obj
+}
+func (self *NxmXxreg2) GetOXMName() string {
+	return "xxreg2"
+}
+
+func (self *NxmXxreg2) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmXxreg2) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmXxreg2Masked struct {
+	*Oxm
+	Value     uint128
+	ValueMask uint128
+}
+
+type INxmXxreg2Masked interface {
+	goloxi.IOxm
+	GetValue() uint128
+	GetValueMask() uint128
+}
+
+func (self *NxmXxreg2Masked) GetValue() uint128 {
+	return self.Value
+}
+
+func (self *NxmXxreg2Masked) SetValue(v uint128) {
+	self.Value = v
+}
+
+func (self *NxmXxreg2Masked) GetValueMask() uint128 {
+	return self.ValueMask
+}
+
+func (self *NxmXxreg2Masked) SetValueMask(v uint128) {
+	self.ValueMask = v
+}
+
+func (self *NxmXxreg2Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint128(uint128(self.Value))
+	encoder.PutUint128(uint128(self.ValueMask))
+
+	return nil
+}
+
+func DecodeNxmXxreg2Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmXxreg2Masked, error) {
+	_nxmxxreg2masked := &NxmXxreg2Masked{Oxm: parent}
+	if decoder.Length() < 32 {
+		return nil, fmt.Errorf("NxmXxreg2Masked packet too short: %d < 32", decoder.Length())
+	}
+	_nxmxxreg2masked.Value = uint128(decoder.ReadUint128())
+	_nxmxxreg2masked.ValueMask = uint128(decoder.ReadUint128())
+	return _nxmxxreg2masked, nil
+}
+
+func NewNxmXxreg2Masked() *NxmXxreg2Masked {
+	obj := &NxmXxreg2Masked{
+		Oxm: NewOxm(123680),
+	}
+	return obj
+}
+func (self *NxmXxreg2Masked) GetOXMName() string {
+	return "xxreg2_masked"
+}
+
+func (self *NxmXxreg2Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmXxreg2Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmXxreg2Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type NxmXxreg3 struct {
+	*Oxm
+	Value uint128
+}
+
+type INxmXxreg3 interface {
+	goloxi.IOxm
+	GetValue() uint128
+}
+
+func (self *NxmXxreg3) GetValue() uint128 {
+	return self.Value
+}
+
+func (self *NxmXxreg3) SetValue(v uint128) {
+	self.Value = v
+}
+
+func (self *NxmXxreg3) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint128(uint128(self.Value))
+
+	return nil
+}
+
+func DecodeNxmXxreg3(parent *Oxm, decoder *goloxi.Decoder) (*NxmXxreg3, error) {
+	_nxmxxreg3 := &NxmXxreg3{Oxm: parent}
+	if decoder.Length() < 16 {
+		return nil, fmt.Errorf("NxmXxreg3 packet too short: %d < 16", decoder.Length())
+	}
+	_nxmxxreg3.Value = uint128(decoder.ReadUint128())
+	return _nxmxxreg3, nil
+}
+
+func NewNxmXxreg3() *NxmXxreg3 {
+	obj := &NxmXxreg3{
+		Oxm: NewOxm(123920),
+	}
+	return obj
+}
+func (self *NxmXxreg3) GetOXMName() string {
+	return "xxreg3"
+}
+
+func (self *NxmXxreg3) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmXxreg3) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type NxmXxreg3Masked struct {
+	*Oxm
+	Value     uint128
+	ValueMask uint128
+}
+
+type INxmXxreg3Masked interface {
+	goloxi.IOxm
+	GetValue() uint128
+	GetValueMask() uint128
+}
+
+func (self *NxmXxreg3Masked) GetValue() uint128 {
+	return self.Value
+}
+
+func (self *NxmXxreg3Masked) SetValue(v uint128) {
+	self.Value = v
+}
+
+func (self *NxmXxreg3Masked) GetValueMask() uint128 {
+	return self.ValueMask
+}
+
+func (self *NxmXxreg3Masked) SetValueMask(v uint128) {
+	self.ValueMask = v
+}
+
+func (self *NxmXxreg3Masked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint128(uint128(self.Value))
+	encoder.PutUint128(uint128(self.ValueMask))
+
+	return nil
+}
+
+func DecodeNxmXxreg3Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmXxreg3Masked, error) {
+	_nxmxxreg3masked := &NxmXxreg3Masked{Oxm: parent}
+	if decoder.Length() < 32 {
+		return nil, fmt.Errorf("NxmXxreg3Masked packet too short: %d < 32", decoder.Length())
+	}
+	_nxmxxreg3masked.Value = uint128(decoder.ReadUint128())
+	_nxmxxreg3masked.ValueMask = uint128(decoder.ReadUint128())
+	return _nxmxxreg3masked, nil
+}
+
+func NewNxmXxreg3Masked() *NxmXxreg3Masked {
+	obj := &NxmXxreg3Masked{
+		Oxm: NewOxm(124192),
+	}
+	return obj
+}
+func (self *NxmXxreg3Masked) GetOXMName() string {
+	return "xxreg3_masked"
+}
+
+func (self *NxmXxreg3Masked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *NxmXxreg3Masked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *NxmXxreg3Masked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmArpOp struct {
+	*Oxm
+	Value uint16
+}
+
+type IOxmArpOp interface {
+	goloxi.IOxm
+	GetValue() uint16
+}
+
+func (self *OxmArpOp) GetValue() uint16 {
+	return self.Value
+}
+
+func (self *OxmArpOp) SetValue(v uint16) {
+	self.Value = v
+}
+
+func (self *OxmArpOp) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Value))
+
+	return nil
+}
+
+func DecodeOxmArpOp(parent *Oxm, decoder *goloxi.Decoder) (*OxmArpOp, error) {
+	_oxmarpop := &OxmArpOp{Oxm: parent}
+	if decoder.Length() < 2 {
+		return nil, fmt.Errorf("OxmArpOp packet too short: %d < 2", decoder.Length())
+	}
+	_oxmarpop.Value = uint16(decoder.ReadUint16())
+	return _oxmarpop, nil
+}
+
+func NewOxmArpOp() *OxmArpOp {
+	obj := &OxmArpOp{
+		Oxm: NewOxm(2147494402),
+	}
+	return obj
+}
+func (self *OxmArpOp) GetOXMName() string {
+	return "arp_op"
+}
+
+func (self *OxmArpOp) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmArpOp) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmArpOpMasked struct {
+	*Oxm
+	Value     uint16
+	ValueMask uint16
+}
+
+type IOxmArpOpMasked interface {
+	goloxi.IOxm
+	GetValue() uint16
+	GetValueMask() uint16
+}
+
+func (self *OxmArpOpMasked) GetValue() uint16 {
+	return self.Value
+}
+
+func (self *OxmArpOpMasked) SetValue(v uint16) {
+	self.Value = v
+}
+
+func (self *OxmArpOpMasked) GetValueMask() uint16 {
+	return self.ValueMask
+}
+
+func (self *OxmArpOpMasked) SetValueMask(v uint16) {
+	self.ValueMask = v
+}
+
+func (self *OxmArpOpMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Value))
+	encoder.PutUint16(uint16(self.ValueMask))
+
+	return nil
+}
+
+func DecodeOxmArpOpMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmArpOpMasked, error) {
+	_oxmarpopmasked := &OxmArpOpMasked{Oxm: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("OxmArpOpMasked packet too short: %d < 4", decoder.Length())
+	}
+	_oxmarpopmasked.Value = uint16(decoder.ReadUint16())
+	_oxmarpopmasked.ValueMask = uint16(decoder.ReadUint16())
+	return _oxmarpopmasked, nil
+}
+
+func NewOxmArpOpMasked() *OxmArpOpMasked {
+	obj := &OxmArpOpMasked{
+		Oxm: NewOxm(2147494660),
+	}
+	return obj
+}
+func (self *OxmArpOpMasked) GetOXMName() string {
+	return "arp_op_masked"
+}
+
+func (self *OxmArpOpMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmArpOpMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *OxmArpOpMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmArpSha struct {
+	*Oxm
+	Value net.HardwareAddr
+}
+
+type IOxmArpSha interface {
+	goloxi.IOxm
+	GetValue() net.HardwareAddr
+}
+
+func (self *OxmArpSha) GetValue() net.HardwareAddr {
+	return self.Value
+}
+
+func (self *OxmArpSha) SetValue(v net.HardwareAddr) {
+	self.Value = v
+}
+
+func (self *OxmArpSha) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeOxmArpSha(parent *Oxm, decoder *goloxi.Decoder) (*OxmArpSha, error) {
+	_oxmarpsha := &OxmArpSha{Oxm: parent}
+	if decoder.Length() < 6 {
+		return nil, fmt.Errorf("OxmArpSha packet too short: %d < 6", decoder.Length())
+	}
+	_oxmarpsha.Value = net.HardwareAddr(decoder.Read(6))
+	return _oxmarpsha, nil
+}
+
+func NewOxmArpSha() *OxmArpSha {
+	obj := &OxmArpSha{
+		Oxm: NewOxm(2147495942),
+	}
+	return obj
+}
+func (self *OxmArpSha) GetOXMName() string {
+	return "arp_sha"
+}
+
+func (self *OxmArpSha) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmArpSha) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmArpShaMasked struct {
+	*Oxm
+	Value     net.HardwareAddr
+	ValueMask net.HardwareAddr
+}
+
+type IOxmArpShaMasked interface {
+	goloxi.IOxm
+	GetValue() net.HardwareAddr
+	GetValueMask() net.HardwareAddr
+}
+
+func (self *OxmArpShaMasked) GetValue() net.HardwareAddr {
+	return self.Value
+}
+
+func (self *OxmArpShaMasked) SetValue(v net.HardwareAddr) {
+	self.Value = v
+}
+
+func (self *OxmArpShaMasked) GetValueMask() net.HardwareAddr {
+	return self.ValueMask
+}
+
+func (self *OxmArpShaMasked) SetValueMask(v net.HardwareAddr) {
+	self.ValueMask = v
+}
+
+func (self *OxmArpShaMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeOxmArpShaMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmArpShaMasked, error) {
+	_oxmarpshamasked := &OxmArpShaMasked{Oxm: parent}
+	if decoder.Length() < 12 {
+		return nil, fmt.Errorf("OxmArpShaMasked packet too short: %d < 12", decoder.Length())
+	}
+	_oxmarpshamasked.Value = net.HardwareAddr(decoder.Read(6))
+	_oxmarpshamasked.ValueMask = net.HardwareAddr(decoder.Read(6))
+	return _oxmarpshamasked, nil
+}
+
+func NewOxmArpShaMasked() *OxmArpShaMasked {
+	obj := &OxmArpShaMasked{
+		Oxm: NewOxm(2147496204),
+	}
+	return obj
+}
+func (self *OxmArpShaMasked) GetOXMName() string {
+	return "arp_sha_masked"
+}
+
+func (self *OxmArpShaMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmArpShaMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *OxmArpShaMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmArpSpa struct {
+	*Oxm
+	Value uint32
+}
+
+type IOxmArpSpa interface {
+	goloxi.IOxm
+	GetValue() uint32
+}
+
+func (self *OxmArpSpa) GetValue() uint32 {
+	return self.Value
+}
+
+func (self *OxmArpSpa) SetValue(v uint32) {
+	self.Value = v
+}
+
+func (self *OxmArpSpa) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Value))
+
+	return nil
+}
+
+func DecodeOxmArpSpa(parent *Oxm, decoder *goloxi.Decoder) (*OxmArpSpa, error) {
+	_oxmarpspa := &OxmArpSpa{Oxm: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("OxmArpSpa packet too short: %d < 4", decoder.Length())
+	}
+	_oxmarpspa.Value = uint32(decoder.ReadUint32())
+	return _oxmarpspa, nil
+}
+
+func NewOxmArpSpa() *OxmArpSpa {
+	obj := &OxmArpSpa{
+		Oxm: NewOxm(2147494916),
+	}
+	return obj
+}
+func (self *OxmArpSpa) GetOXMName() string {
+	return "arp_spa"
+}
+
+func (self *OxmArpSpa) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmArpSpa) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmArpSpaMasked struct {
+	*Oxm
+	Value     uint32
+	ValueMask uint32
+}
+
+type IOxmArpSpaMasked interface {
+	goloxi.IOxm
+	GetValue() uint32
+	GetValueMask() uint32
+}
+
+func (self *OxmArpSpaMasked) GetValue() uint32 {
+	return self.Value
+}
+
+func (self *OxmArpSpaMasked) SetValue(v uint32) {
+	self.Value = v
+}
+
+func (self *OxmArpSpaMasked) GetValueMask() uint32 {
+	return self.ValueMask
+}
+
+func (self *OxmArpSpaMasked) SetValueMask(v uint32) {
+	self.ValueMask = v
+}
+
+func (self *OxmArpSpaMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Value))
+	encoder.PutUint32(uint32(self.ValueMask))
+
+	return nil
+}
+
+func DecodeOxmArpSpaMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmArpSpaMasked, error) {
+	_oxmarpspamasked := &OxmArpSpaMasked{Oxm: parent}
+	if decoder.Length() < 8 {
+		return nil, fmt.Errorf("OxmArpSpaMasked packet too short: %d < 8", decoder.Length())
+	}
+	_oxmarpspamasked.Value = uint32(decoder.ReadUint32())
+	_oxmarpspamasked.ValueMask = uint32(decoder.ReadUint32())
+	return _oxmarpspamasked, nil
+}
+
+func NewOxmArpSpaMasked() *OxmArpSpaMasked {
+	obj := &OxmArpSpaMasked{
+		Oxm: NewOxm(2147495176),
+	}
+	return obj
+}
+func (self *OxmArpSpaMasked) GetOXMName() string {
+	return "arp_spa_masked"
+}
+
+func (self *OxmArpSpaMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmArpSpaMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *OxmArpSpaMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmArpTha struct {
+	*Oxm
+	Value net.HardwareAddr
+}
+
+type IOxmArpTha interface {
+	goloxi.IOxm
+	GetValue() net.HardwareAddr
+}
+
+func (self *OxmArpTha) GetValue() net.HardwareAddr {
+	return self.Value
+}
+
+func (self *OxmArpTha) SetValue(v net.HardwareAddr) {
+	self.Value = v
+}
+
+func (self *OxmArpTha) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeOxmArpTha(parent *Oxm, decoder *goloxi.Decoder) (*OxmArpTha, error) {
+	_oxmarptha := &OxmArpTha{Oxm: parent}
+	if decoder.Length() < 6 {
+		return nil, fmt.Errorf("OxmArpTha packet too short: %d < 6", decoder.Length())
+	}
+	_oxmarptha.Value = net.HardwareAddr(decoder.Read(6))
+	return _oxmarptha, nil
+}
+
+func NewOxmArpTha() *OxmArpTha {
+	obj := &OxmArpTha{
+		Oxm: NewOxm(2147496454),
+	}
+	return obj
+}
+func (self *OxmArpTha) GetOXMName() string {
+	return "arp_tha"
+}
+
+func (self *OxmArpTha) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmArpTha) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmArpThaMasked struct {
+	*Oxm
+	Value     net.HardwareAddr
+	ValueMask net.HardwareAddr
+}
+
+type IOxmArpThaMasked interface {
+	goloxi.IOxm
+	GetValue() net.HardwareAddr
+	GetValueMask() net.HardwareAddr
+}
+
+func (self *OxmArpThaMasked) GetValue() net.HardwareAddr {
+	return self.Value
+}
+
+func (self *OxmArpThaMasked) SetValue(v net.HardwareAddr) {
+	self.Value = v
+}
+
+func (self *OxmArpThaMasked) GetValueMask() net.HardwareAddr {
+	return self.ValueMask
+}
+
+func (self *OxmArpThaMasked) SetValueMask(v net.HardwareAddr) {
+	self.ValueMask = v
+}
+
+func (self *OxmArpThaMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeOxmArpThaMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmArpThaMasked, error) {
+	_oxmarpthamasked := &OxmArpThaMasked{Oxm: parent}
+	if decoder.Length() < 12 {
+		return nil, fmt.Errorf("OxmArpThaMasked packet too short: %d < 12", decoder.Length())
+	}
+	_oxmarpthamasked.Value = net.HardwareAddr(decoder.Read(6))
+	_oxmarpthamasked.ValueMask = net.HardwareAddr(decoder.Read(6))
+	return _oxmarpthamasked, nil
+}
+
+func NewOxmArpThaMasked() *OxmArpThaMasked {
+	obj := &OxmArpThaMasked{
+		Oxm: NewOxm(2147496716),
+	}
+	return obj
+}
+func (self *OxmArpThaMasked) GetOXMName() string {
+	return "arp_tha_masked"
+}
+
+func (self *OxmArpThaMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmArpThaMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *OxmArpThaMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmArpTpa struct {
+	*Oxm
+	Value uint32
+}
+
+type IOxmArpTpa interface {
+	goloxi.IOxm
+	GetValue() uint32
+}
+
+func (self *OxmArpTpa) GetValue() uint32 {
+	return self.Value
+}
+
+func (self *OxmArpTpa) SetValue(v uint32) {
+	self.Value = v
+}
+
+func (self *OxmArpTpa) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Value))
+
+	return nil
+}
+
+func DecodeOxmArpTpa(parent *Oxm, decoder *goloxi.Decoder) (*OxmArpTpa, error) {
+	_oxmarptpa := &OxmArpTpa{Oxm: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("OxmArpTpa packet too short: %d < 4", decoder.Length())
+	}
+	_oxmarptpa.Value = uint32(decoder.ReadUint32())
+	return _oxmarptpa, nil
+}
+
+func NewOxmArpTpa() *OxmArpTpa {
+	obj := &OxmArpTpa{
+		Oxm: NewOxm(2147495428),
+	}
+	return obj
+}
+func (self *OxmArpTpa) GetOXMName() string {
+	return "arp_tpa"
+}
+
+func (self *OxmArpTpa) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmArpTpa) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmArpTpaMasked struct {
+	*Oxm
+	Value     uint32
+	ValueMask uint32
+}
+
+type IOxmArpTpaMasked interface {
+	goloxi.IOxm
+	GetValue() uint32
+	GetValueMask() uint32
+}
+
+func (self *OxmArpTpaMasked) GetValue() uint32 {
+	return self.Value
+}
+
+func (self *OxmArpTpaMasked) SetValue(v uint32) {
+	self.Value = v
+}
+
+func (self *OxmArpTpaMasked) GetValueMask() uint32 {
+	return self.ValueMask
+}
+
+func (self *OxmArpTpaMasked) SetValueMask(v uint32) {
+	self.ValueMask = v
+}
+
+func (self *OxmArpTpaMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Value))
+	encoder.PutUint32(uint32(self.ValueMask))
+
+	return nil
+}
+
+func DecodeOxmArpTpaMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmArpTpaMasked, error) {
+	_oxmarptpamasked := &OxmArpTpaMasked{Oxm: parent}
+	if decoder.Length() < 8 {
+		return nil, fmt.Errorf("OxmArpTpaMasked packet too short: %d < 8", decoder.Length())
+	}
+	_oxmarptpamasked.Value = uint32(decoder.ReadUint32())
+	_oxmarptpamasked.ValueMask = uint32(decoder.ReadUint32())
+	return _oxmarptpamasked, nil
+}
+
+func NewOxmArpTpaMasked() *OxmArpTpaMasked {
+	obj := &OxmArpTpaMasked{
+		Oxm: NewOxm(2147495688),
+	}
+	return obj
+}
+func (self *OxmArpTpaMasked) GetOXMName() string {
+	return "arp_tpa_masked"
+}
+
+func (self *OxmArpTpaMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmArpTpaMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *OxmArpTpaMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmConnTrackingIpv6Dst struct {
+	*Oxm
+	Value net.IP
+}
+
+type IOxmConnTrackingIpv6Dst interface {
+	goloxi.IOxm
+	GetValue() net.IP
+}
+
+func (self *OxmConnTrackingIpv6Dst) GetValue() net.IP {
+	return self.Value
+}
+
+func (self *OxmConnTrackingIpv6Dst) SetValue(v net.IP) {
+	self.Value = v
+}
+
+func (self *OxmConnTrackingIpv6Dst) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value.To16())
+
+	return nil
+}
+
+func DecodeOxmConnTrackingIpv6Dst(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingIpv6Dst, error) {
+	_oxmconntrackingipv6dst := &OxmConnTrackingIpv6Dst{Oxm: parent}
+	if decoder.Length() < 16 {
+		return nil, fmt.Errorf("OxmConnTrackingIpv6Dst packet too short: %d < 16", decoder.Length())
+	}
+	_oxmconntrackingipv6dst.Value = net.IP(decoder.Read(16))
+	return _oxmconntrackingipv6dst, nil
+}
+
+func NewOxmConnTrackingIpv6Dst() *OxmConnTrackingIpv6Dst {
+	obj := &OxmConnTrackingIpv6Dst{
+		Oxm: NewOxm(128528),
+	}
+	return obj
+}
+func (self *OxmConnTrackingIpv6Dst) GetOXMName() string {
+	return "conn_tracking_ipv6_dst"
+}
+
+func (self *OxmConnTrackingIpv6Dst) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmConnTrackingIpv6Dst) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmConnTrackingIpv6DstMasked struct {
+	*Oxm
+	Value     net.IP
+	ValueMask net.IP
+}
+
+type IOxmConnTrackingIpv6DstMasked interface {
+	goloxi.IOxm
+	GetValue() net.IP
+	GetValueMask() net.IP
+}
+
+func (self *OxmConnTrackingIpv6DstMasked) GetValue() net.IP {
+	return self.Value
+}
+
+func (self *OxmConnTrackingIpv6DstMasked) SetValue(v net.IP) {
+	self.Value = v
+}
+
+func (self *OxmConnTrackingIpv6DstMasked) GetValueMask() net.IP {
+	return self.ValueMask
+}
+
+func (self *OxmConnTrackingIpv6DstMasked) SetValueMask(v net.IP) {
+	self.ValueMask = v
+}
+
+func (self *OxmConnTrackingIpv6DstMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value.To16())
+	encoder.Write(self.ValueMask.To16())
+
+	return nil
+}
+
+func DecodeOxmConnTrackingIpv6DstMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingIpv6DstMasked, error) {
+	_oxmconntrackingipv6dstmasked := &OxmConnTrackingIpv6DstMasked{Oxm: parent}
+	if decoder.Length() < 32 {
+		return nil, fmt.Errorf("OxmConnTrackingIpv6DstMasked packet too short: %d < 32", decoder.Length())
+	}
+	_oxmconntrackingipv6dstmasked.Value = net.IP(decoder.Read(16))
+	_oxmconntrackingipv6dstmasked.ValueMask = net.IP(decoder.Read(16))
+	return _oxmconntrackingipv6dstmasked, nil
+}
+
+func NewOxmConnTrackingIpv6DstMasked() *OxmConnTrackingIpv6DstMasked {
+	obj := &OxmConnTrackingIpv6DstMasked{
+		Oxm: NewOxm(128800),
+	}
+	return obj
+}
+func (self *OxmConnTrackingIpv6DstMasked) GetOXMName() string {
+	return "conn_tracking_ipv6_dst_masked"
+}
+
+func (self *OxmConnTrackingIpv6DstMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmConnTrackingIpv6DstMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *OxmConnTrackingIpv6DstMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmConnTrackingIpv6Src struct {
+	*Oxm
+	Value net.IP
+}
+
+type IOxmConnTrackingIpv6Src interface {
+	goloxi.IOxm
+	GetValue() net.IP
+}
+
+func (self *OxmConnTrackingIpv6Src) GetValue() net.IP {
+	return self.Value
+}
+
+func (self *OxmConnTrackingIpv6Src) SetValue(v net.IP) {
+	self.Value = v
+}
+
+func (self *OxmConnTrackingIpv6Src) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value.To16())
+
+	return nil
+}
+
+func DecodeOxmConnTrackingIpv6Src(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingIpv6Src, error) {
+	_oxmconntrackingipv6src := &OxmConnTrackingIpv6Src{Oxm: parent}
+	if decoder.Length() < 16 {
+		return nil, fmt.Errorf("OxmConnTrackingIpv6Src packet too short: %d < 16", decoder.Length())
+	}
+	_oxmconntrackingipv6src.Value = net.IP(decoder.Read(16))
+	return _oxmconntrackingipv6src, nil
+}
+
+func NewOxmConnTrackingIpv6Src() *OxmConnTrackingIpv6Src {
+	obj := &OxmConnTrackingIpv6Src{
+		Oxm: NewOxm(128016),
+	}
+	return obj
+}
+func (self *OxmConnTrackingIpv6Src) GetOXMName() string {
+	return "conn_tracking_ipv6_src"
+}
+
+func (self *OxmConnTrackingIpv6Src) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmConnTrackingIpv6Src) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmConnTrackingIpv6SrcMasked struct {
+	*Oxm
+	Value     net.IP
+	ValueMask net.IP
+}
+
+type IOxmConnTrackingIpv6SrcMasked interface {
+	goloxi.IOxm
+	GetValue() net.IP
+	GetValueMask() net.IP
+}
+
+func (self *OxmConnTrackingIpv6SrcMasked) GetValue() net.IP {
+	return self.Value
+}
+
+func (self *OxmConnTrackingIpv6SrcMasked) SetValue(v net.IP) {
+	self.Value = v
+}
+
+func (self *OxmConnTrackingIpv6SrcMasked) GetValueMask() net.IP {
+	return self.ValueMask
+}
+
+func (self *OxmConnTrackingIpv6SrcMasked) SetValueMask(v net.IP) {
+	self.ValueMask = v
+}
+
+func (self *OxmConnTrackingIpv6SrcMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value.To16())
+	encoder.Write(self.ValueMask.To16())
+
+	return nil
+}
+
+func DecodeOxmConnTrackingIpv6SrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingIpv6SrcMasked, error) {
+	_oxmconntrackingipv6srcmasked := &OxmConnTrackingIpv6SrcMasked{Oxm: parent}
+	if decoder.Length() < 32 {
+		return nil, fmt.Errorf("OxmConnTrackingIpv6SrcMasked packet too short: %d < 32", decoder.Length())
+	}
+	_oxmconntrackingipv6srcmasked.Value = net.IP(decoder.Read(16))
+	_oxmconntrackingipv6srcmasked.ValueMask = net.IP(decoder.Read(16))
+	return _oxmconntrackingipv6srcmasked, nil
+}
+
+func NewOxmConnTrackingIpv6SrcMasked() *OxmConnTrackingIpv6SrcMasked {
+	obj := &OxmConnTrackingIpv6SrcMasked{
+		Oxm: NewOxm(128288),
+	}
+	return obj
+}
+func (self *OxmConnTrackingIpv6SrcMasked) GetOXMName() string {
+	return "conn_tracking_ipv6_src_masked"
+}
+
+func (self *OxmConnTrackingIpv6SrcMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmConnTrackingIpv6SrcMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *OxmConnTrackingIpv6SrcMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmConnTrackingLabel struct {
+	*Oxm
+	Value uint128
+}
+
+type IOxmConnTrackingLabel interface {
+	goloxi.IOxm
+	GetValue() uint128
+}
+
+func (self *OxmConnTrackingLabel) GetValue() uint128 {
+	return self.Value
+}
+
+func (self *OxmConnTrackingLabel) SetValue(v uint128) {
+	self.Value = v
+}
+
+func (self *OxmConnTrackingLabel) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint128(uint128(self.Value))
+
+	return nil
+}
+
+func DecodeOxmConnTrackingLabel(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingLabel, error) {
+	_oxmconntrackinglabel := &OxmConnTrackingLabel{Oxm: parent}
+	if decoder.Length() < 16 {
+		return nil, fmt.Errorf("OxmConnTrackingLabel packet too short: %d < 16", decoder.Length())
+	}
+	_oxmconntrackinglabel.Value = uint128(decoder.ReadUint128())
+	return _oxmconntrackinglabel, nil
+}
+
+func NewOxmConnTrackingLabel() *OxmConnTrackingLabel {
+	obj := &OxmConnTrackingLabel{
+		Oxm: NewOxm(120848),
+	}
+	return obj
+}
+func (self *OxmConnTrackingLabel) GetOXMName() string {
+	return "conn_tracking_label"
+}
+
+func (self *OxmConnTrackingLabel) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmConnTrackingLabel) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmConnTrackingLabelMasked struct {
+	*Oxm
+	Value     uint128
+	ValueMask uint128
+}
+
+type IOxmConnTrackingLabelMasked interface {
+	goloxi.IOxm
+	GetValue() uint128
+	GetValueMask() uint128
+}
+
+func (self *OxmConnTrackingLabelMasked) GetValue() uint128 {
+	return self.Value
+}
+
+func (self *OxmConnTrackingLabelMasked) SetValue(v uint128) {
+	self.Value = v
+}
+
+func (self *OxmConnTrackingLabelMasked) GetValueMask() uint128 {
+	return self.ValueMask
+}
+
+func (self *OxmConnTrackingLabelMasked) SetValueMask(v uint128) {
+	self.ValueMask = v
+}
+
+func (self *OxmConnTrackingLabelMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint128(uint128(self.Value))
+	encoder.PutUint128(uint128(self.ValueMask))
+
+	return nil
+}
+
+func DecodeOxmConnTrackingLabelMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingLabelMasked, error) {
+	_oxmconntrackinglabelmasked := &OxmConnTrackingLabelMasked{Oxm: parent}
+	if decoder.Length() < 32 {
+		return nil, fmt.Errorf("OxmConnTrackingLabelMasked packet too short: %d < 32", decoder.Length())
+	}
+	_oxmconntrackinglabelmasked.Value = uint128(decoder.ReadUint128())
+	_oxmconntrackinglabelmasked.ValueMask = uint128(decoder.ReadUint128())
+	return _oxmconntrackinglabelmasked, nil
+}
+
+func NewOxmConnTrackingLabelMasked() *OxmConnTrackingLabelMasked {
+	obj := &OxmConnTrackingLabelMasked{
+		Oxm: NewOxm(121120),
+	}
+	return obj
+}
+func (self *OxmConnTrackingLabelMasked) GetOXMName() string {
+	return "conn_tracking_label_masked"
+}
+
+func (self *OxmConnTrackingLabelMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmConnTrackingLabelMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *OxmConnTrackingLabelMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmConnTrackingMark struct {
+	*Oxm
+	Value uint32
+}
+
+type IOxmConnTrackingMark interface {
+	goloxi.IOxm
+	GetValue() uint32
+}
+
+func (self *OxmConnTrackingMark) GetValue() uint32 {
+	return self.Value
+}
+
+func (self *OxmConnTrackingMark) SetValue(v uint32) {
+	self.Value = v
+}
+
+func (self *OxmConnTrackingMark) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Value))
+
+	return nil
+}
+
+func DecodeOxmConnTrackingMark(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingMark, error) {
+	_oxmconntrackingmark := &OxmConnTrackingMark{Oxm: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("OxmConnTrackingMark packet too short: %d < 4", decoder.Length())
+	}
+	_oxmconntrackingmark.Value = uint32(decoder.ReadUint32())
+	return _oxmconntrackingmark, nil
+}
+
+func NewOxmConnTrackingMark() *OxmConnTrackingMark {
+	obj := &OxmConnTrackingMark{
+		Oxm: NewOxm(120324),
+	}
+	return obj
+}
+func (self *OxmConnTrackingMark) GetOXMName() string {
+	return "conn_tracking_mark"
+}
+
+func (self *OxmConnTrackingMark) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmConnTrackingMark) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmConnTrackingMarkMasked struct {
+	*Oxm
+	Value     uint32
+	ValueMask uint32
+}
+
+type IOxmConnTrackingMarkMasked interface {
+	goloxi.IOxm
+	GetValue() uint32
+	GetValueMask() uint32
+}
+
+func (self *OxmConnTrackingMarkMasked) GetValue() uint32 {
+	return self.Value
+}
+
+func (self *OxmConnTrackingMarkMasked) SetValue(v uint32) {
+	self.Value = v
+}
+
+func (self *OxmConnTrackingMarkMasked) GetValueMask() uint32 {
+	return self.ValueMask
+}
+
+func (self *OxmConnTrackingMarkMasked) SetValueMask(v uint32) {
+	self.ValueMask = v
+}
+
+func (self *OxmConnTrackingMarkMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Value))
+	encoder.PutUint32(uint32(self.ValueMask))
+
+	return nil
+}
+
+func DecodeOxmConnTrackingMarkMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingMarkMasked, error) {
+	_oxmconntrackingmarkmasked := &OxmConnTrackingMarkMasked{Oxm: parent}
+	if decoder.Length() < 8 {
+		return nil, fmt.Errorf("OxmConnTrackingMarkMasked packet too short: %d < 8", decoder.Length())
+	}
+	_oxmconntrackingmarkmasked.Value = uint32(decoder.ReadUint32())
+	_oxmconntrackingmarkmasked.ValueMask = uint32(decoder.ReadUint32())
+	return _oxmconntrackingmarkmasked, nil
+}
+
+func NewOxmConnTrackingMarkMasked() *OxmConnTrackingMarkMasked {
+	obj := &OxmConnTrackingMarkMasked{
+		Oxm: NewOxm(120584),
+	}
+	return obj
+}
+func (self *OxmConnTrackingMarkMasked) GetOXMName() string {
+	return "conn_tracking_mark_masked"
+}
+
+func (self *OxmConnTrackingMarkMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmConnTrackingMarkMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *OxmConnTrackingMarkMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmConnTrackingNwDst struct {
+	*Oxm
+	Value uint32
+}
+
+type IOxmConnTrackingNwDst interface {
+	goloxi.IOxm
+	GetValue() uint32
+}
+
+func (self *OxmConnTrackingNwDst) GetValue() uint32 {
+	return self.Value
+}
+
+func (self *OxmConnTrackingNwDst) SetValue(v uint32) {
+	self.Value = v
+}
+
+func (self *OxmConnTrackingNwDst) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Value))
+
+	return nil
+}
+
+func DecodeOxmConnTrackingNwDst(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingNwDst, error) {
+	_oxmconntrackingnwdst := &OxmConnTrackingNwDst{Oxm: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("OxmConnTrackingNwDst packet too short: %d < 4", decoder.Length())
+	}
+	_oxmconntrackingnwdst.Value = uint32(decoder.ReadUint32())
+	return _oxmconntrackingnwdst, nil
+}
+
+func NewOxmConnTrackingNwDst() *OxmConnTrackingNwDst {
+	obj := &OxmConnTrackingNwDst{
+		Oxm: NewOxm(127492),
+	}
+	return obj
+}
+func (self *OxmConnTrackingNwDst) GetOXMName() string {
+	return "conn_tracking_nw_dst"
+}
+
+func (self *OxmConnTrackingNwDst) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmConnTrackingNwDst) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmConnTrackingNwDstMasked struct {
+	*Oxm
+	Value     uint32
+	ValueMask uint32
+}
+
+type IOxmConnTrackingNwDstMasked interface {
+	goloxi.IOxm
+	GetValue() uint32
+	GetValueMask() uint32
+}
+
+func (self *OxmConnTrackingNwDstMasked) GetValue() uint32 {
+	return self.Value
+}
+
+func (self *OxmConnTrackingNwDstMasked) SetValue(v uint32) {
+	self.Value = v
+}
+
+func (self *OxmConnTrackingNwDstMasked) GetValueMask() uint32 {
+	return self.ValueMask
+}
+
+func (self *OxmConnTrackingNwDstMasked) SetValueMask(v uint32) {
+	self.ValueMask = v
+}
+
+func (self *OxmConnTrackingNwDstMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Value))
+	encoder.PutUint32(uint32(self.ValueMask))
+
+	return nil
+}
+
+func DecodeOxmConnTrackingNwDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingNwDstMasked, error) {
+	_oxmconntrackingnwdstmasked := &OxmConnTrackingNwDstMasked{Oxm: parent}
+	if decoder.Length() < 8 {
+		return nil, fmt.Errorf("OxmConnTrackingNwDstMasked packet too short: %d < 8", decoder.Length())
+	}
+	_oxmconntrackingnwdstmasked.Value = uint32(decoder.ReadUint32())
+	_oxmconntrackingnwdstmasked.ValueMask = uint32(decoder.ReadUint32())
+	return _oxmconntrackingnwdstmasked, nil
+}
+
+func NewOxmConnTrackingNwDstMasked() *OxmConnTrackingNwDstMasked {
+	obj := &OxmConnTrackingNwDstMasked{
+		Oxm: NewOxm(127752),
+	}
+	return obj
+}
+func (self *OxmConnTrackingNwDstMasked) GetOXMName() string {
+	return "conn_tracking_nw_dst_masked"
+}
+
+func (self *OxmConnTrackingNwDstMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmConnTrackingNwDstMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *OxmConnTrackingNwDstMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmConnTrackingNwProto struct {
+	*Oxm
+	Value uint8
+}
+
+type IOxmConnTrackingNwProto interface {
+	goloxi.IOxm
+	GetValue() uint8
+}
+
+func (self *OxmConnTrackingNwProto) GetValue() uint8 {
+	return self.Value
+}
+
+func (self *OxmConnTrackingNwProto) SetValue(v uint8) {
+	self.Value = v
+}
+
+func (self *OxmConnTrackingNwProto) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint8(uint8(self.Value))
+
+	return nil
+}
+
+func DecodeOxmConnTrackingNwProto(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingNwProto, error) {
+	_oxmconntrackingnwproto := &OxmConnTrackingNwProto{Oxm: parent}
+	if decoder.Length() < 1 {
+		return nil, fmt.Errorf("OxmConnTrackingNwProto packet too short: %d < 1", decoder.Length())
+	}
+	_oxmconntrackingnwproto.Value = uint8(decoder.ReadByte())
+	return _oxmconntrackingnwproto, nil
+}
+
+func NewOxmConnTrackingNwProto() *OxmConnTrackingNwProto {
+	obj := &OxmConnTrackingNwProto{
+		Oxm: NewOxm(126465),
+	}
+	return obj
+}
+func (self *OxmConnTrackingNwProto) GetOXMName() string {
+	return "conn_tracking_nw_proto"
+}
+
+func (self *OxmConnTrackingNwProto) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmConnTrackingNwProto) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmConnTrackingNwProtoMasked struct {
+	*Oxm
+	Value     uint8
+	ValueMask uint8
+}
+
+type IOxmConnTrackingNwProtoMasked interface {
+	goloxi.IOxm
+	GetValue() uint8
+	GetValueMask() uint8
+}
+
+func (self *OxmConnTrackingNwProtoMasked) GetValue() uint8 {
+	return self.Value
+}
+
+func (self *OxmConnTrackingNwProtoMasked) SetValue(v uint8) {
+	self.Value = v
+}
+
+func (self *OxmConnTrackingNwProtoMasked) GetValueMask() uint8 {
+	return self.ValueMask
+}
+
+func (self *OxmConnTrackingNwProtoMasked) SetValueMask(v uint8) {
+	self.ValueMask = v
+}
+
+func (self *OxmConnTrackingNwProtoMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint8(uint8(self.Value))
+	encoder.PutUint8(uint8(self.ValueMask))
+
+	return nil
+}
+
+func DecodeOxmConnTrackingNwProtoMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingNwProtoMasked, error) {
+	_oxmconntrackingnwprotomasked := &OxmConnTrackingNwProtoMasked{Oxm: parent}
+	if decoder.Length() < 2 {
+		return nil, fmt.Errorf("OxmConnTrackingNwProtoMasked packet too short: %d < 2", decoder.Length())
+	}
+	_oxmconntrackingnwprotomasked.Value = uint8(decoder.ReadByte())
+	_oxmconntrackingnwprotomasked.ValueMask = uint8(decoder.ReadByte())
+	return _oxmconntrackingnwprotomasked, nil
+}
+
+func NewOxmConnTrackingNwProtoMasked() *OxmConnTrackingNwProtoMasked {
+	obj := &OxmConnTrackingNwProtoMasked{
+		Oxm: NewOxm(126722),
+	}
+	return obj
+}
+func (self *OxmConnTrackingNwProtoMasked) GetOXMName() string {
+	return "conn_tracking_nw_proto_masked"
+}
+
+func (self *OxmConnTrackingNwProtoMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmConnTrackingNwProtoMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *OxmConnTrackingNwProtoMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmConnTrackingNwSrc struct {
+	*Oxm
+	Value uint32
+}
+
+type IOxmConnTrackingNwSrc interface {
+	goloxi.IOxm
+	GetValue() uint32
+}
+
+func (self *OxmConnTrackingNwSrc) GetValue() uint32 {
+	return self.Value
+}
+
+func (self *OxmConnTrackingNwSrc) SetValue(v uint32) {
+	self.Value = v
+}
+
+func (self *OxmConnTrackingNwSrc) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Value))
+
+	return nil
+}
+
+func DecodeOxmConnTrackingNwSrc(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingNwSrc, error) {
+	_oxmconntrackingnwsrc := &OxmConnTrackingNwSrc{Oxm: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("OxmConnTrackingNwSrc packet too short: %d < 4", decoder.Length())
+	}
+	_oxmconntrackingnwsrc.Value = uint32(decoder.ReadUint32())
+	return _oxmconntrackingnwsrc, nil
+}
+
+func NewOxmConnTrackingNwSrc() *OxmConnTrackingNwSrc {
+	obj := &OxmConnTrackingNwSrc{
+		Oxm: NewOxm(126980),
+	}
+	return obj
+}
+func (self *OxmConnTrackingNwSrc) GetOXMName() string {
+	return "conn_tracking_nw_src"
+}
+
+func (self *OxmConnTrackingNwSrc) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmConnTrackingNwSrc) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmConnTrackingNwSrcMasked struct {
+	*Oxm
+	Value     uint32
+	ValueMask uint32
+}
+
+type IOxmConnTrackingNwSrcMasked interface {
+	goloxi.IOxm
+	GetValue() uint32
+	GetValueMask() uint32
+}
+
+func (self *OxmConnTrackingNwSrcMasked) GetValue() uint32 {
+	return self.Value
+}
+
+func (self *OxmConnTrackingNwSrcMasked) SetValue(v uint32) {
+	self.Value = v
+}
+
+func (self *OxmConnTrackingNwSrcMasked) GetValueMask() uint32 {
+	return self.ValueMask
+}
+
+func (self *OxmConnTrackingNwSrcMasked) SetValueMask(v uint32) {
+	self.ValueMask = v
+}
+
+func (self *OxmConnTrackingNwSrcMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Value))
+	encoder.PutUint32(uint32(self.ValueMask))
+
+	return nil
+}
+
+func DecodeOxmConnTrackingNwSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingNwSrcMasked, error) {
+	_oxmconntrackingnwsrcmasked := &OxmConnTrackingNwSrcMasked{Oxm: parent}
+	if decoder.Length() < 8 {
+		return nil, fmt.Errorf("OxmConnTrackingNwSrcMasked packet too short: %d < 8", decoder.Length())
+	}
+	_oxmconntrackingnwsrcmasked.Value = uint32(decoder.ReadUint32())
+	_oxmconntrackingnwsrcmasked.ValueMask = uint32(decoder.ReadUint32())
+	return _oxmconntrackingnwsrcmasked, nil
+}
+
+func NewOxmConnTrackingNwSrcMasked() *OxmConnTrackingNwSrcMasked {
+	obj := &OxmConnTrackingNwSrcMasked{
+		Oxm: NewOxm(127240),
+	}
+	return obj
+}
+func (self *OxmConnTrackingNwSrcMasked) GetOXMName() string {
+	return "conn_tracking_nw_src_masked"
+}
+
+func (self *OxmConnTrackingNwSrcMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmConnTrackingNwSrcMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *OxmConnTrackingNwSrcMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmConnTrackingState struct {
+	*Oxm
+	Value CsStates
+}
+
+type IOxmConnTrackingState interface {
+	goloxi.IOxm
+	GetValue() CsStates
+}
+
+func (self *OxmConnTrackingState) GetValue() CsStates {
+	return self.Value
+}
+
+func (self *OxmConnTrackingState) SetValue(v CsStates) {
+	self.Value = v
+}
+
+func (self *OxmConnTrackingState) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Value))
+
+	return nil
+}
+
+func DecodeOxmConnTrackingState(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingState, error) {
+	_oxmconntrackingstate := &OxmConnTrackingState{Oxm: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("OxmConnTrackingState packet too short: %d < 4", decoder.Length())
+	}
+	_oxmconntrackingstate.Value = CsStates(decoder.ReadUint32())
+	return _oxmconntrackingstate, nil
+}
+
+func NewOxmConnTrackingState() *OxmConnTrackingState {
+	obj := &OxmConnTrackingState{
+		Oxm: NewOxm(119300),
+	}
+	return obj
+}
+func (self *OxmConnTrackingState) GetOXMName() string {
+	return "conn_tracking_state"
+}
+
+func (self *OxmConnTrackingState) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmConnTrackingState) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmConnTrackingStateMasked struct {
+	*Oxm
+	Value     CsStates
+	ValueMask CsStates
+}
+
+type IOxmConnTrackingStateMasked interface {
+	goloxi.IOxm
+	GetValue() CsStates
+	GetValueMask() CsStates
+}
+
+func (self *OxmConnTrackingStateMasked) GetValue() CsStates {
+	return self.Value
+}
+
+func (self *OxmConnTrackingStateMasked) SetValue(v CsStates) {
+	self.Value = v
+}
+
+func (self *OxmConnTrackingStateMasked) GetValueMask() CsStates {
+	return self.ValueMask
+}
+
+func (self *OxmConnTrackingStateMasked) SetValueMask(v CsStates) {
+	self.ValueMask = v
+}
+
+func (self *OxmConnTrackingStateMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Value))
+	encoder.PutUint32(uint32(self.ValueMask))
+
+	return nil
+}
+
+func DecodeOxmConnTrackingStateMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingStateMasked, error) {
+	_oxmconntrackingstatemasked := &OxmConnTrackingStateMasked{Oxm: parent}
+	if decoder.Length() < 8 {
+		return nil, fmt.Errorf("OxmConnTrackingStateMasked packet too short: %d < 8", decoder.Length())
+	}
+	_oxmconntrackingstatemasked.Value = CsStates(decoder.ReadUint32())
+	_oxmconntrackingstatemasked.ValueMask = CsStates(decoder.ReadUint32())
+	return _oxmconntrackingstatemasked, nil
+}
+
+func NewOxmConnTrackingStateMasked() *OxmConnTrackingStateMasked {
+	obj := &OxmConnTrackingStateMasked{
+		Oxm: NewOxm(119560),
+	}
+	return obj
+}
+func (self *OxmConnTrackingStateMasked) GetOXMName() string {
+	return "conn_tracking_state_masked"
+}
+
+func (self *OxmConnTrackingStateMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmConnTrackingStateMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *OxmConnTrackingStateMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmConnTrackingTpDst struct {
+	*Oxm
+	Value uint16
+}
+
+type IOxmConnTrackingTpDst interface {
+	goloxi.IOxm
+	GetValue() uint16
+}
+
+func (self *OxmConnTrackingTpDst) GetValue() uint16 {
+	return self.Value
+}
+
+func (self *OxmConnTrackingTpDst) SetValue(v uint16) {
+	self.Value = v
+}
+
+func (self *OxmConnTrackingTpDst) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Value))
+
+	return nil
+}
+
+func DecodeOxmConnTrackingTpDst(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingTpDst, error) {
+	_oxmconntrackingtpdst := &OxmConnTrackingTpDst{Oxm: parent}
+	if decoder.Length() < 2 {
+		return nil, fmt.Errorf("OxmConnTrackingTpDst packet too short: %d < 2", decoder.Length())
+	}
+	_oxmconntrackingtpdst.Value = uint16(decoder.ReadUint16())
+	return _oxmconntrackingtpdst, nil
+}
+
+func NewOxmConnTrackingTpDst() *OxmConnTrackingTpDst {
+	obj := &OxmConnTrackingTpDst{
+		Oxm: NewOxm(129538),
+	}
+	return obj
+}
+func (self *OxmConnTrackingTpDst) GetOXMName() string {
+	return "conn_tracking_tp_dst"
+}
+
+func (self *OxmConnTrackingTpDst) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmConnTrackingTpDst) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmConnTrackingTpDstMasked struct {
+	*Oxm
+	Value     uint16
+	ValueMask uint16
+}
+
+type IOxmConnTrackingTpDstMasked interface {
+	goloxi.IOxm
+	GetValue() uint16
+	GetValueMask() uint16
+}
+
+func (self *OxmConnTrackingTpDstMasked) GetValue() uint16 {
+	return self.Value
+}
+
+func (self *OxmConnTrackingTpDstMasked) SetValue(v uint16) {
+	self.Value = v
+}
+
+func (self *OxmConnTrackingTpDstMasked) GetValueMask() uint16 {
+	return self.ValueMask
+}
+
+func (self *OxmConnTrackingTpDstMasked) SetValueMask(v uint16) {
+	self.ValueMask = v
+}
+
+func (self *OxmConnTrackingTpDstMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Value))
+	encoder.PutUint16(uint16(self.ValueMask))
+
+	return nil
+}
+
+func DecodeOxmConnTrackingTpDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingTpDstMasked, error) {
+	_oxmconntrackingtpdstmasked := &OxmConnTrackingTpDstMasked{Oxm: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("OxmConnTrackingTpDstMasked packet too short: %d < 4", decoder.Length())
+	}
+	_oxmconntrackingtpdstmasked.Value = uint16(decoder.ReadUint16())
+	_oxmconntrackingtpdstmasked.ValueMask = uint16(decoder.ReadUint16())
+	return _oxmconntrackingtpdstmasked, nil
+}
+
+func NewOxmConnTrackingTpDstMasked() *OxmConnTrackingTpDstMasked {
+	obj := &OxmConnTrackingTpDstMasked{
+		Oxm: NewOxm(129796),
+	}
+	return obj
+}
+func (self *OxmConnTrackingTpDstMasked) GetOXMName() string {
+	return "conn_tracking_tp_dst_masked"
+}
+
+func (self *OxmConnTrackingTpDstMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmConnTrackingTpDstMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *OxmConnTrackingTpDstMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmConnTrackingTpSrc struct {
+	*Oxm
+	Value uint16
+}
+
+type IOxmConnTrackingTpSrc interface {
+	goloxi.IOxm
+	GetValue() uint16
+}
+
+func (self *OxmConnTrackingTpSrc) GetValue() uint16 {
+	return self.Value
+}
+
+func (self *OxmConnTrackingTpSrc) SetValue(v uint16) {
+	self.Value = v
+}
+
+func (self *OxmConnTrackingTpSrc) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Value))
+
+	return nil
+}
+
+func DecodeOxmConnTrackingTpSrc(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingTpSrc, error) {
+	_oxmconntrackingtpsrc := &OxmConnTrackingTpSrc{Oxm: parent}
+	if decoder.Length() < 2 {
+		return nil, fmt.Errorf("OxmConnTrackingTpSrc packet too short: %d < 2", decoder.Length())
+	}
+	_oxmconntrackingtpsrc.Value = uint16(decoder.ReadUint16())
+	return _oxmconntrackingtpsrc, nil
+}
+
+func NewOxmConnTrackingTpSrc() *OxmConnTrackingTpSrc {
+	obj := &OxmConnTrackingTpSrc{
+		Oxm: NewOxm(129026),
+	}
+	return obj
+}
+func (self *OxmConnTrackingTpSrc) GetOXMName() string {
+	return "conn_tracking_tp_src"
+}
+
+func (self *OxmConnTrackingTpSrc) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmConnTrackingTpSrc) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmConnTrackingTpSrcMasked struct {
+	*Oxm
+	Value     uint16
+	ValueMask uint16
+}
+
+type IOxmConnTrackingTpSrcMasked interface {
+	goloxi.IOxm
+	GetValue() uint16
+	GetValueMask() uint16
+}
+
+func (self *OxmConnTrackingTpSrcMasked) GetValue() uint16 {
+	return self.Value
+}
+
+func (self *OxmConnTrackingTpSrcMasked) SetValue(v uint16) {
+	self.Value = v
+}
+
+func (self *OxmConnTrackingTpSrcMasked) GetValueMask() uint16 {
+	return self.ValueMask
+}
+
+func (self *OxmConnTrackingTpSrcMasked) SetValueMask(v uint16) {
+	self.ValueMask = v
+}
+
+func (self *OxmConnTrackingTpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Value))
+	encoder.PutUint16(uint16(self.ValueMask))
+
+	return nil
+}
+
+func DecodeOxmConnTrackingTpSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingTpSrcMasked, error) {
+	_oxmconntrackingtpsrcmasked := &OxmConnTrackingTpSrcMasked{Oxm: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("OxmConnTrackingTpSrcMasked packet too short: %d < 4", decoder.Length())
+	}
+	_oxmconntrackingtpsrcmasked.Value = uint16(decoder.ReadUint16())
+	_oxmconntrackingtpsrcmasked.ValueMask = uint16(decoder.ReadUint16())
+	return _oxmconntrackingtpsrcmasked, nil
+}
+
+func NewOxmConnTrackingTpSrcMasked() *OxmConnTrackingTpSrcMasked {
+	obj := &OxmConnTrackingTpSrcMasked{
+		Oxm: NewOxm(129284),
+	}
+	return obj
+}
+func (self *OxmConnTrackingTpSrcMasked) GetOXMName() string {
+	return "conn_tracking_tp_src_masked"
+}
+
+func (self *OxmConnTrackingTpSrcMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmConnTrackingTpSrcMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *OxmConnTrackingTpSrcMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmConnTrackingZone struct {
+	*Oxm
+	Value uint16
+}
+
+type IOxmConnTrackingZone interface {
+	goloxi.IOxm
+	GetValue() uint16
+}
+
+func (self *OxmConnTrackingZone) GetValue() uint16 {
+	return self.Value
+}
+
+func (self *OxmConnTrackingZone) SetValue(v uint16) {
+	self.Value = v
+}
+
+func (self *OxmConnTrackingZone) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Value))
+
+	return nil
+}
+
+func DecodeOxmConnTrackingZone(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingZone, error) {
+	_oxmconntrackingzone := &OxmConnTrackingZone{Oxm: parent}
+	if decoder.Length() < 2 {
+		return nil, fmt.Errorf("OxmConnTrackingZone packet too short: %d < 2", decoder.Length())
+	}
+	_oxmconntrackingzone.Value = uint16(decoder.ReadUint16())
+	return _oxmconntrackingzone, nil
+}
+
+func NewOxmConnTrackingZone() *OxmConnTrackingZone {
+	obj := &OxmConnTrackingZone{
+		Oxm: NewOxm(119810),
+	}
+	return obj
+}
+func (self *OxmConnTrackingZone) GetOXMName() string {
+	return "conn_tracking_zone"
+}
+
+func (self *OxmConnTrackingZone) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmConnTrackingZone) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmConnTrackingZoneMasked struct {
+	*Oxm
+	Value     uint16
+	ValueMask uint16
+}
+
+type IOxmConnTrackingZoneMasked interface {
+	goloxi.IOxm
+	GetValue() uint16
+	GetValueMask() uint16
+}
+
+func (self *OxmConnTrackingZoneMasked) GetValue() uint16 {
+	return self.Value
+}
+
+func (self *OxmConnTrackingZoneMasked) SetValue(v uint16) {
+	self.Value = v
+}
+
+func (self *OxmConnTrackingZoneMasked) GetValueMask() uint16 {
+	return self.ValueMask
+}
+
+func (self *OxmConnTrackingZoneMasked) SetValueMask(v uint16) {
+	self.ValueMask = v
+}
+
+func (self *OxmConnTrackingZoneMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Value))
+	encoder.PutUint16(uint16(self.ValueMask))
+
+	return nil
+}
+
+func DecodeOxmConnTrackingZoneMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingZoneMasked, error) {
+	_oxmconntrackingzonemasked := &OxmConnTrackingZoneMasked{Oxm: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("OxmConnTrackingZoneMasked packet too short: %d < 4", decoder.Length())
+	}
+	_oxmconntrackingzonemasked.Value = uint16(decoder.ReadUint16())
+	_oxmconntrackingzonemasked.ValueMask = uint16(decoder.ReadUint16())
+	return _oxmconntrackingzonemasked, nil
+}
+
+func NewOxmConnTrackingZoneMasked() *OxmConnTrackingZoneMasked {
+	obj := &OxmConnTrackingZoneMasked{
+		Oxm: NewOxm(120068),
+	}
+	return obj
+}
+func (self *OxmConnTrackingZoneMasked) GetOXMName() string {
+	return "conn_tracking_zone_masked"
+}
+
+func (self *OxmConnTrackingZoneMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmConnTrackingZoneMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *OxmConnTrackingZoneMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmEthDst struct {
+	*Oxm
+	Value net.HardwareAddr
+}
+
+type IOxmEthDst interface {
+	goloxi.IOxm
+	GetValue() net.HardwareAddr
+}
+
+func (self *OxmEthDst) GetValue() net.HardwareAddr {
+	return self.Value
+}
+
+func (self *OxmEthDst) SetValue(v net.HardwareAddr) {
+	self.Value = v
+}
+
+func (self *OxmEthDst) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeOxmEthDst(parent *Oxm, decoder *goloxi.Decoder) (*OxmEthDst, error) {
+	_oxmethdst := &OxmEthDst{Oxm: parent}
+	if decoder.Length() < 6 {
+		return nil, fmt.Errorf("OxmEthDst packet too short: %d < 6", decoder.Length())
+	}
+	_oxmethdst.Value = net.HardwareAddr(decoder.Read(6))
+	return _oxmethdst, nil
+}
+
+func NewOxmEthDst() *OxmEthDst {
+	obj := &OxmEthDst{
+		Oxm: NewOxm(2147485190),
+	}
+	return obj
+}
+func (self *OxmEthDst) GetOXMName() string {
+	return "eth_dst"
+}
+
+func (self *OxmEthDst) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmEthDst) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmEthDstMasked struct {
+	*Oxm
+	Value     net.HardwareAddr
+	ValueMask net.HardwareAddr
+}
+
+type IOxmEthDstMasked interface {
+	goloxi.IOxm
+	GetValue() net.HardwareAddr
+	GetValueMask() net.HardwareAddr
+}
+
+func (self *OxmEthDstMasked) GetValue() net.HardwareAddr {
+	return self.Value
+}
+
+func (self *OxmEthDstMasked) SetValue(v net.HardwareAddr) {
+	self.Value = v
+}
+
+func (self *OxmEthDstMasked) GetValueMask() net.HardwareAddr {
+	return self.ValueMask
+}
+
+func (self *OxmEthDstMasked) SetValueMask(v net.HardwareAddr) {
+	self.ValueMask = v
+}
+
+func (self *OxmEthDstMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeOxmEthDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmEthDstMasked, error) {
+	_oxmethdstmasked := &OxmEthDstMasked{Oxm: parent}
+	if decoder.Length() < 12 {
+		return nil, fmt.Errorf("OxmEthDstMasked packet too short: %d < 12", decoder.Length())
+	}
+	_oxmethdstmasked.Value = net.HardwareAddr(decoder.Read(6))
+	_oxmethdstmasked.ValueMask = net.HardwareAddr(decoder.Read(6))
+	return _oxmethdstmasked, nil
+}
+
+func NewOxmEthDstMasked() *OxmEthDstMasked {
+	obj := &OxmEthDstMasked{
+		Oxm: NewOxm(2147485452),
+	}
+	return obj
+}
+func (self *OxmEthDstMasked) GetOXMName() string {
+	return "eth_dst_masked"
+}
+
+func (self *OxmEthDstMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmEthDstMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *OxmEthDstMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmEthSrc struct {
+	*Oxm
+	Value net.HardwareAddr
+}
+
+type IOxmEthSrc interface {
+	goloxi.IOxm
+	GetValue() net.HardwareAddr
+}
+
+func (self *OxmEthSrc) GetValue() net.HardwareAddr {
+	return self.Value
+}
+
+func (self *OxmEthSrc) SetValue(v net.HardwareAddr) {
+	self.Value = v
+}
+
+func (self *OxmEthSrc) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeOxmEthSrc(parent *Oxm, decoder *goloxi.Decoder) (*OxmEthSrc, error) {
+	_oxmethsrc := &OxmEthSrc{Oxm: parent}
+	if decoder.Length() < 6 {
+		return nil, fmt.Errorf("OxmEthSrc packet too short: %d < 6", decoder.Length())
+	}
+	_oxmethsrc.Value = net.HardwareAddr(decoder.Read(6))
+	return _oxmethsrc, nil
+}
+
+func NewOxmEthSrc() *OxmEthSrc {
+	obj := &OxmEthSrc{
+		Oxm: NewOxm(2147485702),
+	}
+	return obj
+}
+func (self *OxmEthSrc) GetOXMName() string {
+	return "eth_src"
+}
+
+func (self *OxmEthSrc) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmEthSrc) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmEthSrcMasked struct {
+	*Oxm
+	Value     net.HardwareAddr
+	ValueMask net.HardwareAddr
+}
+
+type IOxmEthSrcMasked interface {
+	goloxi.IOxm
+	GetValue() net.HardwareAddr
+	GetValueMask() net.HardwareAddr
+}
+
+func (self *OxmEthSrcMasked) GetValue() net.HardwareAddr {
+	return self.Value
+}
+
+func (self *OxmEthSrcMasked) SetValue(v net.HardwareAddr) {
+	self.Value = v
+}
+
+func (self *OxmEthSrcMasked) GetValueMask() net.HardwareAddr {
+	return self.ValueMask
+}
+
+func (self *OxmEthSrcMasked) SetValueMask(v net.HardwareAddr) {
+	self.ValueMask = v
+}
+
+func (self *OxmEthSrcMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeOxmEthSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmEthSrcMasked, error) {
+	_oxmethsrcmasked := &OxmEthSrcMasked{Oxm: parent}
+	if decoder.Length() < 12 {
+		return nil, fmt.Errorf("OxmEthSrcMasked packet too short: %d < 12", decoder.Length())
+	}
+	_oxmethsrcmasked.Value = net.HardwareAddr(decoder.Read(6))
+	_oxmethsrcmasked.ValueMask = net.HardwareAddr(decoder.Read(6))
+	return _oxmethsrcmasked, nil
+}
+
+func NewOxmEthSrcMasked() *OxmEthSrcMasked {
+	obj := &OxmEthSrcMasked{
+		Oxm: NewOxm(2147485964),
+	}
+	return obj
+}
+func (self *OxmEthSrcMasked) GetOXMName() string {
+	return "eth_src_masked"
+}
+
+func (self *OxmEthSrcMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmEthSrcMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *OxmEthSrcMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmEthType struct {
+	*Oxm
+	Value EthernetType
+}
+
+type IOxmEthType interface {
+	goloxi.IOxm
+	GetValue() EthernetType
+}
+
+func (self *OxmEthType) GetValue() EthernetType {
+	return self.Value
+}
+
+func (self *OxmEthType) SetValue(v EthernetType) {
+	self.Value = v
+}
+
+func (self *OxmEthType) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Value))
+
+	return nil
+}
+
+func DecodeOxmEthType(parent *Oxm, decoder *goloxi.Decoder) (*OxmEthType, error) {
+	_oxmethtype := &OxmEthType{Oxm: parent}
+	if decoder.Length() < 2 {
+		return nil, fmt.Errorf("OxmEthType packet too short: %d < 2", decoder.Length())
+	}
+	_oxmethtype.Value = EthernetType(decoder.ReadUint16())
+	return _oxmethtype, nil
+}
+
+func NewOxmEthType() *OxmEthType {
+	obj := &OxmEthType{
+		Oxm: NewOxm(2147486210),
+	}
+	return obj
+}
+func (self *OxmEthType) GetOXMName() string {
+	return "eth_type"
+}
+
+func (self *OxmEthType) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmEthType) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmEthTypeMasked struct {
+	*Oxm
+	Value     EthernetType
+	ValueMask uint16
+}
+
+type IOxmEthTypeMasked interface {
+	goloxi.IOxm
+	GetValue() EthernetType
+	GetValueMask() uint16
+}
+
+func (self *OxmEthTypeMasked) GetValue() EthernetType {
+	return self.Value
+}
+
+func (self *OxmEthTypeMasked) SetValue(v EthernetType) {
+	self.Value = v
+}
+
+func (self *OxmEthTypeMasked) GetValueMask() uint16 {
+	return self.ValueMask
+}
+
+func (self *OxmEthTypeMasked) SetValueMask(v uint16) {
+	self.ValueMask = v
+}
+
+func (self *OxmEthTypeMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Value))
+	encoder.PutUint16(uint16(self.ValueMask))
+
+	return nil
+}
+
+func DecodeOxmEthTypeMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmEthTypeMasked, error) {
+	_oxmethtypemasked := &OxmEthTypeMasked{Oxm: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("OxmEthTypeMasked packet too short: %d < 4", decoder.Length())
+	}
+	_oxmethtypemasked.Value = EthernetType(decoder.ReadUint16())
+	_oxmethtypemasked.ValueMask = uint16(decoder.ReadUint16())
+	return _oxmethtypemasked, nil
+}
+
+func NewOxmEthTypeMasked() *OxmEthTypeMasked {
+	obj := &OxmEthTypeMasked{
+		Oxm: NewOxm(2147486468),
+	}
+	return obj
+}
+func (self *OxmEthTypeMasked) GetOXMName() string {
+	return "eth_type_masked"
+}
+
+func (self *OxmEthTypeMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmEthTypeMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *OxmEthTypeMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmIcmpv4Code struct {
+	*Oxm
+	Value uint8
+}
+
+type IOxmIcmpv4Code interface {
+	goloxi.IOxm
+	GetValue() uint8
+}
+
+func (self *OxmIcmpv4Code) GetValue() uint8 {
+	return self.Value
+}
+
+func (self *OxmIcmpv4Code) SetValue(v uint8) {
+	self.Value = v
+}
+
+func (self *OxmIcmpv4Code) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint8(uint8(self.Value))
+
+	return nil
+}
+
+func DecodeOxmIcmpv4Code(parent *Oxm, decoder *goloxi.Decoder) (*OxmIcmpv4Code, error) {
+	_oxmicmpv4code := &OxmIcmpv4Code{Oxm: parent}
+	if decoder.Length() < 1 {
+		return nil, fmt.Errorf("OxmIcmpv4Code packet too short: %d < 1", decoder.Length())
+	}
+	_oxmicmpv4code.Value = uint8(decoder.ReadByte())
+	return _oxmicmpv4code, nil
+}
+
+func NewOxmIcmpv4Code() *OxmIcmpv4Code {
+	obj := &OxmIcmpv4Code{
+		Oxm: NewOxm(2147493889),
+	}
+	return obj
+}
+func (self *OxmIcmpv4Code) GetOXMName() string {
+	return "icmpv4_code"
+}
+
+func (self *OxmIcmpv4Code) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmIcmpv4Code) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmIcmpv4CodeMasked struct {
+	*Oxm
+	Value     uint8
+	ValueMask uint8
+}
+
+type IOxmIcmpv4CodeMasked interface {
+	goloxi.IOxm
+	GetValue() uint8
+	GetValueMask() uint8
+}
+
+func (self *OxmIcmpv4CodeMasked) GetValue() uint8 {
+	return self.Value
+}
+
+func (self *OxmIcmpv4CodeMasked) SetValue(v uint8) {
+	self.Value = v
+}
+
+func (self *OxmIcmpv4CodeMasked) GetValueMask() uint8 {
+	return self.ValueMask
+}
+
+func (self *OxmIcmpv4CodeMasked) SetValueMask(v uint8) {
+	self.ValueMask = v
+}
+
+func (self *OxmIcmpv4CodeMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint8(uint8(self.Value))
+	encoder.PutUint8(uint8(self.ValueMask))
+
+	return nil
+}
+
+func DecodeOxmIcmpv4CodeMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIcmpv4CodeMasked, error) {
+	_oxmicmpv4codemasked := &OxmIcmpv4CodeMasked{Oxm: parent}
+	if decoder.Length() < 2 {
+		return nil, fmt.Errorf("OxmIcmpv4CodeMasked packet too short: %d < 2", decoder.Length())
+	}
+	_oxmicmpv4codemasked.Value = uint8(decoder.ReadByte())
+	_oxmicmpv4codemasked.ValueMask = uint8(decoder.ReadByte())
+	return _oxmicmpv4codemasked, nil
+}
+
+func NewOxmIcmpv4CodeMasked() *OxmIcmpv4CodeMasked {
+	obj := &OxmIcmpv4CodeMasked{
+		Oxm: NewOxm(2147494146),
+	}
+	return obj
+}
+func (self *OxmIcmpv4CodeMasked) GetOXMName() string {
+	return "icmpv4_code_masked"
+}
+
+func (self *OxmIcmpv4CodeMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmIcmpv4CodeMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *OxmIcmpv4CodeMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmIcmpv4Type struct {
+	*Oxm
+	Value IcmpType
+}
+
+type IOxmIcmpv4Type interface {
+	goloxi.IOxm
+	GetValue() IcmpType
+}
+
+func (self *OxmIcmpv4Type) GetValue() IcmpType {
+	return self.Value
+}
+
+func (self *OxmIcmpv4Type) SetValue(v IcmpType) {
+	self.Value = v
+}
+
+func (self *OxmIcmpv4Type) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint8(uint8(self.Value))
+
+	return nil
+}
+
+func DecodeOxmIcmpv4Type(parent *Oxm, decoder *goloxi.Decoder) (*OxmIcmpv4Type, error) {
+	_oxmicmpv4type := &OxmIcmpv4Type{Oxm: parent}
+	if decoder.Length() < 1 {
+		return nil, fmt.Errorf("OxmIcmpv4Type packet too short: %d < 1", decoder.Length())
+	}
+	_oxmicmpv4type.Value = IcmpType(decoder.ReadByte())
+	return _oxmicmpv4type, nil
+}
+
+func NewOxmIcmpv4Type() *OxmIcmpv4Type {
+	obj := &OxmIcmpv4Type{
+		Oxm: NewOxm(2147493377),
+	}
+	return obj
+}
+func (self *OxmIcmpv4Type) GetOXMName() string {
+	return "icmpv4_type"
+}
+
+func (self *OxmIcmpv4Type) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmIcmpv4Type) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmIcmpv4TypeMasked struct {
+	*Oxm
+	Value     IcmpType
+	ValueMask uint8
+}
+
+type IOxmIcmpv4TypeMasked interface {
+	goloxi.IOxm
+	GetValue() IcmpType
+	GetValueMask() uint8
+}
+
+func (self *OxmIcmpv4TypeMasked) GetValue() IcmpType {
+	return self.Value
+}
+
+func (self *OxmIcmpv4TypeMasked) SetValue(v IcmpType) {
+	self.Value = v
+}
+
+func (self *OxmIcmpv4TypeMasked) GetValueMask() uint8 {
+	return self.ValueMask
+}
+
+func (self *OxmIcmpv4TypeMasked) SetValueMask(v uint8) {
+	self.ValueMask = v
+}
+
+func (self *OxmIcmpv4TypeMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint8(uint8(self.Value))
+	encoder.PutUint8(uint8(self.ValueMask))
+
+	return nil
+}
+
+func DecodeOxmIcmpv4TypeMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIcmpv4TypeMasked, error) {
+	_oxmicmpv4typemasked := &OxmIcmpv4TypeMasked{Oxm: parent}
+	if decoder.Length() < 2 {
+		return nil, fmt.Errorf("OxmIcmpv4TypeMasked packet too short: %d < 2", decoder.Length())
+	}
+	_oxmicmpv4typemasked.Value = IcmpType(decoder.ReadByte())
+	_oxmicmpv4typemasked.ValueMask = uint8(decoder.ReadByte())
+	return _oxmicmpv4typemasked, nil
+}
+
+func NewOxmIcmpv4TypeMasked() *OxmIcmpv4TypeMasked {
+	obj := &OxmIcmpv4TypeMasked{
+		Oxm: NewOxm(2147493634),
+	}
+	return obj
+}
+func (self *OxmIcmpv4TypeMasked) GetOXMName() string {
+	return "icmpv4_type_masked"
+}
+
+func (self *OxmIcmpv4TypeMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmIcmpv4TypeMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *OxmIcmpv4TypeMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmIcmpv6Code struct {
+	*Oxm
+	Value uint8
+}
+
+type IOxmIcmpv6Code interface {
+	goloxi.IOxm
+	GetValue() uint8
+}
+
+func (self *OxmIcmpv6Code) GetValue() uint8 {
+	return self.Value
+}
+
+func (self *OxmIcmpv6Code) SetValue(v uint8) {
+	self.Value = v
+}
+
+func (self *OxmIcmpv6Code) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint8(uint8(self.Value))
+
+	return nil
+}
+
+func DecodeOxmIcmpv6Code(parent *Oxm, decoder *goloxi.Decoder) (*OxmIcmpv6Code, error) {
+	_oxmicmpv6code := &OxmIcmpv6Code{Oxm: parent}
+	if decoder.Length() < 1 {
+		return nil, fmt.Errorf("OxmIcmpv6Code packet too short: %d < 1", decoder.Length())
+	}
+	_oxmicmpv6code.Value = uint8(decoder.ReadByte())
+	return _oxmicmpv6code, nil
+}
+
+func NewOxmIcmpv6Code() *OxmIcmpv6Code {
+	obj := &OxmIcmpv6Code{
+		Oxm: NewOxm(2147499009),
+	}
+	return obj
+}
+func (self *OxmIcmpv6Code) GetOXMName() string {
+	return "icmpv6_code"
+}
+
+func (self *OxmIcmpv6Code) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmIcmpv6Code) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmIcmpv6CodeMasked struct {
+	*Oxm
+	Value     uint8
+	ValueMask uint8
+}
+
+type IOxmIcmpv6CodeMasked interface {
+	goloxi.IOxm
+	GetValue() uint8
+	GetValueMask() uint8
+}
+
+func (self *OxmIcmpv6CodeMasked) GetValue() uint8 {
+	return self.Value
+}
+
+func (self *OxmIcmpv6CodeMasked) SetValue(v uint8) {
+	self.Value = v
+}
+
+func (self *OxmIcmpv6CodeMasked) GetValueMask() uint8 {
+	return self.ValueMask
+}
+
+func (self *OxmIcmpv6CodeMasked) SetValueMask(v uint8) {
+	self.ValueMask = v
+}
+
+func (self *OxmIcmpv6CodeMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint8(uint8(self.Value))
+	encoder.PutUint8(uint8(self.ValueMask))
+
+	return nil
+}
+
+func DecodeOxmIcmpv6CodeMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIcmpv6CodeMasked, error) {
+	_oxmicmpv6codemasked := &OxmIcmpv6CodeMasked{Oxm: parent}
+	if decoder.Length() < 2 {
+		return nil, fmt.Errorf("OxmIcmpv6CodeMasked packet too short: %d < 2", decoder.Length())
+	}
+	_oxmicmpv6codemasked.Value = uint8(decoder.ReadByte())
+	_oxmicmpv6codemasked.ValueMask = uint8(decoder.ReadByte())
+	return _oxmicmpv6codemasked, nil
+}
+
+func NewOxmIcmpv6CodeMasked() *OxmIcmpv6CodeMasked {
+	obj := &OxmIcmpv6CodeMasked{
+		Oxm: NewOxm(2147499266),
+	}
+	return obj
+}
+func (self *OxmIcmpv6CodeMasked) GetOXMName() string {
+	return "icmpv6_code_masked"
+}
+
+func (self *OxmIcmpv6CodeMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmIcmpv6CodeMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *OxmIcmpv6CodeMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmIcmpv6Type struct {
+	*Oxm
+	Value Icmpv6Type
+}
+
+type IOxmIcmpv6Type interface {
+	goloxi.IOxm
+	GetValue() Icmpv6Type
+}
+
+func (self *OxmIcmpv6Type) GetValue() Icmpv6Type {
+	return self.Value
+}
+
+func (self *OxmIcmpv6Type) SetValue(v Icmpv6Type) {
+	self.Value = v
+}
+
+func (self *OxmIcmpv6Type) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint8(uint8(self.Value))
+
+	return nil
+}
+
+func DecodeOxmIcmpv6Type(parent *Oxm, decoder *goloxi.Decoder) (*OxmIcmpv6Type, error) {
+	_oxmicmpv6type := &OxmIcmpv6Type{Oxm: parent}
+	if decoder.Length() < 1 {
+		return nil, fmt.Errorf("OxmIcmpv6Type packet too short: %d < 1", decoder.Length())
+	}
+	_oxmicmpv6type.Value = Icmpv6Type(decoder.ReadByte())
+	return _oxmicmpv6type, nil
+}
+
+func NewOxmIcmpv6Type() *OxmIcmpv6Type {
+	obj := &OxmIcmpv6Type{
+		Oxm: NewOxm(2147498497),
+	}
+	return obj
+}
+func (self *OxmIcmpv6Type) GetOXMName() string {
+	return "icmpv6_type"
+}
+
+func (self *OxmIcmpv6Type) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmIcmpv6Type) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmIcmpv6TypeMasked struct {
+	*Oxm
+	Value     Icmpv6Type
+	ValueMask uint8
+}
+
+type IOxmIcmpv6TypeMasked interface {
+	goloxi.IOxm
+	GetValue() Icmpv6Type
+	GetValueMask() uint8
+}
+
+func (self *OxmIcmpv6TypeMasked) GetValue() Icmpv6Type {
+	return self.Value
+}
+
+func (self *OxmIcmpv6TypeMasked) SetValue(v Icmpv6Type) {
+	self.Value = v
+}
+
+func (self *OxmIcmpv6TypeMasked) GetValueMask() uint8 {
+	return self.ValueMask
+}
+
+func (self *OxmIcmpv6TypeMasked) SetValueMask(v uint8) {
+	self.ValueMask = v
+}
+
+func (self *OxmIcmpv6TypeMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint8(uint8(self.Value))
+	encoder.PutUint8(uint8(self.ValueMask))
+
+	return nil
+}
+
+func DecodeOxmIcmpv6TypeMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIcmpv6TypeMasked, error) {
+	_oxmicmpv6typemasked := &OxmIcmpv6TypeMasked{Oxm: parent}
+	if decoder.Length() < 2 {
+		return nil, fmt.Errorf("OxmIcmpv6TypeMasked packet too short: %d < 2", decoder.Length())
+	}
+	_oxmicmpv6typemasked.Value = Icmpv6Type(decoder.ReadByte())
+	_oxmicmpv6typemasked.ValueMask = uint8(decoder.ReadByte())
+	return _oxmicmpv6typemasked, nil
+}
+
+func NewOxmIcmpv6TypeMasked() *OxmIcmpv6TypeMasked {
+	obj := &OxmIcmpv6TypeMasked{
+		Oxm: NewOxm(2147498754),
+	}
+	return obj
+}
+func (self *OxmIcmpv6TypeMasked) GetOXMName() string {
+	return "icmpv6_type_masked"
+}
+
+func (self *OxmIcmpv6TypeMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmIcmpv6TypeMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *OxmIcmpv6TypeMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmInPhyPort struct {
+	*Oxm
+	Value Port
+}
+
+type IOxmInPhyPort interface {
+	goloxi.IOxm
+	GetValue() Port
+}
+
+func (self *OxmInPhyPort) GetValue() Port {
+	return self.Value
+}
+
+func (self *OxmInPhyPort) SetValue(v Port) {
+	self.Value = v
+}
+
+func (self *OxmInPhyPort) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	self.Value.Serialize(encoder)
+
+	return nil
+}
+
+func DecodeOxmInPhyPort(parent *Oxm, decoder *goloxi.Decoder) (*OxmInPhyPort, error) {
+	_oxminphyport := &OxmInPhyPort{Oxm: parent}
+	if decoder.Length() < 2 {
+		return nil, fmt.Errorf("OxmInPhyPort packet too short: %d < 2", decoder.Length())
+	}
+	_oxminphyport.Value.Decode(decoder)
+	return _oxminphyport, nil
+}
+
+func NewOxmInPhyPort() *OxmInPhyPort {
+	obj := &OxmInPhyPort{
+		Oxm: NewOxm(2147484164),
+	}
+	return obj
+}
+func (self *OxmInPhyPort) GetOXMName() string {
+	return "in_phy_port"
+}
+
+func (self *OxmInPhyPort) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmInPhyPort) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmInPhyPortMasked struct {
+	*Oxm
+	Value     Port
+	ValueMask Port
+}
+
+type IOxmInPhyPortMasked interface {
+	goloxi.IOxm
+	GetValue() Port
+	GetValueMask() Port
+}
+
+func (self *OxmInPhyPortMasked) GetValue() Port {
+	return self.Value
+}
+
+func (self *OxmInPhyPortMasked) SetValue(v Port) {
+	self.Value = v
+}
+
+func (self *OxmInPhyPortMasked) GetValueMask() Port {
+	return self.ValueMask
+}
+
+func (self *OxmInPhyPortMasked) SetValueMask(v Port) {
+	self.ValueMask = v
+}
+
+func (self *OxmInPhyPortMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	self.Value.Serialize(encoder)
+	self.ValueMask.Serialize(encoder)
+
+	return nil
+}
+
+func DecodeOxmInPhyPortMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmInPhyPortMasked, error) {
+	_oxminphyportmasked := &OxmInPhyPortMasked{Oxm: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("OxmInPhyPortMasked packet too short: %d < 4", decoder.Length())
+	}
+	_oxminphyportmasked.Value.Decode(decoder)
+	_oxminphyportmasked.ValueMask.Decode(decoder)
+	return _oxminphyportmasked, nil
+}
+
+func NewOxmInPhyPortMasked() *OxmInPhyPortMasked {
+	obj := &OxmInPhyPortMasked{
+		Oxm: NewOxm(2147484424),
+	}
+	return obj
+}
+func (self *OxmInPhyPortMasked) GetOXMName() string {
+	return "in_phy_port_masked"
+}
+
+func (self *OxmInPhyPortMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmInPhyPortMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *OxmInPhyPortMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmInPort struct {
+	*Oxm
+	Value Port
+}
+
+type IOxmInPort interface {
+	goloxi.IOxm
+	GetValue() Port
+}
+
+func (self *OxmInPort) GetValue() Port {
+	return self.Value
+}
+
+func (self *OxmInPort) SetValue(v Port) {
+	self.Value = v
+}
+
+func (self *OxmInPort) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	self.Value.Serialize(encoder)
+
+	return nil
+}
+
+func DecodeOxmInPort(parent *Oxm, decoder *goloxi.Decoder) (*OxmInPort, error) {
+	_oxminport := &OxmInPort{Oxm: parent}
+	if decoder.Length() < 2 {
+		return nil, fmt.Errorf("OxmInPort packet too short: %d < 2", decoder.Length())
+	}
+	_oxminport.Value.Decode(decoder)
+	return _oxminport, nil
+}
+
+func NewOxmInPort() *OxmInPort {
+	obj := &OxmInPort{
+		Oxm: NewOxm(2147483652),
+	}
+	return obj
+}
+func (self *OxmInPort) GetOXMName() string {
+	return "in_port"
+}
+
+func (self *OxmInPort) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmInPort) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmInPortMasked struct {
+	*Oxm
+	Value     Port
+	ValueMask Port
+}
+
+type IOxmInPortMasked interface {
+	goloxi.IOxm
+	GetValue() Port
+	GetValueMask() Port
+}
+
+func (self *OxmInPortMasked) GetValue() Port {
+	return self.Value
+}
+
+func (self *OxmInPortMasked) SetValue(v Port) {
+	self.Value = v
+}
+
+func (self *OxmInPortMasked) GetValueMask() Port {
+	return self.ValueMask
+}
+
+func (self *OxmInPortMasked) SetValueMask(v Port) {
+	self.ValueMask = v
+}
+
+func (self *OxmInPortMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	self.Value.Serialize(encoder)
+	self.ValueMask.Serialize(encoder)
+
+	return nil
+}
+
+func DecodeOxmInPortMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmInPortMasked, error) {
+	_oxminportmasked := &OxmInPortMasked{Oxm: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("OxmInPortMasked packet too short: %d < 4", decoder.Length())
+	}
+	_oxminportmasked.Value.Decode(decoder)
+	_oxminportmasked.ValueMask.Decode(decoder)
+	return _oxminportmasked, nil
+}
+
+func NewOxmInPortMasked() *OxmInPortMasked {
+	obj := &OxmInPortMasked{
+		Oxm: NewOxm(2147483912),
+	}
+	return obj
+}
+func (self *OxmInPortMasked) GetOXMName() string {
+	return "in_port_masked"
+}
+
+func (self *OxmInPortMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmInPortMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *OxmInPortMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmIpDscp struct {
+	*Oxm
+	Value uint8
+}
+
+type IOxmIpDscp interface {
+	goloxi.IOxm
+	GetValue() uint8
+}
+
+func (self *OxmIpDscp) GetValue() uint8 {
+	return self.Value
+}
+
+func (self *OxmIpDscp) SetValue(v uint8) {
+	self.Value = v
+}
+
+func (self *OxmIpDscp) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint8(uint8(self.Value))
+
+	return nil
+}
+
+func DecodeOxmIpDscp(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpDscp, error) {
+	_oxmipdscp := &OxmIpDscp{Oxm: parent}
+	if decoder.Length() < 1 {
+		return nil, fmt.Errorf("OxmIpDscp packet too short: %d < 1", decoder.Length())
+	}
+	_oxmipdscp.Value = uint8(decoder.ReadByte())
+	return _oxmipdscp, nil
+}
+
+func NewOxmIpDscp() *OxmIpDscp {
+	obj := &OxmIpDscp{
+		Oxm: NewOxm(2147487745),
+	}
+	return obj
+}
+func (self *OxmIpDscp) GetOXMName() string {
+	return "ip_dscp"
+}
+
+func (self *OxmIpDscp) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmIpDscp) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmIpDscpMasked struct {
+	*Oxm
+	Value     uint8
+	ValueMask uint8
+}
+
+type IOxmIpDscpMasked interface {
+	goloxi.IOxm
+	GetValue() uint8
+	GetValueMask() uint8
+}
+
+func (self *OxmIpDscpMasked) GetValue() uint8 {
+	return self.Value
+}
+
+func (self *OxmIpDscpMasked) SetValue(v uint8) {
+	self.Value = v
+}
+
+func (self *OxmIpDscpMasked) GetValueMask() uint8 {
+	return self.ValueMask
+}
+
+func (self *OxmIpDscpMasked) SetValueMask(v uint8) {
+	self.ValueMask = v
+}
+
+func (self *OxmIpDscpMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint8(uint8(self.Value))
+	encoder.PutUint8(uint8(self.ValueMask))
+
+	return nil
+}
+
+func DecodeOxmIpDscpMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpDscpMasked, error) {
+	_oxmipdscpmasked := &OxmIpDscpMasked{Oxm: parent}
+	if decoder.Length() < 2 {
+		return nil, fmt.Errorf("OxmIpDscpMasked packet too short: %d < 2", decoder.Length())
+	}
+	_oxmipdscpmasked.Value = uint8(decoder.ReadByte())
+	_oxmipdscpmasked.ValueMask = uint8(decoder.ReadByte())
+	return _oxmipdscpmasked, nil
+}
+
+func NewOxmIpDscpMasked() *OxmIpDscpMasked {
+	obj := &OxmIpDscpMasked{
+		Oxm: NewOxm(2147488002),
+	}
+	return obj
+}
+func (self *OxmIpDscpMasked) GetOXMName() string {
+	return "ip_dscp_masked"
+}
+
+func (self *OxmIpDscpMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmIpDscpMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *OxmIpDscpMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmIpEcn struct {
+	*Oxm
+	Value uint8
+}
+
+type IOxmIpEcn interface {
+	goloxi.IOxm
+	GetValue() uint8
+}
+
+func (self *OxmIpEcn) GetValue() uint8 {
+	return self.Value
+}
+
+func (self *OxmIpEcn) SetValue(v uint8) {
+	self.Value = v
+}
+
+func (self *OxmIpEcn) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint8(uint8(self.Value))
+
+	return nil
+}
+
+func DecodeOxmIpEcn(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpEcn, error) {
+	_oxmipecn := &OxmIpEcn{Oxm: parent}
+	if decoder.Length() < 1 {
+		return nil, fmt.Errorf("OxmIpEcn packet too short: %d < 1", decoder.Length())
+	}
+	_oxmipecn.Value = uint8(decoder.ReadByte())
+	return _oxmipecn, nil
+}
+
+func NewOxmIpEcn() *OxmIpEcn {
+	obj := &OxmIpEcn{
+		Oxm: NewOxm(2147488257),
+	}
+	return obj
+}
+func (self *OxmIpEcn) GetOXMName() string {
+	return "ip_ecn"
+}
+
+func (self *OxmIpEcn) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmIpEcn) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmIpEcnMasked struct {
+	*Oxm
+	Value     uint8
+	ValueMask uint8
+}
+
+type IOxmIpEcnMasked interface {
+	goloxi.IOxm
+	GetValue() uint8
+	GetValueMask() uint8
+}
+
+func (self *OxmIpEcnMasked) GetValue() uint8 {
+	return self.Value
+}
+
+func (self *OxmIpEcnMasked) SetValue(v uint8) {
+	self.Value = v
+}
+
+func (self *OxmIpEcnMasked) GetValueMask() uint8 {
+	return self.ValueMask
+}
+
+func (self *OxmIpEcnMasked) SetValueMask(v uint8) {
+	self.ValueMask = v
+}
+
+func (self *OxmIpEcnMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint8(uint8(self.Value))
+	encoder.PutUint8(uint8(self.ValueMask))
+
+	return nil
+}
+
+func DecodeOxmIpEcnMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpEcnMasked, error) {
+	_oxmipecnmasked := &OxmIpEcnMasked{Oxm: parent}
+	if decoder.Length() < 2 {
+		return nil, fmt.Errorf("OxmIpEcnMasked packet too short: %d < 2", decoder.Length())
+	}
+	_oxmipecnmasked.Value = uint8(decoder.ReadByte())
+	_oxmipecnmasked.ValueMask = uint8(decoder.ReadByte())
+	return _oxmipecnmasked, nil
+}
+
+func NewOxmIpEcnMasked() *OxmIpEcnMasked {
+	obj := &OxmIpEcnMasked{
+		Oxm: NewOxm(2147488514),
+	}
+	return obj
+}
+func (self *OxmIpEcnMasked) GetOXMName() string {
+	return "ip_ecn_masked"
+}
+
+func (self *OxmIpEcnMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmIpEcnMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *OxmIpEcnMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmIpProto struct {
+	*Oxm
+	Value IpPrototype
+}
+
+type IOxmIpProto interface {
+	goloxi.IOxm
+	GetValue() IpPrototype
+}
+
+func (self *OxmIpProto) GetValue() IpPrototype {
+	return self.Value
+}
+
+func (self *OxmIpProto) SetValue(v IpPrototype) {
+	self.Value = v
+}
+
+func (self *OxmIpProto) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint8(uint8(self.Value))
+
+	return nil
+}
+
+func DecodeOxmIpProto(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpProto, error) {
+	_oxmipproto := &OxmIpProto{Oxm: parent}
+	if decoder.Length() < 1 {
+		return nil, fmt.Errorf("OxmIpProto packet too short: %d < 1", decoder.Length())
+	}
+	_oxmipproto.Value = IpPrototype(decoder.ReadByte())
+	return _oxmipproto, nil
+}
+
+func NewOxmIpProto() *OxmIpProto {
+	obj := &OxmIpProto{
+		Oxm: NewOxm(2147488769),
+	}
+	return obj
+}
+func (self *OxmIpProto) GetOXMName() string {
+	return "ip_proto"
+}
+
+func (self *OxmIpProto) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmIpProto) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmIpProtoMasked struct {
+	*Oxm
+	Value     IpPrototype
+	ValueMask uint8
+}
+
+type IOxmIpProtoMasked interface {
+	goloxi.IOxm
+	GetValue() IpPrototype
+	GetValueMask() uint8
+}
+
+func (self *OxmIpProtoMasked) GetValue() IpPrototype {
+	return self.Value
+}
+
+func (self *OxmIpProtoMasked) SetValue(v IpPrototype) {
+	self.Value = v
+}
+
+func (self *OxmIpProtoMasked) GetValueMask() uint8 {
+	return self.ValueMask
+}
+
+func (self *OxmIpProtoMasked) SetValueMask(v uint8) {
+	self.ValueMask = v
+}
+
+func (self *OxmIpProtoMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint8(uint8(self.Value))
+	encoder.PutUint8(uint8(self.ValueMask))
+
+	return nil
+}
+
+func DecodeOxmIpProtoMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpProtoMasked, error) {
+	_oxmipprotomasked := &OxmIpProtoMasked{Oxm: parent}
+	if decoder.Length() < 2 {
+		return nil, fmt.Errorf("OxmIpProtoMasked packet too short: %d < 2", decoder.Length())
+	}
+	_oxmipprotomasked.Value = IpPrototype(decoder.ReadByte())
+	_oxmipprotomasked.ValueMask = uint8(decoder.ReadByte())
+	return _oxmipprotomasked, nil
+}
+
+func NewOxmIpProtoMasked() *OxmIpProtoMasked {
+	obj := &OxmIpProtoMasked{
+		Oxm: NewOxm(2147489026),
+	}
+	return obj
+}
+func (self *OxmIpProtoMasked) GetOXMName() string {
+	return "ip_proto_masked"
+}
+
+func (self *OxmIpProtoMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmIpProtoMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *OxmIpProtoMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmIpv4Dst struct {
+	*Oxm
+	Value net.IP
+}
+
+type IOxmIpv4Dst interface {
+	goloxi.IOxm
+	GetValue() net.IP
+}
+
+func (self *OxmIpv4Dst) GetValue() net.IP {
+	return self.Value
+}
+
+func (self *OxmIpv4Dst) SetValue(v net.IP) {
+	self.Value = v
+}
+
+func (self *OxmIpv4Dst) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value.To4())
+
+	return nil
+}
+
+func DecodeOxmIpv4Dst(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv4Dst, error) {
+	_oxmipv4dst := &OxmIpv4Dst{Oxm: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("OxmIpv4Dst packet too short: %d < 4", decoder.Length())
+	}
+	_oxmipv4dst.Value = net.IP(decoder.Read(4))
+	return _oxmipv4dst, nil
+}
+
+func NewOxmIpv4Dst() *OxmIpv4Dst {
+	obj := &OxmIpv4Dst{
+		Oxm: NewOxm(2147489796),
+	}
+	return obj
+}
+func (self *OxmIpv4Dst) GetOXMName() string {
+	return "ipv4_dst"
+}
+
+func (self *OxmIpv4Dst) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmIpv4Dst) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmIpv4DstMasked struct {
+	*Oxm
+	Value     net.IP
+	ValueMask net.IP
+}
+
+type IOxmIpv4DstMasked interface {
+	goloxi.IOxm
+	GetValue() net.IP
+	GetValueMask() net.IP
+}
+
+func (self *OxmIpv4DstMasked) GetValue() net.IP {
+	return self.Value
+}
+
+func (self *OxmIpv4DstMasked) SetValue(v net.IP) {
+	self.Value = v
+}
+
+func (self *OxmIpv4DstMasked) GetValueMask() net.IP {
+	return self.ValueMask
+}
+
+func (self *OxmIpv4DstMasked) SetValueMask(v net.IP) {
+	self.ValueMask = v
+}
+
+func (self *OxmIpv4DstMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value.To4())
+	encoder.Write(self.ValueMask.To4())
+
+	return nil
+}
+
+func DecodeOxmIpv4DstMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv4DstMasked, error) {
+	_oxmipv4dstmasked := &OxmIpv4DstMasked{Oxm: parent}
+	if decoder.Length() < 8 {
+		return nil, fmt.Errorf("OxmIpv4DstMasked packet too short: %d < 8", decoder.Length())
+	}
+	_oxmipv4dstmasked.Value = net.IP(decoder.Read(4))
+	_oxmipv4dstmasked.ValueMask = net.IP(decoder.Read(4))
+	return _oxmipv4dstmasked, nil
+}
+
+func NewOxmIpv4DstMasked() *OxmIpv4DstMasked {
+	obj := &OxmIpv4DstMasked{
+		Oxm: NewOxm(2147490056),
+	}
+	return obj
+}
+func (self *OxmIpv4DstMasked) GetOXMName() string {
+	return "ipv4_dst_masked"
+}
+
+func (self *OxmIpv4DstMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmIpv4DstMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *OxmIpv4DstMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmIpv4Src struct {
+	*Oxm
+	Value net.IP
+}
+
+type IOxmIpv4Src interface {
+	goloxi.IOxm
+	GetValue() net.IP
+}
+
+func (self *OxmIpv4Src) GetValue() net.IP {
+	return self.Value
+}
+
+func (self *OxmIpv4Src) SetValue(v net.IP) {
+	self.Value = v
+}
+
+func (self *OxmIpv4Src) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value.To4())
+
+	return nil
+}
+
+func DecodeOxmIpv4Src(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv4Src, error) {
+	_oxmipv4src := &OxmIpv4Src{Oxm: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("OxmIpv4Src packet too short: %d < 4", decoder.Length())
+	}
+	_oxmipv4src.Value = net.IP(decoder.Read(4))
+	return _oxmipv4src, nil
+}
+
+func NewOxmIpv4Src() *OxmIpv4Src {
+	obj := &OxmIpv4Src{
+		Oxm: NewOxm(2147489284),
+	}
+	return obj
+}
+func (self *OxmIpv4Src) GetOXMName() string {
+	return "ipv4_src"
+}
+
+func (self *OxmIpv4Src) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmIpv4Src) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmIpv4SrcMasked struct {
+	*Oxm
+	Value     net.IP
+	ValueMask net.IP
+}
+
+type IOxmIpv4SrcMasked interface {
+	goloxi.IOxm
+	GetValue() net.IP
+	GetValueMask() net.IP
+}
+
+func (self *OxmIpv4SrcMasked) GetValue() net.IP {
+	return self.Value
+}
+
+func (self *OxmIpv4SrcMasked) SetValue(v net.IP) {
+	self.Value = v
+}
+
+func (self *OxmIpv4SrcMasked) GetValueMask() net.IP {
+	return self.ValueMask
+}
+
+func (self *OxmIpv4SrcMasked) SetValueMask(v net.IP) {
+	self.ValueMask = v
+}
+
+func (self *OxmIpv4SrcMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value.To4())
+	encoder.Write(self.ValueMask.To4())
+
+	return nil
+}
+
+func DecodeOxmIpv4SrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv4SrcMasked, error) {
+	_oxmipv4srcmasked := &OxmIpv4SrcMasked{Oxm: parent}
+	if decoder.Length() < 8 {
+		return nil, fmt.Errorf("OxmIpv4SrcMasked packet too short: %d < 8", decoder.Length())
+	}
+	_oxmipv4srcmasked.Value = net.IP(decoder.Read(4))
+	_oxmipv4srcmasked.ValueMask = net.IP(decoder.Read(4))
+	return _oxmipv4srcmasked, nil
+}
+
+func NewOxmIpv4SrcMasked() *OxmIpv4SrcMasked {
+	obj := &OxmIpv4SrcMasked{
+		Oxm: NewOxm(2147489544),
+	}
+	return obj
+}
+func (self *OxmIpv4SrcMasked) GetOXMName() string {
+	return "ipv4_src_masked"
+}
+
+func (self *OxmIpv4SrcMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmIpv4SrcMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *OxmIpv4SrcMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmIpv6Dst struct {
+	*Oxm
+	Value net.IP
+}
+
+type IOxmIpv6Dst interface {
+	goloxi.IOxm
+	GetValue() net.IP
+}
+
+func (self *OxmIpv6Dst) GetValue() net.IP {
+	return self.Value
+}
+
+func (self *OxmIpv6Dst) SetValue(v net.IP) {
+	self.Value = v
+}
+
+func (self *OxmIpv6Dst) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value.To16())
+
+	return nil
+}
+
+func DecodeOxmIpv6Dst(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6Dst, error) {
+	_oxmipv6dst := &OxmIpv6Dst{Oxm: parent}
+	if decoder.Length() < 16 {
+		return nil, fmt.Errorf("OxmIpv6Dst packet too short: %d < 16", decoder.Length())
+	}
+	_oxmipv6dst.Value = net.IP(decoder.Read(16))
+	return _oxmipv6dst, nil
+}
+
+func NewOxmIpv6Dst() *OxmIpv6Dst {
+	obj := &OxmIpv6Dst{
+		Oxm: NewOxm(2147497488),
+	}
+	return obj
+}
+func (self *OxmIpv6Dst) GetOXMName() string {
+	return "ipv6_dst"
+}
+
+func (self *OxmIpv6Dst) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmIpv6Dst) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmIpv6DstMasked struct {
+	*Oxm
+	Value     net.IP
+	ValueMask net.IP
+}
+
+type IOxmIpv6DstMasked interface {
+	goloxi.IOxm
+	GetValue() net.IP
+	GetValueMask() net.IP
+}
+
+func (self *OxmIpv6DstMasked) GetValue() net.IP {
+	return self.Value
+}
+
+func (self *OxmIpv6DstMasked) SetValue(v net.IP) {
+	self.Value = v
+}
+
+func (self *OxmIpv6DstMasked) GetValueMask() net.IP {
+	return self.ValueMask
+}
+
+func (self *OxmIpv6DstMasked) SetValueMask(v net.IP) {
+	self.ValueMask = v
+}
+
+func (self *OxmIpv6DstMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value.To16())
+	encoder.Write(self.ValueMask.To16())
+
+	return nil
+}
+
+func DecodeOxmIpv6DstMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6DstMasked, error) {
+	_oxmipv6dstmasked := &OxmIpv6DstMasked{Oxm: parent}
+	if decoder.Length() < 32 {
+		return nil, fmt.Errorf("OxmIpv6DstMasked packet too short: %d < 32", decoder.Length())
+	}
+	_oxmipv6dstmasked.Value = net.IP(decoder.Read(16))
+	_oxmipv6dstmasked.ValueMask = net.IP(decoder.Read(16))
+	return _oxmipv6dstmasked, nil
+}
+
+func NewOxmIpv6DstMasked() *OxmIpv6DstMasked {
+	obj := &OxmIpv6DstMasked{
+		Oxm: NewOxm(2147497760),
+	}
+	return obj
+}
+func (self *OxmIpv6DstMasked) GetOXMName() string {
+	return "ipv6_dst_masked"
+}
+
+func (self *OxmIpv6DstMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmIpv6DstMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *OxmIpv6DstMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmIpv6Flabel struct {
+	*Oxm
+	Value uint32
+}
+
+type IOxmIpv6Flabel interface {
+	goloxi.IOxm
+	GetValue() uint32
+}
+
+func (self *OxmIpv6Flabel) GetValue() uint32 {
+	return self.Value
+}
+
+func (self *OxmIpv6Flabel) SetValue(v uint32) {
+	self.Value = v
+}
+
+func (self *OxmIpv6Flabel) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Value))
+
+	return nil
+}
+
+func DecodeOxmIpv6Flabel(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6Flabel, error) {
+	_oxmipv6flabel := &OxmIpv6Flabel{Oxm: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("OxmIpv6Flabel packet too short: %d < 4", decoder.Length())
+	}
+	_oxmipv6flabel.Value = uint32(decoder.ReadUint32())
+	return _oxmipv6flabel, nil
+}
+
+func NewOxmIpv6Flabel() *OxmIpv6Flabel {
+	obj := &OxmIpv6Flabel{
+		Oxm: NewOxm(2147497988),
+	}
+	return obj
+}
+func (self *OxmIpv6Flabel) GetOXMName() string {
+	return "ipv6_flabel"
+}
+
+func (self *OxmIpv6Flabel) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmIpv6Flabel) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmIpv6FlabelMasked struct {
+	*Oxm
+	Value     uint32
+	ValueMask uint32
+}
+
+type IOxmIpv6FlabelMasked interface {
+	goloxi.IOxm
+	GetValue() uint32
+	GetValueMask() uint32
+}
+
+func (self *OxmIpv6FlabelMasked) GetValue() uint32 {
+	return self.Value
+}
+
+func (self *OxmIpv6FlabelMasked) SetValue(v uint32) {
+	self.Value = v
+}
+
+func (self *OxmIpv6FlabelMasked) GetValueMask() uint32 {
+	return self.ValueMask
+}
+
+func (self *OxmIpv6FlabelMasked) SetValueMask(v uint32) {
+	self.ValueMask = v
+}
+
+func (self *OxmIpv6FlabelMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Value))
+	encoder.PutUint32(uint32(self.ValueMask))
+
+	return nil
+}
+
+func DecodeOxmIpv6FlabelMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6FlabelMasked, error) {
+	_oxmipv6flabelmasked := &OxmIpv6FlabelMasked{Oxm: parent}
+	if decoder.Length() < 8 {
+		return nil, fmt.Errorf("OxmIpv6FlabelMasked packet too short: %d < 8", decoder.Length())
+	}
+	_oxmipv6flabelmasked.Value = uint32(decoder.ReadUint32())
+	_oxmipv6flabelmasked.ValueMask = uint32(decoder.ReadUint32())
+	return _oxmipv6flabelmasked, nil
+}
+
+func NewOxmIpv6FlabelMasked() *OxmIpv6FlabelMasked {
+	obj := &OxmIpv6FlabelMasked{
+		Oxm: NewOxm(2147498248),
+	}
+	return obj
+}
+func (self *OxmIpv6FlabelMasked) GetOXMName() string {
+	return "ipv6_flabel_masked"
+}
+
+func (self *OxmIpv6FlabelMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmIpv6FlabelMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *OxmIpv6FlabelMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmIpv6NdSll struct {
+	*Oxm
+	Value net.HardwareAddr
+}
+
+type IOxmIpv6NdSll interface {
+	goloxi.IOxm
+	GetValue() net.HardwareAddr
+}
+
+func (self *OxmIpv6NdSll) GetValue() net.HardwareAddr {
+	return self.Value
+}
+
+func (self *OxmIpv6NdSll) SetValue(v net.HardwareAddr) {
+	self.Value = v
+}
+
+func (self *OxmIpv6NdSll) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeOxmIpv6NdSll(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6NdSll, error) {
+	_oxmipv6ndsll := &OxmIpv6NdSll{Oxm: parent}
+	if decoder.Length() < 6 {
+		return nil, fmt.Errorf("OxmIpv6NdSll packet too short: %d < 6", decoder.Length())
+	}
+	_oxmipv6ndsll.Value = net.HardwareAddr(decoder.Read(6))
+	return _oxmipv6ndsll, nil
+}
+
+func NewOxmIpv6NdSll() *OxmIpv6NdSll {
+	obj := &OxmIpv6NdSll{
+		Oxm: NewOxm(2147500038),
+	}
+	return obj
+}
+func (self *OxmIpv6NdSll) GetOXMName() string {
+	return "ipv6_nd_sll"
+}
+
+func (self *OxmIpv6NdSll) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmIpv6NdSll) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmIpv6NdSllMasked struct {
+	*Oxm
+	Value     net.HardwareAddr
+	ValueMask net.HardwareAddr
+}
+
+type IOxmIpv6NdSllMasked interface {
+	goloxi.IOxm
+	GetValue() net.HardwareAddr
+	GetValueMask() net.HardwareAddr
+}
+
+func (self *OxmIpv6NdSllMasked) GetValue() net.HardwareAddr {
+	return self.Value
+}
+
+func (self *OxmIpv6NdSllMasked) SetValue(v net.HardwareAddr) {
+	self.Value = v
+}
+
+func (self *OxmIpv6NdSllMasked) GetValueMask() net.HardwareAddr {
+	return self.ValueMask
+}
+
+func (self *OxmIpv6NdSllMasked) SetValueMask(v net.HardwareAddr) {
+	self.ValueMask = v
+}
+
+func (self *OxmIpv6NdSllMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeOxmIpv6NdSllMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6NdSllMasked, error) {
+	_oxmipv6ndsllmasked := &OxmIpv6NdSllMasked{Oxm: parent}
+	if decoder.Length() < 12 {
+		return nil, fmt.Errorf("OxmIpv6NdSllMasked packet too short: %d < 12", decoder.Length())
+	}
+	_oxmipv6ndsllmasked.Value = net.HardwareAddr(decoder.Read(6))
+	_oxmipv6ndsllmasked.ValueMask = net.HardwareAddr(decoder.Read(6))
+	return _oxmipv6ndsllmasked, nil
+}
+
+func NewOxmIpv6NdSllMasked() *OxmIpv6NdSllMasked {
+	obj := &OxmIpv6NdSllMasked{
+		Oxm: NewOxm(2147500300),
+	}
+	return obj
+}
+func (self *OxmIpv6NdSllMasked) GetOXMName() string {
+	return "ipv6_nd_sll_masked"
+}
+
+func (self *OxmIpv6NdSllMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmIpv6NdSllMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *OxmIpv6NdSllMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmIpv6NdTarget struct {
+	*Oxm
+	Value net.IP
+}
+
+type IOxmIpv6NdTarget interface {
+	goloxi.IOxm
+	GetValue() net.IP
+}
+
+func (self *OxmIpv6NdTarget) GetValue() net.IP {
+	return self.Value
+}
+
+func (self *OxmIpv6NdTarget) SetValue(v net.IP) {
+	self.Value = v
+}
+
+func (self *OxmIpv6NdTarget) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value.To16())
+
+	return nil
+}
+
+func DecodeOxmIpv6NdTarget(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6NdTarget, error) {
+	_oxmipv6ndtarget := &OxmIpv6NdTarget{Oxm: parent}
+	if decoder.Length() < 16 {
+		return nil, fmt.Errorf("OxmIpv6NdTarget packet too short: %d < 16", decoder.Length())
+	}
+	_oxmipv6ndtarget.Value = net.IP(decoder.Read(16))
+	return _oxmipv6ndtarget, nil
+}
+
+func NewOxmIpv6NdTarget() *OxmIpv6NdTarget {
+	obj := &OxmIpv6NdTarget{
+		Oxm: NewOxm(2147499536),
+	}
+	return obj
+}
+func (self *OxmIpv6NdTarget) GetOXMName() string {
+	return "ipv6_nd_target"
+}
+
+func (self *OxmIpv6NdTarget) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmIpv6NdTarget) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmIpv6NdTargetMasked struct {
+	*Oxm
+	Value     net.IP
+	ValueMask net.IP
+}
+
+type IOxmIpv6NdTargetMasked interface {
+	goloxi.IOxm
+	GetValue() net.IP
+	GetValueMask() net.IP
+}
+
+func (self *OxmIpv6NdTargetMasked) GetValue() net.IP {
+	return self.Value
+}
+
+func (self *OxmIpv6NdTargetMasked) SetValue(v net.IP) {
+	self.Value = v
+}
+
+func (self *OxmIpv6NdTargetMasked) GetValueMask() net.IP {
+	return self.ValueMask
+}
+
+func (self *OxmIpv6NdTargetMasked) SetValueMask(v net.IP) {
+	self.ValueMask = v
+}
+
+func (self *OxmIpv6NdTargetMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value.To16())
+	encoder.Write(self.ValueMask.To16())
+
+	return nil
+}
+
+func DecodeOxmIpv6NdTargetMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6NdTargetMasked, error) {
+	_oxmipv6ndtargetmasked := &OxmIpv6NdTargetMasked{Oxm: parent}
+	if decoder.Length() < 32 {
+		return nil, fmt.Errorf("OxmIpv6NdTargetMasked packet too short: %d < 32", decoder.Length())
+	}
+	_oxmipv6ndtargetmasked.Value = net.IP(decoder.Read(16))
+	_oxmipv6ndtargetmasked.ValueMask = net.IP(decoder.Read(16))
+	return _oxmipv6ndtargetmasked, nil
+}
+
+func NewOxmIpv6NdTargetMasked() *OxmIpv6NdTargetMasked {
+	obj := &OxmIpv6NdTargetMasked{
+		Oxm: NewOxm(2147499808),
+	}
+	return obj
+}
+func (self *OxmIpv6NdTargetMasked) GetOXMName() string {
+	return "ipv6_nd_target_masked"
+}
+
+func (self *OxmIpv6NdTargetMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmIpv6NdTargetMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *OxmIpv6NdTargetMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmIpv6NdTll struct {
+	*Oxm
+	Value net.HardwareAddr
+}
+
+type IOxmIpv6NdTll interface {
+	goloxi.IOxm
+	GetValue() net.HardwareAddr
+}
+
+func (self *OxmIpv6NdTll) GetValue() net.HardwareAddr {
+	return self.Value
+}
+
+func (self *OxmIpv6NdTll) SetValue(v net.HardwareAddr) {
+	self.Value = v
+}
+
+func (self *OxmIpv6NdTll) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+
+	return nil
+}
+
+func DecodeOxmIpv6NdTll(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6NdTll, error) {
+	_oxmipv6ndtll := &OxmIpv6NdTll{Oxm: parent}
+	if decoder.Length() < 6 {
+		return nil, fmt.Errorf("OxmIpv6NdTll packet too short: %d < 6", decoder.Length())
+	}
+	_oxmipv6ndtll.Value = net.HardwareAddr(decoder.Read(6))
+	return _oxmipv6ndtll, nil
+}
+
+func NewOxmIpv6NdTll() *OxmIpv6NdTll {
+	obj := &OxmIpv6NdTll{
+		Oxm: NewOxm(2147500550),
+	}
+	return obj
+}
+func (self *OxmIpv6NdTll) GetOXMName() string {
+	return "ipv6_nd_tll"
+}
+
+func (self *OxmIpv6NdTll) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmIpv6NdTll) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmIpv6NdTllMasked struct {
+	*Oxm
+	Value     net.HardwareAddr
+	ValueMask net.HardwareAddr
+}
+
+type IOxmIpv6NdTllMasked interface {
+	goloxi.IOxm
+	GetValue() net.HardwareAddr
+	GetValueMask() net.HardwareAddr
+}
+
+func (self *OxmIpv6NdTllMasked) GetValue() net.HardwareAddr {
+	return self.Value
+}
+
+func (self *OxmIpv6NdTllMasked) SetValue(v net.HardwareAddr) {
+	self.Value = v
+}
+
+func (self *OxmIpv6NdTllMasked) GetValueMask() net.HardwareAddr {
+	return self.ValueMask
+}
+
+func (self *OxmIpv6NdTllMasked) SetValueMask(v net.HardwareAddr) {
+	self.ValueMask = v
+}
+
+func (self *OxmIpv6NdTllMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value)
+	encoder.Write(self.ValueMask)
+
+	return nil
+}
+
+func DecodeOxmIpv6NdTllMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6NdTllMasked, error) {
+	_oxmipv6ndtllmasked := &OxmIpv6NdTllMasked{Oxm: parent}
+	if decoder.Length() < 12 {
+		return nil, fmt.Errorf("OxmIpv6NdTllMasked packet too short: %d < 12", decoder.Length())
+	}
+	_oxmipv6ndtllmasked.Value = net.HardwareAddr(decoder.Read(6))
+	_oxmipv6ndtllmasked.ValueMask = net.HardwareAddr(decoder.Read(6))
+	return _oxmipv6ndtllmasked, nil
+}
+
+func NewOxmIpv6NdTllMasked() *OxmIpv6NdTllMasked {
+	obj := &OxmIpv6NdTllMasked{
+		Oxm: NewOxm(2147500812),
+	}
+	return obj
+}
+func (self *OxmIpv6NdTllMasked) GetOXMName() string {
+	return "ipv6_nd_tll_masked"
+}
+
+func (self *OxmIpv6NdTllMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmIpv6NdTllMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *OxmIpv6NdTllMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmIpv6Src struct {
+	*Oxm
+	Value net.IP
+}
+
+type IOxmIpv6Src interface {
+	goloxi.IOxm
+	GetValue() net.IP
+}
+
+func (self *OxmIpv6Src) GetValue() net.IP {
+	return self.Value
+}
+
+func (self *OxmIpv6Src) SetValue(v net.IP) {
+	self.Value = v
+}
+
+func (self *OxmIpv6Src) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value.To16())
+
+	return nil
+}
+
+func DecodeOxmIpv6Src(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6Src, error) {
+	_oxmipv6src := &OxmIpv6Src{Oxm: parent}
+	if decoder.Length() < 16 {
+		return nil, fmt.Errorf("OxmIpv6Src packet too short: %d < 16", decoder.Length())
+	}
+	_oxmipv6src.Value = net.IP(decoder.Read(16))
+	return _oxmipv6src, nil
+}
+
+func NewOxmIpv6Src() *OxmIpv6Src {
+	obj := &OxmIpv6Src{
+		Oxm: NewOxm(2147496976),
+	}
+	return obj
+}
+func (self *OxmIpv6Src) GetOXMName() string {
+	return "ipv6_src"
+}
+
+func (self *OxmIpv6Src) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmIpv6Src) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmIpv6SrcMasked struct {
+	*Oxm
+	Value     net.IP
+	ValueMask net.IP
+}
+
+type IOxmIpv6SrcMasked interface {
+	goloxi.IOxm
+	GetValue() net.IP
+	GetValueMask() net.IP
+}
+
+func (self *OxmIpv6SrcMasked) GetValue() net.IP {
+	return self.Value
+}
+
+func (self *OxmIpv6SrcMasked) SetValue(v net.IP) {
+	self.Value = v
+}
+
+func (self *OxmIpv6SrcMasked) GetValueMask() net.IP {
+	return self.ValueMask
+}
+
+func (self *OxmIpv6SrcMasked) SetValueMask(v net.IP) {
+	self.ValueMask = v
+}
+
+func (self *OxmIpv6SrcMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.Write(self.Value.To16())
+	encoder.Write(self.ValueMask.To16())
+
+	return nil
+}
+
+func DecodeOxmIpv6SrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6SrcMasked, error) {
+	_oxmipv6srcmasked := &OxmIpv6SrcMasked{Oxm: parent}
+	if decoder.Length() < 32 {
+		return nil, fmt.Errorf("OxmIpv6SrcMasked packet too short: %d < 32", decoder.Length())
+	}
+	_oxmipv6srcmasked.Value = net.IP(decoder.Read(16))
+	_oxmipv6srcmasked.ValueMask = net.IP(decoder.Read(16))
+	return _oxmipv6srcmasked, nil
+}
+
+func NewOxmIpv6SrcMasked() *OxmIpv6SrcMasked {
+	obj := &OxmIpv6SrcMasked{
+		Oxm: NewOxm(2147497248),
+	}
+	return obj
+}
+func (self *OxmIpv6SrcMasked) GetOXMName() string {
+	return "ipv6_src_masked"
+}
+
+func (self *OxmIpv6SrcMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmIpv6SrcMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *OxmIpv6SrcMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmMetadata struct {
+	*Oxm
+	Value uint64
+}
+
+type IOxmMetadata interface {
+	goloxi.IOxm
+	GetValue() uint64
+}
+
+func (self *OxmMetadata) GetValue() uint64 {
+	return self.Value
+}
+
+func (self *OxmMetadata) SetValue(v uint64) {
+	self.Value = v
+}
+
+func (self *OxmMetadata) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint64(uint64(self.Value))
+
+	return nil
+}
+
+func DecodeOxmMetadata(parent *Oxm, decoder *goloxi.Decoder) (*OxmMetadata, error) {
+	_oxmmetadata := &OxmMetadata{Oxm: parent}
+	if decoder.Length() < 8 {
+		return nil, fmt.Errorf("OxmMetadata packet too short: %d < 8", decoder.Length())
+	}
+	_oxmmetadata.Value = uint64(decoder.ReadUint64())
+	return _oxmmetadata, nil
+}
+
+func NewOxmMetadata() *OxmMetadata {
+	obj := &OxmMetadata{
+		Oxm: NewOxm(2147484680),
+	}
+	return obj
+}
+func (self *OxmMetadata) GetOXMName() string {
+	return "metadata"
+}
+
+func (self *OxmMetadata) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmMetadata) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmMetadataMasked struct {
+	*Oxm
+	Value     uint64
+	ValueMask uint64
+}
+
+type IOxmMetadataMasked interface {
+	goloxi.IOxm
+	GetValue() uint64
+	GetValueMask() uint64
+}
+
+func (self *OxmMetadataMasked) GetValue() uint64 {
+	return self.Value
+}
+
+func (self *OxmMetadataMasked) SetValue(v uint64) {
+	self.Value = v
+}
+
+func (self *OxmMetadataMasked) GetValueMask() uint64 {
+	return self.ValueMask
+}
+
+func (self *OxmMetadataMasked) SetValueMask(v uint64) {
+	self.ValueMask = v
+}
+
+func (self *OxmMetadataMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint64(uint64(self.Value))
+	encoder.PutUint64(uint64(self.ValueMask))
+
+	return nil
+}
+
+func DecodeOxmMetadataMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmMetadataMasked, error) {
+	_oxmmetadatamasked := &OxmMetadataMasked{Oxm: parent}
+	if decoder.Length() < 16 {
+		return nil, fmt.Errorf("OxmMetadataMasked packet too short: %d < 16", decoder.Length())
+	}
+	_oxmmetadatamasked.Value = uint64(decoder.ReadUint64())
+	_oxmmetadatamasked.ValueMask = uint64(decoder.ReadUint64())
+	return _oxmmetadatamasked, nil
+}
+
+func NewOxmMetadataMasked() *OxmMetadataMasked {
+	obj := &OxmMetadataMasked{
+		Oxm: NewOxm(2147484944),
+	}
+	return obj
+}
+func (self *OxmMetadataMasked) GetOXMName() string {
+	return "metadata_masked"
+}
+
+func (self *OxmMetadataMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmMetadataMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *OxmMetadataMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmMplsLabel struct {
+	*Oxm
+	Value uint32
+}
+
+type IOxmMplsLabel interface {
+	goloxi.IOxm
+	GetValue() uint32
+}
+
+func (self *OxmMplsLabel) GetValue() uint32 {
+	return self.Value
+}
+
+func (self *OxmMplsLabel) SetValue(v uint32) {
+	self.Value = v
+}
+
+func (self *OxmMplsLabel) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Value))
+
+	return nil
+}
+
+func DecodeOxmMplsLabel(parent *Oxm, decoder *goloxi.Decoder) (*OxmMplsLabel, error) {
+	_oxmmplslabel := &OxmMplsLabel{Oxm: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("OxmMplsLabel packet too short: %d < 4", decoder.Length())
+	}
+	_oxmmplslabel.Value = uint32(decoder.ReadUint32())
+	return _oxmmplslabel, nil
+}
+
+func NewOxmMplsLabel() *OxmMplsLabel {
+	obj := &OxmMplsLabel{
+		Oxm: NewOxm(2147501060),
+	}
+	return obj
+}
+func (self *OxmMplsLabel) GetOXMName() string {
+	return "mpls_label"
+}
+
+func (self *OxmMplsLabel) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmMplsLabel) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmMplsLabelMasked struct {
+	*Oxm
+	Value     uint32
+	ValueMask uint32
+}
+
+type IOxmMplsLabelMasked interface {
+	goloxi.IOxm
+	GetValue() uint32
+	GetValueMask() uint32
+}
+
+func (self *OxmMplsLabelMasked) GetValue() uint32 {
+	return self.Value
+}
+
+func (self *OxmMplsLabelMasked) SetValue(v uint32) {
+	self.Value = v
+}
+
+func (self *OxmMplsLabelMasked) GetValueMask() uint32 {
+	return self.ValueMask
+}
+
+func (self *OxmMplsLabelMasked) SetValueMask(v uint32) {
+	self.ValueMask = v
+}
+
+func (self *OxmMplsLabelMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint32(uint32(self.Value))
+	encoder.PutUint32(uint32(self.ValueMask))
+
+	return nil
+}
+
+func DecodeOxmMplsLabelMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmMplsLabelMasked, error) {
+	_oxmmplslabelmasked := &OxmMplsLabelMasked{Oxm: parent}
+	if decoder.Length() < 8 {
+		return nil, fmt.Errorf("OxmMplsLabelMasked packet too short: %d < 8", decoder.Length())
+	}
+	_oxmmplslabelmasked.Value = uint32(decoder.ReadUint32())
+	_oxmmplslabelmasked.ValueMask = uint32(decoder.ReadUint32())
+	return _oxmmplslabelmasked, nil
+}
+
+func NewOxmMplsLabelMasked() *OxmMplsLabelMasked {
+	obj := &OxmMplsLabelMasked{
+		Oxm: NewOxm(2147501320),
+	}
+	return obj
+}
+func (self *OxmMplsLabelMasked) GetOXMName() string {
+	return "mpls_label_masked"
+}
+
+func (self *OxmMplsLabelMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmMplsLabelMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *OxmMplsLabelMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmMplsTc struct {
+	*Oxm
+	Value uint8
+}
+
+type IOxmMplsTc interface {
+	goloxi.IOxm
+	GetValue() uint8
+}
+
+func (self *OxmMplsTc) GetValue() uint8 {
+	return self.Value
+}
+
+func (self *OxmMplsTc) SetValue(v uint8) {
+	self.Value = v
+}
+
+func (self *OxmMplsTc) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint8(uint8(self.Value))
+
+	return nil
+}
+
+func DecodeOxmMplsTc(parent *Oxm, decoder *goloxi.Decoder) (*OxmMplsTc, error) {
+	_oxmmplstc := &OxmMplsTc{Oxm: parent}
+	if decoder.Length() < 1 {
+		return nil, fmt.Errorf("OxmMplsTc packet too short: %d < 1", decoder.Length())
+	}
+	_oxmmplstc.Value = uint8(decoder.ReadByte())
+	return _oxmmplstc, nil
+}
+
+func NewOxmMplsTc() *OxmMplsTc {
+	obj := &OxmMplsTc{
+		Oxm: NewOxm(2147501569),
+	}
+	return obj
+}
+func (self *OxmMplsTc) GetOXMName() string {
+	return "mpls_tc"
+}
+
+func (self *OxmMplsTc) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmMplsTc) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmMplsTcMasked struct {
+	*Oxm
+	Value     uint8
+	ValueMask uint8
+}
+
+type IOxmMplsTcMasked interface {
+	goloxi.IOxm
+	GetValue() uint8
+	GetValueMask() uint8
+}
+
+func (self *OxmMplsTcMasked) GetValue() uint8 {
+	return self.Value
+}
+
+func (self *OxmMplsTcMasked) SetValue(v uint8) {
+	self.Value = v
+}
+
+func (self *OxmMplsTcMasked) GetValueMask() uint8 {
+	return self.ValueMask
+}
+
+func (self *OxmMplsTcMasked) SetValueMask(v uint8) {
+	self.ValueMask = v
+}
+
+func (self *OxmMplsTcMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint8(uint8(self.Value))
+	encoder.PutUint8(uint8(self.ValueMask))
+
+	return nil
+}
+
+func DecodeOxmMplsTcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmMplsTcMasked, error) {
+	_oxmmplstcmasked := &OxmMplsTcMasked{Oxm: parent}
+	if decoder.Length() < 2 {
+		return nil, fmt.Errorf("OxmMplsTcMasked packet too short: %d < 2", decoder.Length())
+	}
+	_oxmmplstcmasked.Value = uint8(decoder.ReadByte())
+	_oxmmplstcmasked.ValueMask = uint8(decoder.ReadByte())
+	return _oxmmplstcmasked, nil
+}
+
+func NewOxmMplsTcMasked() *OxmMplsTcMasked {
+	obj := &OxmMplsTcMasked{
+		Oxm: NewOxm(2147501826),
+	}
+	return obj
+}
+func (self *OxmMplsTcMasked) GetOXMName() string {
+	return "mpls_tc_masked"
+}
+
+func (self *OxmMplsTcMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmMplsTcMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *OxmMplsTcMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmSctpDst struct {
+	*Oxm
+	Value uint16
+}
+
+type IOxmSctpDst interface {
+	goloxi.IOxm
+	GetValue() uint16
+}
+
+func (self *OxmSctpDst) GetValue() uint16 {
+	return self.Value
+}
+
+func (self *OxmSctpDst) SetValue(v uint16) {
+	self.Value = v
+}
+
+func (self *OxmSctpDst) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Value))
+
+	return nil
+}
+
+func DecodeOxmSctpDst(parent *Oxm, decoder *goloxi.Decoder) (*OxmSctpDst, error) {
+	_oxmsctpdst := &OxmSctpDst{Oxm: parent}
+	if decoder.Length() < 2 {
+		return nil, fmt.Errorf("OxmSctpDst packet too short: %d < 2", decoder.Length())
+	}
+	_oxmsctpdst.Value = uint16(decoder.ReadUint16())
+	return _oxmsctpdst, nil
+}
+
+func NewOxmSctpDst() *OxmSctpDst {
+	obj := &OxmSctpDst{
+		Oxm: NewOxm(2147492866),
+	}
+	return obj
+}
+func (self *OxmSctpDst) GetOXMName() string {
+	return "sctp_dst"
+}
+
+func (self *OxmSctpDst) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmSctpDst) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmSctpDstMasked struct {
+	*Oxm
+	Value     uint16
+	ValueMask uint16
+}
+
+type IOxmSctpDstMasked interface {
+	goloxi.IOxm
+	GetValue() uint16
+	GetValueMask() uint16
+}
+
+func (self *OxmSctpDstMasked) GetValue() uint16 {
+	return self.Value
+}
+
+func (self *OxmSctpDstMasked) SetValue(v uint16) {
+	self.Value = v
+}
+
+func (self *OxmSctpDstMasked) GetValueMask() uint16 {
+	return self.ValueMask
+}
+
+func (self *OxmSctpDstMasked) SetValueMask(v uint16) {
+	self.ValueMask = v
+}
+
+func (self *OxmSctpDstMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Value))
+	encoder.PutUint16(uint16(self.ValueMask))
+
+	return nil
+}
+
+func DecodeOxmSctpDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmSctpDstMasked, error) {
+	_oxmsctpdstmasked := &OxmSctpDstMasked{Oxm: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("OxmSctpDstMasked packet too short: %d < 4", decoder.Length())
+	}
+	_oxmsctpdstmasked.Value = uint16(decoder.ReadUint16())
+	_oxmsctpdstmasked.ValueMask = uint16(decoder.ReadUint16())
+	return _oxmsctpdstmasked, nil
+}
+
+func NewOxmSctpDstMasked() *OxmSctpDstMasked {
+	obj := &OxmSctpDstMasked{
+		Oxm: NewOxm(2147493124),
+	}
+	return obj
+}
+func (self *OxmSctpDstMasked) GetOXMName() string {
+	return "sctp_dst_masked"
+}
+
+func (self *OxmSctpDstMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmSctpDstMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *OxmSctpDstMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmSctpSrc struct {
+	*Oxm
+	Value uint16
+}
+
+type IOxmSctpSrc interface {
+	goloxi.IOxm
+	GetValue() uint16
+}
+
+func (self *OxmSctpSrc) GetValue() uint16 {
+	return self.Value
+}
+
+func (self *OxmSctpSrc) SetValue(v uint16) {
+	self.Value = v
+}
+
+func (self *OxmSctpSrc) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Value))
+
+	return nil
+}
+
+func DecodeOxmSctpSrc(parent *Oxm, decoder *goloxi.Decoder) (*OxmSctpSrc, error) {
+	_oxmsctpsrc := &OxmSctpSrc{Oxm: parent}
+	if decoder.Length() < 2 {
+		return nil, fmt.Errorf("OxmSctpSrc packet too short: %d < 2", decoder.Length())
+	}
+	_oxmsctpsrc.Value = uint16(decoder.ReadUint16())
+	return _oxmsctpsrc, nil
+}
+
+func NewOxmSctpSrc() *OxmSctpSrc {
+	obj := &OxmSctpSrc{
+		Oxm: NewOxm(2147492354),
+	}
+	return obj
+}
+func (self *OxmSctpSrc) GetOXMName() string {
+	return "sctp_src"
+}
+
+func (self *OxmSctpSrc) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmSctpSrc) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmSctpSrcMasked struct {
+	*Oxm
+	Value     uint16
+	ValueMask uint16
+}
+
+type IOxmSctpSrcMasked interface {
+	goloxi.IOxm
+	GetValue() uint16
+	GetValueMask() uint16
+}
+
+func (self *OxmSctpSrcMasked) GetValue() uint16 {
+	return self.Value
+}
+
+func (self *OxmSctpSrcMasked) SetValue(v uint16) {
+	self.Value = v
+}
+
+func (self *OxmSctpSrcMasked) GetValueMask() uint16 {
+	return self.ValueMask
+}
+
+func (self *OxmSctpSrcMasked) SetValueMask(v uint16) {
+	self.ValueMask = v
+}
+
+func (self *OxmSctpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Value))
+	encoder.PutUint16(uint16(self.ValueMask))
+
+	return nil
+}
+
+func DecodeOxmSctpSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmSctpSrcMasked, error) {
+	_oxmsctpsrcmasked := &OxmSctpSrcMasked{Oxm: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("OxmSctpSrcMasked packet too short: %d < 4", decoder.Length())
+	}
+	_oxmsctpsrcmasked.Value = uint16(decoder.ReadUint16())
+	_oxmsctpsrcmasked.ValueMask = uint16(decoder.ReadUint16())
+	return _oxmsctpsrcmasked, nil
+}
+
+func NewOxmSctpSrcMasked() *OxmSctpSrcMasked {
+	obj := &OxmSctpSrcMasked{
+		Oxm: NewOxm(2147492612),
+	}
+	return obj
+}
+func (self *OxmSctpSrcMasked) GetOXMName() string {
+	return "sctp_src_masked"
+}
+
+func (self *OxmSctpSrcMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmSctpSrcMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *OxmSctpSrcMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmTcpDst struct {
+	*Oxm
+	Value uint16
+}
+
+type IOxmTcpDst interface {
+	goloxi.IOxm
+	GetValue() uint16
+}
+
+func (self *OxmTcpDst) GetValue() uint16 {
+	return self.Value
+}
+
+func (self *OxmTcpDst) SetValue(v uint16) {
+	self.Value = v
+}
+
+func (self *OxmTcpDst) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Value))
+
+	return nil
+}
+
+func DecodeOxmTcpDst(parent *Oxm, decoder *goloxi.Decoder) (*OxmTcpDst, error) {
+	_oxmtcpdst := &OxmTcpDst{Oxm: parent}
+	if decoder.Length() < 2 {
+		return nil, fmt.Errorf("OxmTcpDst packet too short: %d < 2", decoder.Length())
+	}
+	_oxmtcpdst.Value = uint16(decoder.ReadUint16())
+	return _oxmtcpdst, nil
+}
+
+func NewOxmTcpDst() *OxmTcpDst {
+	obj := &OxmTcpDst{
+		Oxm: NewOxm(2147490818),
+	}
+	return obj
+}
+func (self *OxmTcpDst) GetOXMName() string {
+	return "tcp_dst"
+}
+
+func (self *OxmTcpDst) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmTcpDst) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmTcpDstMasked struct {
+	*Oxm
+	Value     uint16
+	ValueMask uint16
+}
+
+type IOxmTcpDstMasked interface {
+	goloxi.IOxm
+	GetValue() uint16
+	GetValueMask() uint16
+}
+
+func (self *OxmTcpDstMasked) GetValue() uint16 {
+	return self.Value
+}
+
+func (self *OxmTcpDstMasked) SetValue(v uint16) {
+	self.Value = v
+}
+
+func (self *OxmTcpDstMasked) GetValueMask() uint16 {
+	return self.ValueMask
+}
+
+func (self *OxmTcpDstMasked) SetValueMask(v uint16) {
+	self.ValueMask = v
+}
+
+func (self *OxmTcpDstMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Value))
+	encoder.PutUint16(uint16(self.ValueMask))
+
+	return nil
+}
+
+func DecodeOxmTcpDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmTcpDstMasked, error) {
+	_oxmtcpdstmasked := &OxmTcpDstMasked{Oxm: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("OxmTcpDstMasked packet too short: %d < 4", decoder.Length())
+	}
+	_oxmtcpdstmasked.Value = uint16(decoder.ReadUint16())
+	_oxmtcpdstmasked.ValueMask = uint16(decoder.ReadUint16())
+	return _oxmtcpdstmasked, nil
+}
+
+func NewOxmTcpDstMasked() *OxmTcpDstMasked {
+	obj := &OxmTcpDstMasked{
+		Oxm: NewOxm(2147491076),
+	}
+	return obj
+}
+func (self *OxmTcpDstMasked) GetOXMName() string {
+	return "tcp_dst_masked"
+}
+
+func (self *OxmTcpDstMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmTcpDstMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *OxmTcpDstMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmTcpSrc struct {
+	*Oxm
+	Value uint16
+}
+
+type IOxmTcpSrc interface {
+	goloxi.IOxm
+	GetValue() uint16
+}
+
+func (self *OxmTcpSrc) GetValue() uint16 {
+	return self.Value
+}
+
+func (self *OxmTcpSrc) SetValue(v uint16) {
+	self.Value = v
+}
+
+func (self *OxmTcpSrc) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Value))
+
+	return nil
+}
+
+func DecodeOxmTcpSrc(parent *Oxm, decoder *goloxi.Decoder) (*OxmTcpSrc, error) {
+	_oxmtcpsrc := &OxmTcpSrc{Oxm: parent}
+	if decoder.Length() < 2 {
+		return nil, fmt.Errorf("OxmTcpSrc packet too short: %d < 2", decoder.Length())
+	}
+	_oxmtcpsrc.Value = uint16(decoder.ReadUint16())
+	return _oxmtcpsrc, nil
+}
+
+func NewOxmTcpSrc() *OxmTcpSrc {
+	obj := &OxmTcpSrc{
+		Oxm: NewOxm(2147490306),
+	}
+	return obj
+}
+func (self *OxmTcpSrc) GetOXMName() string {
+	return "tcp_src"
+}
+
+func (self *OxmTcpSrc) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmTcpSrc) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmTcpSrcMasked struct {
+	*Oxm
+	Value     uint16
+	ValueMask uint16
+}
+
+type IOxmTcpSrcMasked interface {
+	goloxi.IOxm
+	GetValue() uint16
+	GetValueMask() uint16
+}
+
+func (self *OxmTcpSrcMasked) GetValue() uint16 {
+	return self.Value
+}
+
+func (self *OxmTcpSrcMasked) SetValue(v uint16) {
+	self.Value = v
+}
+
+func (self *OxmTcpSrcMasked) GetValueMask() uint16 {
+	return self.ValueMask
+}
+
+func (self *OxmTcpSrcMasked) SetValueMask(v uint16) {
+	self.ValueMask = v
+}
+
+func (self *OxmTcpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Value))
+	encoder.PutUint16(uint16(self.ValueMask))
+
+	return nil
+}
+
+func DecodeOxmTcpSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmTcpSrcMasked, error) {
+	_oxmtcpsrcmasked := &OxmTcpSrcMasked{Oxm: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("OxmTcpSrcMasked packet too short: %d < 4", decoder.Length())
+	}
+	_oxmtcpsrcmasked.Value = uint16(decoder.ReadUint16())
+	_oxmtcpsrcmasked.ValueMask = uint16(decoder.ReadUint16())
+	return _oxmtcpsrcmasked, nil
+}
+
+func NewOxmTcpSrcMasked() *OxmTcpSrcMasked {
+	obj := &OxmTcpSrcMasked{
+		Oxm: NewOxm(2147490564),
+	}
+	return obj
+}
+func (self *OxmTcpSrcMasked) GetOXMName() string {
+	return "tcp_src_masked"
+}
+
+func (self *OxmTcpSrcMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmTcpSrcMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *OxmTcpSrcMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmUdpDst struct {
+	*Oxm
+	Value uint16
+}
+
+type IOxmUdpDst interface {
+	goloxi.IOxm
+	GetValue() uint16
+}
+
+func (self *OxmUdpDst) GetValue() uint16 {
+	return self.Value
+}
+
+func (self *OxmUdpDst) SetValue(v uint16) {
+	self.Value = v
+}
+
+func (self *OxmUdpDst) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Value))
+
+	return nil
+}
+
+func DecodeOxmUdpDst(parent *Oxm, decoder *goloxi.Decoder) (*OxmUdpDst, error) {
+	_oxmudpdst := &OxmUdpDst{Oxm: parent}
+	if decoder.Length() < 2 {
+		return nil, fmt.Errorf("OxmUdpDst packet too short: %d < 2", decoder.Length())
+	}
+	_oxmudpdst.Value = uint16(decoder.ReadUint16())
+	return _oxmudpdst, nil
+}
+
+func NewOxmUdpDst() *OxmUdpDst {
+	obj := &OxmUdpDst{
+		Oxm: NewOxm(2147491842),
+	}
+	return obj
+}
+func (self *OxmUdpDst) GetOXMName() string {
+	return "udp_dst"
+}
+
+func (self *OxmUdpDst) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmUdpDst) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmUdpDstMasked struct {
+	*Oxm
+	Value     uint16
+	ValueMask uint16
+}
+
+type IOxmUdpDstMasked interface {
+	goloxi.IOxm
+	GetValue() uint16
+	GetValueMask() uint16
+}
+
+func (self *OxmUdpDstMasked) GetValue() uint16 {
+	return self.Value
+}
+
+func (self *OxmUdpDstMasked) SetValue(v uint16) {
+	self.Value = v
+}
+
+func (self *OxmUdpDstMasked) GetValueMask() uint16 {
+	return self.ValueMask
+}
+
+func (self *OxmUdpDstMasked) SetValueMask(v uint16) {
+	self.ValueMask = v
+}
+
+func (self *OxmUdpDstMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Value))
+	encoder.PutUint16(uint16(self.ValueMask))
+
+	return nil
+}
+
+func DecodeOxmUdpDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmUdpDstMasked, error) {
+	_oxmudpdstmasked := &OxmUdpDstMasked{Oxm: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("OxmUdpDstMasked packet too short: %d < 4", decoder.Length())
+	}
+	_oxmudpdstmasked.Value = uint16(decoder.ReadUint16())
+	_oxmudpdstmasked.ValueMask = uint16(decoder.ReadUint16())
+	return _oxmudpdstmasked, nil
+}
+
+func NewOxmUdpDstMasked() *OxmUdpDstMasked {
+	obj := &OxmUdpDstMasked{
+		Oxm: NewOxm(2147492100),
+	}
+	return obj
+}
+func (self *OxmUdpDstMasked) GetOXMName() string {
+	return "udp_dst_masked"
+}
+
+func (self *OxmUdpDstMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmUdpDstMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *OxmUdpDstMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmUdpSrc struct {
+	*Oxm
+	Value uint16
+}
+
+type IOxmUdpSrc interface {
+	goloxi.IOxm
+	GetValue() uint16
+}
+
+func (self *OxmUdpSrc) GetValue() uint16 {
+	return self.Value
+}
+
+func (self *OxmUdpSrc) SetValue(v uint16) {
+	self.Value = v
+}
+
+func (self *OxmUdpSrc) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Value))
+
+	return nil
+}
+
+func DecodeOxmUdpSrc(parent *Oxm, decoder *goloxi.Decoder) (*OxmUdpSrc, error) {
+	_oxmudpsrc := &OxmUdpSrc{Oxm: parent}
+	if decoder.Length() < 2 {
+		return nil, fmt.Errorf("OxmUdpSrc packet too short: %d < 2", decoder.Length())
+	}
+	_oxmudpsrc.Value = uint16(decoder.ReadUint16())
+	return _oxmudpsrc, nil
+}
+
+func NewOxmUdpSrc() *OxmUdpSrc {
+	obj := &OxmUdpSrc{
+		Oxm: NewOxm(2147491330),
+	}
+	return obj
+}
+func (self *OxmUdpSrc) GetOXMName() string {
+	return "udp_src"
+}
+
+func (self *OxmUdpSrc) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmUdpSrc) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmUdpSrcMasked struct {
+	*Oxm
+	Value     uint16
+	ValueMask uint16
+}
+
+type IOxmUdpSrcMasked interface {
+	goloxi.IOxm
+	GetValue() uint16
+	GetValueMask() uint16
+}
+
+func (self *OxmUdpSrcMasked) GetValue() uint16 {
+	return self.Value
+}
+
+func (self *OxmUdpSrcMasked) SetValue(v uint16) {
+	self.Value = v
+}
+
+func (self *OxmUdpSrcMasked) GetValueMask() uint16 {
+	return self.ValueMask
+}
+
+func (self *OxmUdpSrcMasked) SetValueMask(v uint16) {
+	self.ValueMask = v
+}
+
+func (self *OxmUdpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Value))
+	encoder.PutUint16(uint16(self.ValueMask))
+
+	return nil
+}
+
+func DecodeOxmUdpSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmUdpSrcMasked, error) {
+	_oxmudpsrcmasked := &OxmUdpSrcMasked{Oxm: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("OxmUdpSrcMasked packet too short: %d < 4", decoder.Length())
+	}
+	_oxmudpsrcmasked.Value = uint16(decoder.ReadUint16())
+	_oxmudpsrcmasked.ValueMask = uint16(decoder.ReadUint16())
+	return _oxmudpsrcmasked, nil
+}
+
+func NewOxmUdpSrcMasked() *OxmUdpSrcMasked {
+	obj := &OxmUdpSrcMasked{
+		Oxm: NewOxm(2147491588),
+	}
+	return obj
+}
+func (self *OxmUdpSrcMasked) GetOXMName() string {
+	return "udp_src_masked"
+}
+
+func (self *OxmUdpSrcMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmUdpSrcMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *OxmUdpSrcMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmVlanPcp struct {
+	*Oxm
+	Value uint8
+}
+
+type IOxmVlanPcp interface {
+	goloxi.IOxm
+	GetValue() uint8
+}
+
+func (self *OxmVlanPcp) GetValue() uint8 {
+	return self.Value
+}
+
+func (self *OxmVlanPcp) SetValue(v uint8) {
+	self.Value = v
+}
+
+func (self *OxmVlanPcp) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint8(uint8(self.Value))
+
+	return nil
+}
+
+func DecodeOxmVlanPcp(parent *Oxm, decoder *goloxi.Decoder) (*OxmVlanPcp, error) {
+	_oxmvlanpcp := &OxmVlanPcp{Oxm: parent}
+	if decoder.Length() < 1 {
+		return nil, fmt.Errorf("OxmVlanPcp packet too short: %d < 1", decoder.Length())
+	}
+	_oxmvlanpcp.Value = uint8(decoder.ReadByte())
+	return _oxmvlanpcp, nil
+}
+
+func NewOxmVlanPcp() *OxmVlanPcp {
+	obj := &OxmVlanPcp{
+		Oxm: NewOxm(2147487233),
+	}
+	return obj
+}
+func (self *OxmVlanPcp) GetOXMName() string {
+	return "vlan_pcp"
+}
+
+func (self *OxmVlanPcp) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmVlanPcp) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmVlanPcpMasked struct {
+	*Oxm
+	Value     uint8
+	ValueMask uint8
+}
+
+type IOxmVlanPcpMasked interface {
+	goloxi.IOxm
+	GetValue() uint8
+	GetValueMask() uint8
+}
+
+func (self *OxmVlanPcpMasked) GetValue() uint8 {
+	return self.Value
+}
+
+func (self *OxmVlanPcpMasked) SetValue(v uint8) {
+	self.Value = v
+}
+
+func (self *OxmVlanPcpMasked) GetValueMask() uint8 {
+	return self.ValueMask
+}
+
+func (self *OxmVlanPcpMasked) SetValueMask(v uint8) {
+	self.ValueMask = v
+}
+
+func (self *OxmVlanPcpMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint8(uint8(self.Value))
+	encoder.PutUint8(uint8(self.ValueMask))
+
+	return nil
+}
+
+func DecodeOxmVlanPcpMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmVlanPcpMasked, error) {
+	_oxmvlanpcpmasked := &OxmVlanPcpMasked{Oxm: parent}
+	if decoder.Length() < 2 {
+		return nil, fmt.Errorf("OxmVlanPcpMasked packet too short: %d < 2", decoder.Length())
+	}
+	_oxmvlanpcpmasked.Value = uint8(decoder.ReadByte())
+	_oxmvlanpcpmasked.ValueMask = uint8(decoder.ReadByte())
+	return _oxmvlanpcpmasked, nil
+}
+
+func NewOxmVlanPcpMasked() *OxmVlanPcpMasked {
+	obj := &OxmVlanPcpMasked{
+		Oxm: NewOxm(2147487490),
+	}
+	return obj
+}
+func (self *OxmVlanPcpMasked) GetOXMName() string {
+	return "vlan_pcp_masked"
+}
+
+func (self *OxmVlanPcpMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmVlanPcpMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *OxmVlanPcpMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
+
+type OxmVlanVid struct {
+	*Oxm
+	Value uint16
+}
+
+type IOxmVlanVid interface {
+	goloxi.IOxm
+	GetValue() uint16
+}
+
+func (self *OxmVlanVid) GetValue() uint16 {
+	return self.Value
+}
+
+func (self *OxmVlanVid) SetValue(v uint16) {
+	self.Value = v
+}
+
+func (self *OxmVlanVid) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Value))
+
+	return nil
+}
+
+func DecodeOxmVlanVid(parent *Oxm, decoder *goloxi.Decoder) (*OxmVlanVid, error) {
+	_oxmvlanvid := &OxmVlanVid{Oxm: parent}
+	if decoder.Length() < 2 {
+		return nil, fmt.Errorf("OxmVlanVid packet too short: %d < 2", decoder.Length())
+	}
+	_oxmvlanvid.Value = uint16(decoder.ReadUint16())
+	return _oxmvlanvid, nil
+}
+
+func NewOxmVlanVid() *OxmVlanVid {
+	obj := &OxmVlanVid{
+		Oxm: NewOxm(2147486722),
+	}
+	return obj
+}
+func (self *OxmVlanVid) GetOXMName() string {
+	return "vlan_vid"
+}
+
+func (self *OxmVlanVid) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmVlanVid) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
+}
+
+type OxmVlanVidMasked struct {
+	*Oxm
+	Value     uint16
+	ValueMask uint16
+}
+
+type IOxmVlanVidMasked interface {
+	goloxi.IOxm
+	GetValue() uint16
+	GetValueMask() uint16
+}
+
+func (self *OxmVlanVidMasked) GetValue() uint16 {
+	return self.Value
+}
+
+func (self *OxmVlanVidMasked) SetValue(v uint16) {
+	self.Value = v
+}
+
+func (self *OxmVlanVidMasked) GetValueMask() uint16 {
+	return self.ValueMask
+}
+
+func (self *OxmVlanVidMasked) SetValueMask(v uint16) {
+	self.ValueMask = v
+}
+
+func (self *OxmVlanVidMasked) Serialize(encoder *goloxi.Encoder) error {
+	if err := self.Oxm.Serialize(encoder); err != nil {
+		return err
+	}
+
+	encoder.PutUint16(uint16(self.Value))
+	encoder.PutUint16(uint16(self.ValueMask))
+
+	return nil
+}
+
+func DecodeOxmVlanVidMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmVlanVidMasked, error) {
+	_oxmvlanvidmasked := &OxmVlanVidMasked{Oxm: parent}
+	if decoder.Length() < 4 {
+		return nil, fmt.Errorf("OxmVlanVidMasked packet too short: %d < 4", decoder.Length())
+	}
+	_oxmvlanvidmasked.Value = uint16(decoder.ReadUint16())
+	_oxmvlanvidmasked.ValueMask = uint16(decoder.ReadUint16())
+	return _oxmvlanvidmasked, nil
+}
+
+func NewOxmVlanVidMasked() *OxmVlanVidMasked {
+	obj := &OxmVlanVidMasked{
+		Oxm: NewOxm(2147486980),
+	}
+	return obj
+}
+func (self *OxmVlanVidMasked) GetOXMName() string {
+	return "vlan_vid_masked"
+}
+
+func (self *OxmVlanVidMasked) GetOXMValue() interface{} {
+	return self.Value
+}
+
+func (self *OxmVlanVidMasked) GetOXMValueMask() interface{} {
+	return self.ValueMask
+}
+
+func (self *OxmVlanVidMasked) MarshalJSON() ([]byte, error) {
+	value, err := jsonValue(self.GetOXMValue())
+	if err != nil {
+		return nil, err
+	}
+	valueMask, err := jsonValue(self.GetOXMValueMask())
+	if err != nil {
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
+}
diff --git a/of10/types.go b/of10/types.go
new file mode 100644
index 0000000..0c1c2fc
--- /dev/null
+++ b/of10/types.go
@@ -0,0 +1,159 @@
+/*
+ * Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
+ * Copyright (c) 2011, 2012 Open Networking Foundation
+ * Copyright 2013, Big Switch Networks, Inc. This library was generated by the LoxiGen Compiler.
+ * Copyright 2018, Red Hat, Inc.
+ */
+package of10
+
+import (
+	"encoding/json"
+	"fmt"
+	"net"
+
+	"github.com/opencord/goloxi"
+)
+
+// TODO: set real types
+type uint128 = goloxi.Uint128
+type Checksum128 [16]byte
+type Bitmap128 uint128
+type Bitmap512 struct {
+	a, b, c, d uint128
+}
+type Unimplemented struct{}
+type BSNVport uint16
+type ControllerURI uint16
+
+func (h *Header) MessageType() uint8 {
+	return h.Type
+}
+
+func (h *Header) MessageName() string {
+	return Type(h.Type).String()
+}
+
+func (self *Checksum128) Decode(decoder *goloxi.Decoder) error {
+	return nil
+}
+
+func (self *Checksum128) Serialize(encoder *goloxi.Encoder) error {
+	return nil
+}
+func (self *Bitmap128) Decode(decoder *goloxi.Decoder) error {
+	return nil
+}
+
+func (self *Bitmap128) Serialize(encoder *goloxi.Encoder) error {
+	return nil
+}
+func (self *Bitmap512) Decode(decoder *goloxi.Decoder) error {
+	return nil
+}
+
+func (self *Bitmap512) Serialize(encoder *goloxi.Encoder) error {
+	return nil
+}
+func (self *BSNVport) Decode(decoder *goloxi.Decoder) error {
+	return nil
+}
+
+func (self *BSNVport) Serialize(encoder *goloxi.Encoder) error {
+	return nil
+}
+func (self *ControllerURI) Decode(decoder *goloxi.Decoder) error {
+	return nil
+}
+
+func (self *ControllerURI) Serialize(encoder *goloxi.Encoder) error {
+	return nil
+}
+
+type FmCmd uint16
+
+func (self *FmCmd) Serialize(encoder *goloxi.Encoder) error {
+	encoder.PutUint16(uint16(*self))
+	return nil
+}
+
+func (self *FmCmd) Decode(decoder *goloxi.Decoder) error {
+	*self = FmCmd(decoder.ReadUint16())
+	return nil
+}
+
+type MatchBmap uint32
+
+func (self *MatchBmap) Serialize(encoder *goloxi.Encoder) error {
+	encoder.PutUint32(uint32(*self))
+	return nil
+}
+
+func (self *MatchBmap) Decode(decoder *goloxi.Decoder) error {
+	*self = MatchBmap(decoder.ReadUint32())
+	return nil
+}
+
+type WcBmap uint32
+
+func (self *WcBmap) Serialize(encoder *goloxi.Encoder) error {
+	encoder.PutUint32(uint32(*self))
+	return nil
+}
+
+func (self *WcBmap) Decode(decoder *goloxi.Decoder) error {
+	*self = WcBmap(decoder.ReadUint32())
+	return nil
+}
+
+type Match = MatchV1
+type PortNo uint16
+
+func (self *PortNo) Serialize(encoder *goloxi.Encoder) error {
+	encoder.PutUint16(uint16(*self))
+	return nil
+}
+
+func (self *PortNo) Decode(decoder *goloxi.Decoder) error {
+	*self = PortNo(decoder.ReadUint16())
+	return nil
+}
+
+func DecodeMessage(data []byte) (goloxi.Message, error) {
+	header, err := DecodeHeader(goloxi.NewDecoder(data))
+	if err != nil {
+		return nil, err
+	}
+
+	return header.(goloxi.Message), nil
+}
+
+func (self *Port) Serialize(encoder *goloxi.Encoder) error {
+	portNo := PortNo(*self)
+	return portNo.Serialize(encoder)
+}
+
+func (self *Port) Decode(decoder *goloxi.Decoder) error {
+	portNo := PortNo(*self)
+	if err := portNo.Decode(decoder); err != nil {
+		return err
+	}
+	*self = Port(portNo)
+	return nil
+}
+
+func jsonValue(value interface{}) ([]byte, error) {
+	switch t := value.(type) {
+	case net.HardwareAddr:
+		value = t.String()
+	case net.IP:
+		value = t.String()
+	default:
+		if s, ok := t.(fmt.Stringer); ok {
+			value = s.String()
+		} else {
+			value = t
+		}
+	}
+
+	return json.Marshal(value)
+}