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
+}