/*
 * 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 of14

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 110204:
		return DecodeOxmIdTunMetadata47(_oxmid, decoder)
	case 129026:
		return DecodeOxmIdConnTrackingTpSrc(_oxmid, decoder)
	case 2147489796:
		return DecodeOxmIdIpv4Dst(_oxmid, decoder)
	case 77830:
		return DecodeOxmIdNdSll(_oxmid, decoder)
	case 80897:
		return DecodeOxmIdMplsTtl(_oxmid, decoder)
	case 73736:
		return DecodeOxmIdTunId(_oxmid, decoder)
	case 2:
		return DecodeOxmIdInPort(_oxmid, decoder)
	case 120848:
		return DecodeOxmIdConnTrackingLabel(_oxmid, decoder)
	case 65540:
		return DecodeOxmIdReg0(_oxmid, decoder)
	case 111228:
		return DecodeOxmIdTunMetadata49(_oxmid, decoder)
	case 74758:
		return DecodeOxmIdArpTha(_oxmid, decoder)
	case 2147499266:
		return DecodeOxmIdIcmpv6CodeMasked(_oxmid, decoder)
	case 2147503112:
		return DecodeOxmIdTunnelId(_oxmid, decoder)
	case 112252:
		return DecodeOxmIdTunMetadata51(_oxmid, decoder)
	case 108024:
		return DecodeOxmIdTunMetadata42Masked(_oxmid, decoder)
	case 113276:
		return DecodeOxmIdTunMetadata53(_oxmid, decoder)
	case 109048:
		return DecodeOxmIdTunMetadata44Masked(_oxmid, decoder)
	case 94332:
		return DecodeOxmIdTunMetadata16(_oxmid, decoder)
	case 114300:
		return DecodeOxmIdTunMetadata55(_oxmid, decoder)
	case 2050:
		return DecodeOxmIdVlanTci(_oxmid, decoder)
	case 3073:
		return DecodeOxmIdNwProto(_oxmid, decoder)
	case 110072:
		return DecodeOxmIdTunMetadata46Masked(_oxmid, decoder)
	case 2147502338:
		return DecodeOxmIdMplsBosMasked(_oxmid, decoder)
	case 66564:
		return DecodeOxmIdReg2(_oxmid, decoder)
	case 115324:
		return DecodeOxmIdTunMetadata57(_oxmid, decoder)
	case 2147486722:
		return DecodeOxmIdVlanVid(_oxmid, decoder)
	case 2147487745:
		return DecodeOxmIdIpDscp(_oxmid, decoder)
	case 111096:
		return DecodeOxmIdTunMetadata48Masked(_oxmid, decoder)
	case 83204:
		return DecodeOxmIdTcpFlagsMasked(_oxmid, decoder)
	case 3588:
		return DecodeOxmIdIpSrc(_oxmid, decoder)
	case 198660:
		return DecodeOxmIdBsnL3InterfaceClassId(_oxmid, decoder)
	case 2147488769:
		return DecodeOxmIdIpProto(_oxmid, decoder)
	case 112120:
		return DecodeOxmIdTunMetadata50Masked(_oxmid, decoder)
	case 121872:
		return DecodeOxmIdTunIpv6Dst(_oxmid, decoder)
	case 199172:
		return DecodeOxmIdBsnL3SrcClassId(_oxmid, decoder)
	case 1030:
		return DecodeOxmIdEthSrc(_oxmid, decoder)
	case 68612:
		return DecodeOxmIdReg6(_oxmid, decoder)
	case 117372:
		return DecodeOxmIdTunMetadata61(_oxmid, decoder)
	case 5122:
		return DecodeOxmIdTcpDst(_oxmid, decoder)
	case 113144:
		return DecodeOxmIdTunMetadata52Masked(_oxmid, decoder)
	case 122896:
		return DecodeOxmIdXxreg1(_oxmid, decoder)
	case 209156:
		return DecodeOxmIdBsnInnerVlanVidMasked(_oxmid, decoder)
	case 124192:
		return DecodeOxmIdXxreg3Masked(_oxmid, decoder)
	case 81672:
		return DecodeOxmIdTunnelIpv4SrcMasked(_oxmid, decoder)
	case 4100:
		return DecodeOxmIdIpDst(_oxmid, decoder)
	case 118396:
		return DecodeOxmIdTunMetadata63(_oxmid, decoder)
	case 2147494146:
		return DecodeOxmIdIcmpv4CodeMasked(_oxmid, decoder)
	case 129284:
		return DecodeOxmIdConnTrackingTpSrcMasked(_oxmid, decoder)
	case 114168:
		return DecodeOxmIdTunMetadata54Masked(_oxmid, decoder)
	case 123920:
		return DecodeOxmIdXxreg3(_oxmid, decoder)
	case 200968:
		return DecodeOxmIdBsnUdf0Masked(_oxmid, decoder)
	case 78091:
		return DecodeOxmIdNdSllMasked(_oxmid, decoder)
	case 2147500300:
		return DecodeOxmIdIpv6NdSllMasked(_oxmid, decoder)
	case 74000:
		return DecodeOxmIdTunIdMasked(_oxmid, decoder)
	case 86140:
		return DecodeOxmIdTunMetadata0(_oxmid, decoder)
	case 70660:
		return DecodeOxmIdReg10(_oxmid, decoder)
	case 121120:
		return DecodeOxmIdConnTrackingLabelMasked(_oxmid, decoder)
	case 107000:
		return DecodeOxmIdTunMetadata40Masked(_oxmid, decoder)
	case 3848:
		return DecodeOxmIdIpSrcMasked(_oxmid, decoder)
	case 87164:
		return DecodeOxmIdTunMetadata2(_oxmid, decoder)
	case 202756:
		return DecodeOxmIdBsnUdf4(_oxmid, decoder)
	case 204802:
		return DecodeOxmIdBsnTcpFlags(_oxmid, decoder)
	case 205825:
		return DecodeOxmIdBsnL2CacheHit(_oxmid, decoder)
	case 116216:
		return DecodeOxmIdTunMetadata58Masked(_oxmid, decoder)
	case 199432:
		return DecodeOxmIdBsnL3SrcClassIdMasked(_oxmid, decoder)
	case 88188:
		return DecodeOxmIdTunMetadata4(_oxmid, decoder)
	case 72708:
		return DecodeOxmIdReg14(_oxmid, decoder)
	case 2147492866:
		return DecodeOxmIdSctpDst(_oxmid, decoder)
	case 2147493889:
		return DecodeOxmIdIcmpv4Code(_oxmid, decoder)
	case 117240:
		return DecodeOxmIdTunMetadata60Masked(_oxmid, decoder)
	case 200196:
		return DecodeOxmIdBsnEgrPortGroupId(_oxmid, decoder)
	case 128288:
		return DecodeOxmIdConnTrackingIpv6SrcMasked(_oxmid, decoder)
	case 89212:
		return DecodeOxmIdTunMetadata6(_oxmid, decoder)
	case 8196:
		return DecodeOxmIdArpSpa(_oxmid, decoder)
	case 76801:
		return DecodeOxmIdIcmpv6Code(_oxmid, decoder)
	case 118264:
		return DecodeOxmIdTunMetadata62Masked(_oxmid, decoder)
	case 70148:
		return DecodeOxmIdReg9(_oxmid, decoder)
	case 119560:
		return DecodeOxmIdConnTrackingStateMasked(_oxmid, decoder)
	case 90236:
		return DecodeOxmIdTunMetadata8(_oxmid, decoder)
	case 119044:
		return DecodeOxmIdTunFlagsMasked(_oxmid, decoder)
	case 82696:
		return DecodeOxmIdPktMarkMasked(_oxmid, decoder)
	case 4294923528:
		return DecodeOxmIdOvsTcpFlagsMasked(_oxmid, decoder)
	case 120584:
		return DecodeOxmIdConnTrackingMarkMasked(_oxmid, decoder)
	case 91260:
		return DecodeOxmIdTunMetadata10(_oxmid, decoder)
	case 87032:
		return DecodeOxmIdTunMetadata1Masked(_oxmid, decoder)
	case 126722:
		return DecodeOxmIdConnTrackingNwProtoMasked(_oxmid, decoder)
	case 206852:
		return DecodeOxmIdBsnIngressPortGroupId(_oxmid, decoder)
	case 208898:
		return DecodeOxmIdBsnInnerVlanVid(_oxmid, decoder)
	case 209921:
		return DecodeOxmIdBsnIpFragmentation(_oxmid, decoder)
	case 196896:
		return DecodeOxmIdBsnInPorts128Masked(_oxmid, decoder)
	case 92284:
		return DecodeOxmIdTunMetadata12(_oxmid, decoder)
	case 88056:
		return DecodeOxmIdTunMetadata3Masked(_oxmid, decoder)
	case 79873:
		return DecodeOxmIdNwEcn(_oxmid, decoder)
	case 196624:
		return DecodeOxmIdBsnInPorts128(_oxmid, decoder)
	case 200456:
		return DecodeOxmIdBsnEgrPortGroupIdMasked(_oxmid, decoder)
	case 2147489284:
		return DecodeOxmIdIpv4Src(_oxmid, decoder)
	case 93308:
		return DecodeOxmIdTunMetadata14(_oxmid, decoder)
	case 115192:
		return DecodeOxmIdTunMetadata56Masked(_oxmid, decoder)
	case 2561:
		return DecodeOxmIdNwTos(_oxmid, decoder)
	case 129538:
		return DecodeOxmIdConnTrackingTpDst(_oxmid, decoder)
	case 2147500550:
		return DecodeOxmIdIpv6NdTll(_oxmid, decoder)
	case 84484:
		return DecodeOxmIdConjId(_oxmid, decoder)
	case 74246:
		return DecodeOxmIdArpSha(_oxmid, decoder)
	case 2147488514:
		return DecodeOxmIdIpEcnMasked(_oxmid, decoder)
	case 123408:
		return DecodeOxmIdXxreg2(_oxmid, decoder)
	case 90104:
		return DecodeOxmIdTunMetadata7Masked(_oxmid, decoder)
	case 2147486468:
		return DecodeOxmIdEthTypeMasked(_oxmid, decoder)
	case 70408:
		return DecodeOxmIdReg9Masked(_oxmid, decoder)
	case 91128:
		return DecodeOxmIdTunMetadata9Masked(_oxmid, decoder)
	case 83720:
		return DecodeOxmIdDpHashMasked(_oxmid, decoder)
	case 2147497988:
		return DecodeOxmIdIpv6Flabel(_oxmid, decoder)
	case 78603:
		return DecodeOxmIdNdTllMasked(_oxmid, decoder)
	case 2147503376:
		return DecodeOxmIdTunnelIdMasked(_oxmid, decoder)
	case 96380:
		return DecodeOxmIdTunMetadata20(_oxmid, decoder)
	case 92152:
		return DecodeOxmIdTunMetadata11Masked(_oxmid, decoder)
	case 129796:
		return DecodeOxmIdConnTrackingTpDstMasked(_oxmid, decoder)
	case 2147502081:
		return DecodeOxmIdMplsBos(_oxmid, decoder)
	case 97404:
		return DecodeOxmIdTunMetadata22(_oxmid, decoder)
	case 93176:
		return DecodeOxmIdTunMetadata13Masked(_oxmid, decoder)
	case 94844:
		return DecodeOxmIdTunMetadata17(_oxmid, decoder)
	case 81924:
		return DecodeOxmIdTunnelIpv4Dst(_oxmid, decoder)
	case 127752:
		return DecodeOxmIdConnTrackingNwDstMasked(_oxmid, decoder)
	case 98428:
		return DecodeOxmIdTunMetadata24(_oxmid, decoder)
	case 94200:
		return DecodeOxmIdTunMetadata15Masked(_oxmid, decoder)
	case 2147501060:
		return DecodeOxmIdMplsLabel(_oxmid, decoder)
	case 84994:
		return DecodeOxmIdTunGbpId(_oxmid, decoder)
	case 71432:
		return DecodeOxmIdReg11Masked(_oxmid, decoder)
	case 99452:
		return DecodeOxmIdTunMetadata26(_oxmid, decoder)
	case 95224:
		return DecodeOxmIdTunMetadata17Masked(_oxmid, decoder)
	case 2147500038:
		return DecodeOxmIdIpv6NdSll(_oxmid, decoder)
	case 83972:
		return DecodeOxmIdRecircId(_oxmid, decoder)
	case 128800:
		return DecodeOxmIdConnTrackingIpv6DstMasked(_oxmid, decoder)
	case 72196:
		return DecodeOxmIdReg13(_oxmid, decoder)
	case 100476:
		return DecodeOxmIdTunMetadata28(_oxmid, decoder)
	case 96248:
		return DecodeOxmIdTunMetadata19Masked(_oxmid, decoder)
	case 112764:
		return DecodeOxmIdTunMetadata52(_oxmid, decoder)
	case 101500:
		return DecodeOxmIdTunMetadata30(_oxmid, decoder)
	case 97272:
		return DecodeOxmIdTunMetadata21Masked(_oxmid, decoder)
	case 2147498754:
		return DecodeOxmIdIcmpv6TypeMasked(_oxmid, decoder)
	case 209668:
		return DecodeOxmIdBsnVfiMasked(_oxmid, decoder)
	case 2147484424:
		return DecodeOxmIdInPhyPortMasked(_oxmid, decoder)
	case 74507:
		return DecodeOxmIdArpShaMasked(_oxmid, decoder)
	case 2147500812:
		return DecodeOxmIdIpv6NdTllMasked(_oxmid, decoder)
	case 197384:
		return DecodeOxmIdBsnLagIdMasked(_oxmid, decoder)
	case 76064:
		return DecodeOxmIdIpv6DstMasked(_oxmid, decoder)
	case 102524:
		return DecodeOxmIdTunMetadata32(_oxmid, decoder)
	case 98296:
		return DecodeOxmIdTunMetadata23Masked(_oxmid, decoder)
	case 4868:
		return DecodeOxmIdTcpSrcMasked(_oxmid, decoder)
	case 121632:
		return DecodeOxmIdTunIpv6SrcMasked(_oxmid, decoder)
	case 75792:
		return DecodeOxmIdIpv6Dst(_oxmid, decoder)
	case 202504:
		return DecodeOxmIdBsnUdf3Masked(_oxmid, decoder)
	case 120324:
		return DecodeOxmIdConnTrackingMark(_oxmid, decoder)
	case 99320:
		return DecodeOxmIdTunMetadata25Masked(_oxmid, decoder)
	case 65800:
		return DecodeOxmIdReg0Masked(_oxmid, decoder)
	case 66824:
		return DecodeOxmIdReg2Masked(_oxmid, decoder)
	case 2147506180:
		return DecodeOxmIdPacketType(_oxmid, decoder)
	case 72456:
		return DecodeOxmIdReg13Masked(_oxmid, decoder)
	case 68360:
		return DecodeOxmIdReg5Masked(_oxmid, decoder)
	case 104572:
		return DecodeOxmIdTunMetadata36(_oxmid, decoder)
	case 95356:
		return DecodeOxmIdTunMetadata18(_oxmid, decoder)
	case 100344:
		return DecodeOxmIdTunMetadata27Masked(_oxmid, decoder)
	case 4294923270:
		return DecodeOxmIdOvsTcpFlags(_oxmid, decoder)
	case 779:
		return DecodeOxmIdEthDstMasked(_oxmid, decoder)
	case 69384:
		return DecodeOxmIdReg7Masked(_oxmid, decoder)
	case 105596:
		return DecodeOxmIdTunMetadata38(_oxmid, decoder)
	case 101368:
		return DecodeOxmIdTunMetadata29Masked(_oxmid, decoder)
	case 2147493634:
		return DecodeOxmIdIcmpv4TypeMasked(_oxmid, decoder)
	case 108668:
		return DecodeOxmIdTunMetadata44(_oxmid, decoder)
	case 201480:
		return DecodeOxmIdBsnUdf1Masked(_oxmid, decoder)
	case 106620:
		return DecodeOxmIdTunMetadata40(_oxmid, decoder)
	case 102392:
		return DecodeOxmIdTunMetadata31Masked(_oxmid, decoder)
	case 2147492612:
		return DecodeOxmIdSctpSrcMasked(_oxmid, decoder)
	case 73480:
		return DecodeOxmIdReg15Masked(_oxmid, decoder)
	case 204292:
		return DecodeOxmIdBsnUdf7(_oxmid, decoder)
	case 2147489544:
		return DecodeOxmIdIpv4SrcMasked(_oxmid, decoder)
	case 107644:
		return DecodeOxmIdTunMetadata42(_oxmid, decoder)
	case 103416:
		return DecodeOxmIdTunMetadata33Masked(_oxmid, decoder)
	case 2147498248:
		return DecodeOxmIdIpv6FlabelMasked(_oxmid, decoder)
	case 203528:
		return DecodeOxmIdBsnUdf5Masked(_oxmid, decoder)
	case 89592:
		return DecodeOxmIdTunMetadata6Masked(_oxmid, decoder)
	case 104440:
		return DecodeOxmIdTunMetadata35Masked(_oxmid, decoder)
	case 2147494660:
		return DecodeOxmIdArpOpMasked(_oxmid, decoder)
	case 197636:
		return DecodeOxmIdBsnVrf(_oxmid, decoder)
	case 204552:
		return DecodeOxmIdBsnUdf7Masked(_oxmid, decoder)
	case 109692:
		return DecodeOxmIdTunMetadata46(_oxmid, decoder)
	case 105464:
		return DecodeOxmIdTunMetadata37Masked(_oxmid, decoder)
	case 89080:
		return DecodeOxmIdTunMetadata5Masked(_oxmid, decoder)
	case 67588:
		return DecodeOxmIdReg4(_oxmid, decoder)
	case 7169:
		return DecodeOxmIdIcmpCode(_oxmid, decoder)
	case 82946:
		return DecodeOxmIdTcpFlags(_oxmid, decoder)
	case 203780:
		return DecodeOxmIdBsnUdf6(_oxmid, decoder)
	case 207878:
		return DecodeOxmIdBsnInnerEthDst(_oxmid, decoder)
	case 85505:
		return DecodeOxmIdTunGbpFlags(_oxmid, decoder)
	case 2147484680:
		return DecodeOxmIdMetadata(_oxmid, decoder)
	case 1538:
		return DecodeOxmIdEthType(_oxmid, decoder)
	case 8968:
		return DecodeOxmIdArpTpaMasked(_oxmid, decoder)
	case 128016:
		return DecodeOxmIdConnTrackingIpv6Src(_oxmid, decoder)
	case 110716:
		return DecodeOxmIdTunMetadata48(_oxmid, decoder)
	case 127492:
		return DecodeOxmIdConnTrackingNwDst(_oxmid, decoder)
	case 78342:
		return DecodeOxmIdNdTll(_oxmid, decoder)
	case 111740:
		return DecodeOxmIdTunMetadata50(_oxmid, decoder)
	case 107512:
		return DecodeOxmIdTunMetadata41Masked(_oxmid, decoder)
	case 207624:
		return DecodeOxmIdBsnVxlanNetworkIdMasked(_oxmid, decoder)
	case 121360:
		return DecodeOxmIdTunIpv6Src(_oxmid, decoder)
	case 113788:
		return DecodeOxmIdTunMetadata54(_oxmid, decoder)
	case 109560:
		return DecodeOxmIdTunMetadata45Masked(_oxmid, decoder)
	case 2147501826:
		return DecodeOxmIdMplsTcMasked(_oxmid, decoder)
	case 103548:
		return DecodeOxmIdTunMetadata34(_oxmid, decoder)
	case 2147484164:
		return DecodeOxmIdInPhyPort(_oxmid, decoder)
	case 205316:
		return DecodeOxmIdBsnVlanXlatePortGroupId(_oxmid, decoder)
	case 114812:
		return DecodeOxmIdTunMetadata56(_oxmid, decoder)
	case 2147487233:
		return DecodeOxmIdVlanPcp(_oxmid, decoder)
	case 110584:
		return DecodeOxmIdTunMetadata47Masked(_oxmid, decoder)
	case 210696:
		return DecodeOxmIdBsnIfpClassIdMasked(_oxmid, decoder)
	case 115836:
		return DecodeOxmIdTunMetadata58(_oxmid, decoder)
	case 2147488257:
		return DecodeOxmIdIpEcn(_oxmid, decoder)
	case 111608:
		return DecodeOxmIdTunMetadata49Masked(_oxmid, decoder)
	case 518:
		return DecodeOxmIdEthDst(_oxmid, decoder)
	case 68100:
		return DecodeOxmIdReg5(_oxmid, decoder)
	case 116860:
		return DecodeOxmIdTunMetadata60(_oxmid, decoder)
	case 4610:
		return DecodeOxmIdTcpSrc(_oxmid, decoder)
	case 112632:
		return DecodeOxmIdTunMetadata51Masked(_oxmid, decoder)
	case 122384:
		return DecodeOxmIdXxreg0(_oxmid, decoder)
	case 2147504898:
		return DecodeOxmIdPbbUcaMasked(_oxmid, decoder)
	case 123680:
		return DecodeOxmIdXxreg2Masked(_oxmid, decoder)
	case 69124:
		return DecodeOxmIdReg7(_oxmid, decoder)
	case 117884:
		return DecodeOxmIdTunMetadata62(_oxmid, decoder)
	case 5634:
		return DecodeOxmIdUdpSrc(_oxmid, decoder)
	case 6657:
		return DecodeOxmIdIcmpType(_oxmid, decoder)
	case 113656:
		return DecodeOxmIdTunMetadata53Masked(_oxmid, decoder)
	case 2147503876:
		return DecodeOxmIdIpv6ExthdrMasked(_oxmid, decoder)
	case 198920:
		return DecodeOxmIdBsnL3InterfaceClassIdMasked(_oxmid, decoder)
	case 2147489026:
		return DecodeOxmIdIpProtoMasked(_oxmid, decoder)
	case 120068:
		return DecodeOxmIdConnTrackingZoneMasked(_oxmid, decoder)
	case 1286:
		return DecodeOxmIdEthSrcMasked(_oxmid, decoder)
	case 204040:
		return DecodeOxmIdBsnUdf6Masked(_oxmid, decoder)
	case 75019:
		return DecodeOxmIdArpThaMasked(_oxmid, decoder)
	case 208140:
		return DecodeOxmIdBsnInnerEthDstMasked(_oxmid, decoder)
	case 201220:
		return DecodeOxmIdBsnUdf1(_oxmid, decoder)
	case 205576:
		return DecodeOxmIdBsnVlanXlatePortGroupIdMasked(_oxmid, decoder)
	case 2147484944:
		return DecodeOxmIdMetadataMasked(_oxmid, decoder)
	case 6146:
		return DecodeOxmIdUdpDst(_oxmid, decoder)
	case 114680:
		return DecodeOxmIdTunMetadata55Masked(_oxmid, decoder)
	case 122144:
		return DecodeOxmIdTunIpv6DstMasked(_oxmid, decoder)
	case 86652:
		return DecodeOxmIdTunMetadata1(_oxmid, decoder)
	case 202244:
		return DecodeOxmIdBsnUdf3(_oxmid, decoder)
	case 115704:
		return DecodeOxmIdTunMetadata57Masked(_oxmid, decoder)
	case 69636:
		return DecodeOxmIdReg8(_oxmid, decoder)
	case 87676:
		return DecodeOxmIdTunMetadata3(_oxmid, decoder)
	case 82184:
		return DecodeOxmIdTunnelIpv4DstMasked(_oxmid, decoder)
	case 203268:
		return DecodeOxmIdBsnUdf5(_oxmid, decoder)
	case 2147492354:
		return DecodeOxmIdSctpSrc(_oxmid, decoder)
	case 2147493377:
		return DecodeOxmIdIcmpv4Type(_oxmid, decoder)
	case 116728:
		return DecodeOxmIdTunMetadata59Masked(_oxmid, decoder)
	case 88700:
		return DecodeOxmIdTunMetadata5(_oxmid, decoder)
	case 73220:
		return DecodeOxmIdReg15(_oxmid, decoder)
	case 76289:
		return DecodeOxmIdIcmpv6Type(_oxmid, decoder)
	case 117752:
		return DecodeOxmIdTunMetadata61Masked(_oxmid, decoder)
	case 4360:
		return DecodeOxmIdIpDstMasked(_oxmid, decoder)
	case 89724:
		return DecodeOxmIdTunMetadata7(_oxmid, decoder)
	case 8708:
		return DecodeOxmIdArpTpa(_oxmid, decoder)
	case 118776:
		return DecodeOxmIdTunMetadata63Masked(_oxmid, decoder)
	case 90748:
		return DecodeOxmIdTunMetadata9(_oxmid, decoder)
	case 86520:
		return DecodeOxmIdTunMetadata0Masked(_oxmid, decoder)
	case 2147487490:
		return DecodeOxmIdVlanPcpMasked(_oxmid, decoder)
	case 2147501320:
		return DecodeOxmIdMplsLabelMasked(_oxmid, decoder)
	case 197124:
		return DecodeOxmIdBsnLagId(_oxmid, decoder)
	case 78849:
		return DecodeOxmIdIpFrag(_oxmid, decoder)
	case 2147505928:
		return DecodeOxmIdActsetOutputMasked(_oxmid, decoder)
	case 200708:
		return DecodeOxmIdBsnUdf0(_oxmid, decoder)
	case 91772:
		return DecodeOxmIdTunMetadata11(_oxmid, decoder)
	case 87544:
		return DecodeOxmIdTunMetadata2Masked(_oxmid, decoder)
	case 207364:
		return DecodeOxmIdBsnVxlanNetworkId(_oxmid, decoder)
	case 209410:
		return DecodeOxmIdBsnVfi(_oxmid, decoder)
	case 92796:
		return DecodeOxmIdTunMetadata13(_oxmid, decoder)
	case 88568:
		return DecodeOxmIdTunMetadata4Masked(_oxmid, decoder)
	case 80385:
		return DecodeOxmIdNwTtl(_oxmid, decoder)
	case 105976:
		return DecodeOxmIdTunMetadata38Masked(_oxmid, decoder)
	case 126465:
		return DecodeOxmIdConnTrackingNwProto(_oxmid, decoder)
	case 7682:
		return DecodeOxmIdArpOp(_oxmid, decoder)
	case 71172:
		return DecodeOxmIdReg11(_oxmid, decoder)
	case 208390:
		return DecodeOxmIdBsnInnerEthSrc(_oxmid, decoder)
	case 210178:
		return DecodeOxmIdBsnIpFragmentationMasked(_oxmid, decoder)
	case 128528:
		return DecodeOxmIdConnTrackingIpv6Dst(_oxmid, decoder)
	case 85252:
		return DecodeOxmIdTunGbpIdMasked(_oxmid, decoder)
	case 90616:
		return DecodeOxmIdTunMetadata8Masked(_oxmid, decoder)
	case 79364:
		return DecodeOxmIdIpv6Label(_oxmid, decoder)
	case 207112:
		return DecodeOxmIdBsnIngressPortGroupIdMasked(_oxmid, decoder)
	case 206400:
		return DecodeOxmIdBsnInPorts512(_oxmid, decoder)
	case 95868:
		return DecodeOxmIdTunMetadata19(_oxmid, decoder)
	case 91640:
		return DecodeOxmIdTunMetadata10Masked(_oxmid, decoder)
	case 2147501569:
		return DecodeOxmIdMplsTc(_oxmid, decoder)
	case 70920:
		return DecodeOxmIdReg10Masked(_oxmid, decoder)
	case 96892:
		return DecodeOxmIdTunMetadata21(_oxmid, decoder)
	case 92664:
		return DecodeOxmIdTunMetadata12Masked(_oxmid, decoder)
	case 205060:
		return DecodeOxmIdBsnTcpFlagsMasked(_oxmid, decoder)
	case 81412:
		return DecodeOxmIdTunnelIpv4Src(_oxmid, decoder)
	case 99964:
		return DecodeOxmIdTunMetadata27(_oxmid, decoder)
	case 71684:
		return DecodeOxmIdReg12(_oxmid, decoder)
	case 127240:
		return DecodeOxmIdConnTrackingNwSrcMasked(_oxmid, decoder)
	case 97916:
		return DecodeOxmIdTunMetadata23(_oxmid, decoder)
	case 93688:
		return DecodeOxmIdTunMetadata14Masked(_oxmid, decoder)
	case 210436:
		return DecodeOxmIdBsnIfpClassId(_oxmid, decoder)
	case 82436:
		return DecodeOxmIdPktMark(_oxmid, decoder)
	case 98940:
		return DecodeOxmIdTunMetadata25(_oxmid, decoder)
	case 94712:
		return DecodeOxmIdTunMetadata16Masked(_oxmid, decoder)
	case 83460:
		return DecodeOxmIdDpHash(_oxmid, decoder)
	case 2147503618:
		return DecodeOxmIdIpv6Exthdr(_oxmid, decoder)
	case 2147504641:
		return DecodeOxmIdPbbUca(_oxmid, decoder)
	case 123168:
		return DecodeOxmIdXxreg1Masked(_oxmid, decoder)
	case 118786:
		return DecodeOxmIdTunFlags(_oxmid, decoder)
	case 95736:
		return DecodeOxmIdTunMetadata18Masked(_oxmid, decoder)
	case 2308:
		return DecodeOxmIdVlanTciMasked(_oxmid, decoder)
	case 2147488002:
		return DecodeOxmIdIpDscpMasked(_oxmid, decoder)
	case 100988:
		return DecodeOxmIdTunMetadata29(_oxmid, decoder)
	case 119810:
		return DecodeOxmIdConnTrackingZone(_oxmid, decoder)
	case 96760:
		return DecodeOxmIdTunMetadata20Masked(_oxmid, decoder)
	case 2147486980:
		return DecodeOxmIdVlanVidMasked(_oxmid, decoder)
	case 116348:
		return DecodeOxmIdTunMetadata59(_oxmid, decoder)
	case 5378:
		return DecodeOxmIdTcpDstMasked(_oxmid, decoder)
	case 71944:
		return DecodeOxmIdReg12Masked(_oxmid, decoder)
	case 2147483912:
		return DecodeOxmIdInPortMasked(_oxmid, decoder)
	case 75552:
		return DecodeOxmIdIpv6SrcMasked(_oxmid, decoder)
	case 102012:
		return DecodeOxmIdTunMetadata31(_oxmid, decoder)
	case 85762:
		return DecodeOxmIdTunGbpFlagsMasked(_oxmid, decoder)
	case 5892:
		return DecodeOxmIdUdpSrcMasked(_oxmid, decoder)
	case 97784:
		return DecodeOxmIdTunMetadata22Masked(_oxmid, decoder)
	case 66052:
		return DecodeOxmIdReg1(_oxmid, decoder)
	case 67336:
		return DecodeOxmIdReg3Masked(_oxmid, decoder)
	case 208652:
		return DecodeOxmIdBsnInnerEthSrcMasked(_oxmid, decoder)
	case 75280:
		return DecodeOxmIdIpv6Src(_oxmid, decoder)
	case 197896:
		return DecodeOxmIdBsnVrfMasked(_oxmid, decoder)
	case 122656:
		return DecodeOxmIdXxreg0Masked(_oxmid, decoder)
	case 103036:
		return DecodeOxmIdTunMetadata33(_oxmid, decoder)
	case 98808:
		return DecodeOxmIdTunMetadata24Masked(_oxmid, decoder)
	case 2147505668:
		return DecodeOxmIdActsetOutput(_oxmid, decoder)
	case 67848:
		return DecodeOxmIdReg4Masked(_oxmid, decoder)
	case 77600:
		return DecodeOxmIdNdTargetMasked(_oxmid, decoder)
	case 104060:
		return DecodeOxmIdTunMetadata35(_oxmid, decoder)
	case 99832:
		return DecodeOxmIdTunMetadata26Masked(_oxmid, decoder)
	case 6404:
		return DecodeOxmIdUdpDstMasked(_oxmid, decoder)
	case 77328:
		return DecodeOxmIdNdTarget(_oxmid, decoder)
	case 68872:
		return DecodeOxmIdReg6Masked(_oxmid, decoder)
	case 105084:
		return DecodeOxmIdTunMetadata37(_oxmid, decoder)
	case 100856:
		return DecodeOxmIdTunMetadata28Masked(_oxmid, decoder)
	case 206082:
		return DecodeOxmIdBsnL2CacheHitMasked(_oxmid, decoder)
	case 203016:
		return DecodeOxmIdBsnUdf4Masked(_oxmid, decoder)
	case 69896:
		return DecodeOxmIdReg8Masked(_oxmid, decoder)
	case 206720:
		return DecodeOxmIdBsnInPorts512Masked(_oxmid, decoder)
	case 106108:
		return DecodeOxmIdTunMetadata39(_oxmid, decoder)
	case 101880:
		return DecodeOxmIdTunMetadata30Masked(_oxmid, decoder)
	case 8452:
		return DecodeOxmIdArpSpaMasked(_oxmid, decoder)
	case 66312:
		return DecodeOxmIdReg1Masked(_oxmid, decoder)
	case 201992:
		return DecodeOxmIdBsnUdf2Masked(_oxmid, decoder)
	case 107132:
		return DecodeOxmIdTunMetadata41(_oxmid, decoder)
	case 102904:
		return DecodeOxmIdTunMetadata32Masked(_oxmid, decoder)
	case 2147493124:
		return DecodeOxmIdSctpDstMasked(_oxmid, decoder)
	case 67076:
		return DecodeOxmIdReg3(_oxmid, decoder)
	case 79624:
		return DecodeOxmIdIpv6LabelMasked(_oxmid, decoder)
	case 119300:
		return DecodeOxmIdConnTrackingState(_oxmid, decoder)
	case 2147490056:
		return DecodeOxmIdIpv4DstMasked(_oxmid, decoder)
	case 2147499808:
		return DecodeOxmIdIpv6NdTargetMasked(_oxmid, decoder)
	case 108156:
		return DecodeOxmIdTunMetadata43(_oxmid, decoder)
	case 103928:
		return DecodeOxmIdTunMetadata34Masked(_oxmid, decoder)
	case 106488:
		return DecodeOxmIdTunMetadata39Masked(_oxmid, decoder)
	case 201732:
		return DecodeOxmIdBsnUdf2(_oxmid, decoder)
	case 2147499536:
		return DecodeOxmIdIpv6NdTarget(_oxmid, decoder)
	case 72968:
		return DecodeOxmIdReg14Masked(_oxmid, decoder)
	case 109180:
		return DecodeOxmIdTunMetadata45(_oxmid, decoder)
	case 104952:
		return DecodeOxmIdTunMetadata36Masked(_oxmid, decoder)
	case 93820:
		return DecodeOxmIdTunMetadata15(_oxmid, decoder)
	case 79106:
		return DecodeOxmIdIpFragMasked(_oxmid, decoder)
	case 108536:
		return DecodeOxmIdTunMetadata43Masked(_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.PutUint32(uint32(self.Port))

	return nil
}

func DecodeActionNxBundleLoadSlave(decoder *goloxi.Decoder) (*ActionNxBundleLoadSlave, error) {
	_actionnxbundleloadslave := &ActionNxBundleLoadSlave{}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("ActionNxBundleLoadSlave packet too short: %d < 4", decoder.Length())
	}
	_actionnxbundleloadslave.Port = Port(decoder.ReadUint32())
	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 AsyncConfigProp struct {
	Type   uint16
	Length uint16
}

type IAsyncConfigProp interface {
	goloxi.Serializable
	GetType() uint16
	GetLength() uint16
}

func (self *AsyncConfigProp) GetType() uint16 {
	return self.Type
}

func (self *AsyncConfigProp) SetType(v uint16) {
	self.Type = v
}

func (self *AsyncConfigProp) GetLength() uint16 {
	return self.Length
}

func (self *AsyncConfigProp) SetLength(v uint16) {
	self.Length = v
}

func (self *AsyncConfigProp) Serialize(encoder *goloxi.Encoder) error {

	encoder.PutUint16(uint16(self.Type))
	encoder.PutUint16(uint16(self.Length))

	return nil
}

func DecodeAsyncConfigProp(decoder *goloxi.Decoder) (IAsyncConfigProp, error) {
	_asyncconfigprop := &AsyncConfigProp{}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("AsyncConfigProp packet too short: %d < 4", decoder.Length())
	}
	_asyncconfigprop.Type = uint16(decoder.ReadUint16())
	_asyncconfigprop.Length = uint16(decoder.ReadUint16())
	oldDecoder := decoder
	defer func() { decoder = oldDecoder }()
	decoder = decoder.SliceDecoder(int(_asyncconfigprop.Length), 2+2)

	switch _asyncconfigprop.Type {
	case 0:
		return DecodeAsyncConfigPropPacketInSlave(_asyncconfigprop, decoder)
	case 1:
		return DecodeAsyncConfigPropPacketInMaster(_asyncconfigprop, decoder)
	case 2:
		return DecodeAsyncConfigPropPortStatusSlave(_asyncconfigprop, decoder)
	case 3:
		return DecodeAsyncConfigPropPortStatusMaster(_asyncconfigprop, decoder)
	case 4:
		return DecodeAsyncConfigPropFlowRemovedSlave(_asyncconfigprop, decoder)
	case 5:
		return DecodeAsyncConfigPropFlowRemovedMaster(_asyncconfigprop, decoder)
	case 6:
		return DecodeAsyncConfigPropRoleStatusSlave(_asyncconfigprop, decoder)
	case 7:
		return DecodeAsyncConfigPropRoleStatusMaster(_asyncconfigprop, decoder)
	case 8:
		return DecodeAsyncConfigPropTableStatusSlave(_asyncconfigprop, decoder)
	case 9:
		return DecodeAsyncConfigPropTableStatusMaster(_asyncconfigprop, decoder)
	case 10:
		return DecodeAsyncConfigPropRequestforwardSlave(_asyncconfigprop, decoder)
	case 11:
		return DecodeAsyncConfigPropRequestforwardMaster(_asyncconfigprop, decoder)
	case 65534:
		return DecodeAsyncConfigPropExperimenterSlave(_asyncconfigprop, decoder)
	case 65535:
		return DecodeAsyncConfigPropExperimenterMaster(_asyncconfigprop, decoder)
	default:
		return nil, fmt.Errorf("Invalid type '%d' for 'AsyncConfigProp'", _asyncconfigprop.Type)
	}
}

func NewAsyncConfigProp(_type uint16) *AsyncConfigProp {
	obj := &AsyncConfigProp{}
	obj.Type = _type
	return obj
}

type AsyncConfigPropExperimenterMaster struct {
	*AsyncConfigProp
}

type IAsyncConfigPropExperimenterMaster interface {
	IAsyncConfigProp
}

func (self *AsyncConfigPropExperimenterMaster) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.AsyncConfigProp.Serialize(encoder); err != nil {
		return err
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeAsyncConfigPropExperimenterMaster(parent *AsyncConfigProp, decoder *goloxi.Decoder) (*AsyncConfigPropExperimenterMaster, error) {
	_asyncconfigpropexperimentermaster := &AsyncConfigPropExperimenterMaster{AsyncConfigProp: parent}
	return _asyncconfigpropexperimentermaster, nil
}

func NewAsyncConfigPropExperimenterMaster() *AsyncConfigPropExperimenterMaster {
	obj := &AsyncConfigPropExperimenterMaster{
		AsyncConfigProp: NewAsyncConfigProp(65535),
	}
	return obj
}

type AsyncConfigPropExperimenterSlave struct {
	*AsyncConfigProp
}

type IAsyncConfigPropExperimenterSlave interface {
	IAsyncConfigProp
}

func (self *AsyncConfigPropExperimenterSlave) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.AsyncConfigProp.Serialize(encoder); err != nil {
		return err
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeAsyncConfigPropExperimenterSlave(parent *AsyncConfigProp, decoder *goloxi.Decoder) (*AsyncConfigPropExperimenterSlave, error) {
	_asyncconfigpropexperimenterslave := &AsyncConfigPropExperimenterSlave{AsyncConfigProp: parent}
	return _asyncconfigpropexperimenterslave, nil
}

func NewAsyncConfigPropExperimenterSlave() *AsyncConfigPropExperimenterSlave {
	obj := &AsyncConfigPropExperimenterSlave{
		AsyncConfigProp: NewAsyncConfigProp(65534),
	}
	return obj
}

type AsyncConfigPropFlowRemovedMaster struct {
	*AsyncConfigProp
	Mask uint32
}

type IAsyncConfigPropFlowRemovedMaster interface {
	IAsyncConfigProp
	GetMask() uint32
}

func (self *AsyncConfigPropFlowRemovedMaster) GetMask() uint32 {
	return self.Mask
}

func (self *AsyncConfigPropFlowRemovedMaster) SetMask(v uint32) {
	self.Mask = v
}

func (self *AsyncConfigPropFlowRemovedMaster) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.AsyncConfigProp.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint32(uint32(self.Mask))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeAsyncConfigPropFlowRemovedMaster(parent *AsyncConfigProp, decoder *goloxi.Decoder) (*AsyncConfigPropFlowRemovedMaster, error) {
	_asyncconfigpropflowremovedmaster := &AsyncConfigPropFlowRemovedMaster{AsyncConfigProp: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("AsyncConfigPropFlowRemovedMaster packet too short: %d < 4", decoder.Length())
	}
	_asyncconfigpropflowremovedmaster.Mask = uint32(decoder.ReadUint32())
	return _asyncconfigpropflowremovedmaster, nil
}

func NewAsyncConfigPropFlowRemovedMaster() *AsyncConfigPropFlowRemovedMaster {
	obj := &AsyncConfigPropFlowRemovedMaster{
		AsyncConfigProp: NewAsyncConfigProp(5),
	}
	return obj
}

type AsyncConfigPropFlowRemovedSlave struct {
	*AsyncConfigProp
	Mask uint32
}

type IAsyncConfigPropFlowRemovedSlave interface {
	IAsyncConfigProp
	GetMask() uint32
}

func (self *AsyncConfigPropFlowRemovedSlave) GetMask() uint32 {
	return self.Mask
}

func (self *AsyncConfigPropFlowRemovedSlave) SetMask(v uint32) {
	self.Mask = v
}

func (self *AsyncConfigPropFlowRemovedSlave) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.AsyncConfigProp.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint32(uint32(self.Mask))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeAsyncConfigPropFlowRemovedSlave(parent *AsyncConfigProp, decoder *goloxi.Decoder) (*AsyncConfigPropFlowRemovedSlave, error) {
	_asyncconfigpropflowremovedslave := &AsyncConfigPropFlowRemovedSlave{AsyncConfigProp: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("AsyncConfigPropFlowRemovedSlave packet too short: %d < 4", decoder.Length())
	}
	_asyncconfigpropflowremovedslave.Mask = uint32(decoder.ReadUint32())
	return _asyncconfigpropflowremovedslave, nil
}

func NewAsyncConfigPropFlowRemovedSlave() *AsyncConfigPropFlowRemovedSlave {
	obj := &AsyncConfigPropFlowRemovedSlave{
		AsyncConfigProp: NewAsyncConfigProp(4),
	}
	return obj
}

type AsyncConfigPropPacketInMaster struct {
	*AsyncConfigProp
	Mask uint32
}

type IAsyncConfigPropPacketInMaster interface {
	IAsyncConfigProp
	GetMask() uint32
}

func (self *AsyncConfigPropPacketInMaster) GetMask() uint32 {
	return self.Mask
}

func (self *AsyncConfigPropPacketInMaster) SetMask(v uint32) {
	self.Mask = v
}

func (self *AsyncConfigPropPacketInMaster) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.AsyncConfigProp.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint32(uint32(self.Mask))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeAsyncConfigPropPacketInMaster(parent *AsyncConfigProp, decoder *goloxi.Decoder) (*AsyncConfigPropPacketInMaster, error) {
	_asyncconfigproppacketinmaster := &AsyncConfigPropPacketInMaster{AsyncConfigProp: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("AsyncConfigPropPacketInMaster packet too short: %d < 4", decoder.Length())
	}
	_asyncconfigproppacketinmaster.Mask = uint32(decoder.ReadUint32())
	return _asyncconfigproppacketinmaster, nil
}

func NewAsyncConfigPropPacketInMaster() *AsyncConfigPropPacketInMaster {
	obj := &AsyncConfigPropPacketInMaster{
		AsyncConfigProp: NewAsyncConfigProp(1),
	}
	return obj
}

type AsyncConfigPropPacketInSlave struct {
	*AsyncConfigProp
	Mask uint32
}

type IAsyncConfigPropPacketInSlave interface {
	IAsyncConfigProp
	GetMask() uint32
}

func (self *AsyncConfigPropPacketInSlave) GetMask() uint32 {
	return self.Mask
}

func (self *AsyncConfigPropPacketInSlave) SetMask(v uint32) {
	self.Mask = v
}

func (self *AsyncConfigPropPacketInSlave) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.AsyncConfigProp.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint32(uint32(self.Mask))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeAsyncConfigPropPacketInSlave(parent *AsyncConfigProp, decoder *goloxi.Decoder) (*AsyncConfigPropPacketInSlave, error) {
	_asyncconfigproppacketinslave := &AsyncConfigPropPacketInSlave{AsyncConfigProp: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("AsyncConfigPropPacketInSlave packet too short: %d < 4", decoder.Length())
	}
	_asyncconfigproppacketinslave.Mask = uint32(decoder.ReadUint32())
	return _asyncconfigproppacketinslave, nil
}

func NewAsyncConfigPropPacketInSlave() *AsyncConfigPropPacketInSlave {
	obj := &AsyncConfigPropPacketInSlave{
		AsyncConfigProp: NewAsyncConfigProp(0),
	}
	return obj
}

type AsyncConfigPropPortStatusMaster struct {
	*AsyncConfigProp
	Mask uint32
}

type IAsyncConfigPropPortStatusMaster interface {
	IAsyncConfigProp
	GetMask() uint32
}

func (self *AsyncConfigPropPortStatusMaster) GetMask() uint32 {
	return self.Mask
}

func (self *AsyncConfigPropPortStatusMaster) SetMask(v uint32) {
	self.Mask = v
}

func (self *AsyncConfigPropPortStatusMaster) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.AsyncConfigProp.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint32(uint32(self.Mask))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeAsyncConfigPropPortStatusMaster(parent *AsyncConfigProp, decoder *goloxi.Decoder) (*AsyncConfigPropPortStatusMaster, error) {
	_asyncconfigpropportstatusmaster := &AsyncConfigPropPortStatusMaster{AsyncConfigProp: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("AsyncConfigPropPortStatusMaster packet too short: %d < 4", decoder.Length())
	}
	_asyncconfigpropportstatusmaster.Mask = uint32(decoder.ReadUint32())
	return _asyncconfigpropportstatusmaster, nil
}

func NewAsyncConfigPropPortStatusMaster() *AsyncConfigPropPortStatusMaster {
	obj := &AsyncConfigPropPortStatusMaster{
		AsyncConfigProp: NewAsyncConfigProp(3),
	}
	return obj
}

type AsyncConfigPropPortStatusSlave struct {
	*AsyncConfigProp
	Mask uint32
}

type IAsyncConfigPropPortStatusSlave interface {
	IAsyncConfigProp
	GetMask() uint32
}

func (self *AsyncConfigPropPortStatusSlave) GetMask() uint32 {
	return self.Mask
}

func (self *AsyncConfigPropPortStatusSlave) SetMask(v uint32) {
	self.Mask = v
}

func (self *AsyncConfigPropPortStatusSlave) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.AsyncConfigProp.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint32(uint32(self.Mask))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeAsyncConfigPropPortStatusSlave(parent *AsyncConfigProp, decoder *goloxi.Decoder) (*AsyncConfigPropPortStatusSlave, error) {
	_asyncconfigpropportstatusslave := &AsyncConfigPropPortStatusSlave{AsyncConfigProp: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("AsyncConfigPropPortStatusSlave packet too short: %d < 4", decoder.Length())
	}
	_asyncconfigpropportstatusslave.Mask = uint32(decoder.ReadUint32())
	return _asyncconfigpropportstatusslave, nil
}

func NewAsyncConfigPropPortStatusSlave() *AsyncConfigPropPortStatusSlave {
	obj := &AsyncConfigPropPortStatusSlave{
		AsyncConfigProp: NewAsyncConfigProp(2),
	}
	return obj
}

type AsyncConfigPropRequestforwardMaster struct {
	*AsyncConfigProp
	Mask uint32
}

type IAsyncConfigPropRequestforwardMaster interface {
	IAsyncConfigProp
	GetMask() uint32
}

func (self *AsyncConfigPropRequestforwardMaster) GetMask() uint32 {
	return self.Mask
}

func (self *AsyncConfigPropRequestforwardMaster) SetMask(v uint32) {
	self.Mask = v
}

func (self *AsyncConfigPropRequestforwardMaster) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.AsyncConfigProp.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint32(uint32(self.Mask))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeAsyncConfigPropRequestforwardMaster(parent *AsyncConfigProp, decoder *goloxi.Decoder) (*AsyncConfigPropRequestforwardMaster, error) {
	_asyncconfigproprequestforwardmaster := &AsyncConfigPropRequestforwardMaster{AsyncConfigProp: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("AsyncConfigPropRequestforwardMaster packet too short: %d < 4", decoder.Length())
	}
	_asyncconfigproprequestforwardmaster.Mask = uint32(decoder.ReadUint32())
	return _asyncconfigproprequestforwardmaster, nil
}

func NewAsyncConfigPropRequestforwardMaster() *AsyncConfigPropRequestforwardMaster {
	obj := &AsyncConfigPropRequestforwardMaster{
		AsyncConfigProp: NewAsyncConfigProp(11),
	}
	return obj
}

type AsyncConfigPropRequestforwardSlave struct {
	*AsyncConfigProp
	Mask uint32
}

type IAsyncConfigPropRequestforwardSlave interface {
	IAsyncConfigProp
	GetMask() uint32
}

func (self *AsyncConfigPropRequestforwardSlave) GetMask() uint32 {
	return self.Mask
}

func (self *AsyncConfigPropRequestforwardSlave) SetMask(v uint32) {
	self.Mask = v
}

func (self *AsyncConfigPropRequestforwardSlave) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.AsyncConfigProp.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint32(uint32(self.Mask))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeAsyncConfigPropRequestforwardSlave(parent *AsyncConfigProp, decoder *goloxi.Decoder) (*AsyncConfigPropRequestforwardSlave, error) {
	_asyncconfigproprequestforwardslave := &AsyncConfigPropRequestforwardSlave{AsyncConfigProp: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("AsyncConfigPropRequestforwardSlave packet too short: %d < 4", decoder.Length())
	}
	_asyncconfigproprequestforwardslave.Mask = uint32(decoder.ReadUint32())
	return _asyncconfigproprequestforwardslave, nil
}

func NewAsyncConfigPropRequestforwardSlave() *AsyncConfigPropRequestforwardSlave {
	obj := &AsyncConfigPropRequestforwardSlave{
		AsyncConfigProp: NewAsyncConfigProp(10),
	}
	return obj
}

type AsyncConfigPropRoleStatusMaster struct {
	*AsyncConfigProp
	Mask uint32
}

type IAsyncConfigPropRoleStatusMaster interface {
	IAsyncConfigProp
	GetMask() uint32
}

func (self *AsyncConfigPropRoleStatusMaster) GetMask() uint32 {
	return self.Mask
}

func (self *AsyncConfigPropRoleStatusMaster) SetMask(v uint32) {
	self.Mask = v
}

func (self *AsyncConfigPropRoleStatusMaster) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.AsyncConfigProp.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint32(uint32(self.Mask))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeAsyncConfigPropRoleStatusMaster(parent *AsyncConfigProp, decoder *goloxi.Decoder) (*AsyncConfigPropRoleStatusMaster, error) {
	_asyncconfigproprolestatusmaster := &AsyncConfigPropRoleStatusMaster{AsyncConfigProp: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("AsyncConfigPropRoleStatusMaster packet too short: %d < 4", decoder.Length())
	}
	_asyncconfigproprolestatusmaster.Mask = uint32(decoder.ReadUint32())
	return _asyncconfigproprolestatusmaster, nil
}

func NewAsyncConfigPropRoleStatusMaster() *AsyncConfigPropRoleStatusMaster {
	obj := &AsyncConfigPropRoleStatusMaster{
		AsyncConfigProp: NewAsyncConfigProp(7),
	}
	return obj
}

type AsyncConfigPropRoleStatusSlave struct {
	*AsyncConfigProp
	Mask uint32
}

type IAsyncConfigPropRoleStatusSlave interface {
	IAsyncConfigProp
	GetMask() uint32
}

func (self *AsyncConfigPropRoleStatusSlave) GetMask() uint32 {
	return self.Mask
}

func (self *AsyncConfigPropRoleStatusSlave) SetMask(v uint32) {
	self.Mask = v
}

func (self *AsyncConfigPropRoleStatusSlave) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.AsyncConfigProp.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint32(uint32(self.Mask))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeAsyncConfigPropRoleStatusSlave(parent *AsyncConfigProp, decoder *goloxi.Decoder) (*AsyncConfigPropRoleStatusSlave, error) {
	_asyncconfigproprolestatusslave := &AsyncConfigPropRoleStatusSlave{AsyncConfigProp: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("AsyncConfigPropRoleStatusSlave packet too short: %d < 4", decoder.Length())
	}
	_asyncconfigproprolestatusslave.Mask = uint32(decoder.ReadUint32())
	return _asyncconfigproprolestatusslave, nil
}

func NewAsyncConfigPropRoleStatusSlave() *AsyncConfigPropRoleStatusSlave {
	obj := &AsyncConfigPropRoleStatusSlave{
		AsyncConfigProp: NewAsyncConfigProp(6),
	}
	return obj
}

type AsyncConfigPropTableStatusMaster struct {
	*AsyncConfigProp
	Mask uint32
}

type IAsyncConfigPropTableStatusMaster interface {
	IAsyncConfigProp
	GetMask() uint32
}

func (self *AsyncConfigPropTableStatusMaster) GetMask() uint32 {
	return self.Mask
}

func (self *AsyncConfigPropTableStatusMaster) SetMask(v uint32) {
	self.Mask = v
}

func (self *AsyncConfigPropTableStatusMaster) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.AsyncConfigProp.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint32(uint32(self.Mask))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeAsyncConfigPropTableStatusMaster(parent *AsyncConfigProp, decoder *goloxi.Decoder) (*AsyncConfigPropTableStatusMaster, error) {
	_asyncconfigproptablestatusmaster := &AsyncConfigPropTableStatusMaster{AsyncConfigProp: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("AsyncConfigPropTableStatusMaster packet too short: %d < 4", decoder.Length())
	}
	_asyncconfigproptablestatusmaster.Mask = uint32(decoder.ReadUint32())
	return _asyncconfigproptablestatusmaster, nil
}

func NewAsyncConfigPropTableStatusMaster() *AsyncConfigPropTableStatusMaster {
	obj := &AsyncConfigPropTableStatusMaster{
		AsyncConfigProp: NewAsyncConfigProp(9),
	}
	return obj
}

type AsyncConfigPropTableStatusSlave struct {
	*AsyncConfigProp
	Mask uint32
}

type IAsyncConfigPropTableStatusSlave interface {
	IAsyncConfigProp
	GetMask() uint32
}

func (self *AsyncConfigPropTableStatusSlave) GetMask() uint32 {
	return self.Mask
}

func (self *AsyncConfigPropTableStatusSlave) SetMask(v uint32) {
	self.Mask = v
}

func (self *AsyncConfigPropTableStatusSlave) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.AsyncConfigProp.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint32(uint32(self.Mask))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeAsyncConfigPropTableStatusSlave(parent *AsyncConfigProp, decoder *goloxi.Decoder) (*AsyncConfigPropTableStatusSlave, error) {
	_asyncconfigproptablestatusslave := &AsyncConfigPropTableStatusSlave{AsyncConfigProp: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("AsyncConfigPropTableStatusSlave packet too short: %d < 4", decoder.Length())
	}
	_asyncconfigproptablestatusslave.Mask = uint32(decoder.ReadUint32())
	return _asyncconfigproptablestatusslave, nil
}

func NewAsyncConfigPropTableStatusSlave() *AsyncConfigPropTableStatusSlave {
	obj := &AsyncConfigPropTableStatusSlave{
		AsyncConfigProp: NewAsyncConfigProp(8),
	}
	return obj
}

type BsnControllerConnection struct {
	State       BsnControllerConnectionState
	AuxiliaryId uint8
	Role        ControllerRole
	Uri         string
}

type IBsnControllerConnection interface {
	goloxi.Serializable
	GetState() BsnControllerConnectionState
	GetAuxiliaryId() uint8
	GetRole() ControllerRole
	GetUri() string
}

func (self *BsnControllerConnection) GetState() BsnControllerConnectionState {
	return self.State
}

func (self *BsnControllerConnection) SetState(v BsnControllerConnectionState) {
	self.State = v
}

func (self *BsnControllerConnection) GetAuxiliaryId() uint8 {
	return self.AuxiliaryId
}

func (self *BsnControllerConnection) SetAuxiliaryId(v uint8) {
	self.AuxiliaryId = v
}

func (self *BsnControllerConnection) GetRole() ControllerRole {
	return self.Role
}

func (self *BsnControllerConnection) SetRole(v ControllerRole) {
	self.Role = v
}

func (self *BsnControllerConnection) GetUri() string {
	return self.Uri
}

func (self *BsnControllerConnection) SetUri(v string) {
	self.Uri = v
}

func (self *BsnControllerConnection) Serialize(encoder *goloxi.Encoder) error {

	encoder.PutUint8(uint8(self.State))
	encoder.PutUint8(uint8(self.AuxiliaryId))
	encoder.Write(bytes.Repeat([]byte{0}, 2))
	encoder.PutUint32(uint32(self.Role))
	encoder.Write([]byte(self.Uri))

	return nil
}

func DecodeBsnControllerConnection(decoder *goloxi.Decoder) (*BsnControllerConnection, error) {
	_bsncontrollerconnection := &BsnControllerConnection{}
	if decoder.Length() < 264 {
		return nil, fmt.Errorf("BsnControllerConnection packet too short: %d < 264", decoder.Length())
	}
	_bsncontrollerconnection.State = BsnControllerConnectionState(decoder.ReadByte())
	_bsncontrollerconnection.AuxiliaryId = uint8(decoder.ReadByte())
	decoder.Skip(2)
	_bsncontrollerconnection.Role = ControllerRole(decoder.ReadUint32())
	_bsncontrollerconnection.Uri = string(bytes.Trim(decoder.Read(256), "\x00"))
	return _bsncontrollerconnection, nil
}

func NewBsnControllerConnection() *BsnControllerConnection {
	obj := &BsnControllerConnection{}
	return obj
}

type BsnDebugCounterDescStatsEntry struct {
	CounterId   uint64
	Name        string
	Description string
}

type IBsnDebugCounterDescStatsEntry interface {
	goloxi.Serializable
	GetCounterId() uint64
	GetName() string
	GetDescription() string
}

func (self *BsnDebugCounterDescStatsEntry) GetCounterId() uint64 {
	return self.CounterId
}

func (self *BsnDebugCounterDescStatsEntry) SetCounterId(v uint64) {
	self.CounterId = v
}

func (self *BsnDebugCounterDescStatsEntry) GetName() string {
	return self.Name
}

func (self *BsnDebugCounterDescStatsEntry) SetName(v string) {
	self.Name = v
}

func (self *BsnDebugCounterDescStatsEntry) GetDescription() string {
	return self.Description
}

func (self *BsnDebugCounterDescStatsEntry) SetDescription(v string) {
	self.Description = v
}

func (self *BsnDebugCounterDescStatsEntry) Serialize(encoder *goloxi.Encoder) error {

	encoder.PutUint64(uint64(self.CounterId))
	encoder.Write([]byte(self.Name))
	encoder.Write([]byte(self.Description))

	return nil
}

func DecodeBsnDebugCounterDescStatsEntry(decoder *goloxi.Decoder) (*BsnDebugCounterDescStatsEntry, error) {
	_bsndebugcounterdescstatsentry := &BsnDebugCounterDescStatsEntry{}
	if decoder.Length() < 328 {
		return nil, fmt.Errorf("BsnDebugCounterDescStatsEntry packet too short: %d < 328", decoder.Length())
	}
	_bsndebugcounterdescstatsentry.CounterId = uint64(decoder.ReadUint64())
	_bsndebugcounterdescstatsentry.Name = string(bytes.Trim(decoder.Read(64), "\x00"))
	_bsndebugcounterdescstatsentry.Description = string(bytes.Trim(decoder.Read(256), "\x00"))
	return _bsndebugcounterdescstatsentry, nil
}

func NewBsnDebugCounterDescStatsEntry() *BsnDebugCounterDescStatsEntry {
	obj := &BsnDebugCounterDescStatsEntry{}
	return obj
}

type BsnDebugCounterStatsEntry struct {
	CounterId uint64
	Value     uint64
}

type IBsnDebugCounterStatsEntry interface {
	goloxi.Serializable
	GetCounterId() uint64
	GetValue() uint64
}

func (self *BsnDebugCounterStatsEntry) GetCounterId() uint64 {
	return self.CounterId
}

func (self *BsnDebugCounterStatsEntry) SetCounterId(v uint64) {
	self.CounterId = v
}

func (self *BsnDebugCounterStatsEntry) GetValue() uint64 {
	return self.Value
}

func (self *BsnDebugCounterStatsEntry) SetValue(v uint64) {
	self.Value = v
}

func (self *BsnDebugCounterStatsEntry) Serialize(encoder *goloxi.Encoder) error {

	encoder.PutUint64(uint64(self.CounterId))
	encoder.PutUint64(uint64(self.Value))

	return nil
}

func DecodeBsnDebugCounterStatsEntry(decoder *goloxi.Decoder) (*BsnDebugCounterStatsEntry, error) {
	_bsndebugcounterstatsentry := &BsnDebugCounterStatsEntry{}
	if decoder.Length() < 16 {
		return nil, fmt.Errorf("BsnDebugCounterStatsEntry packet too short: %d < 16", decoder.Length())
	}
	_bsndebugcounterstatsentry.CounterId = uint64(decoder.ReadUint64())
	_bsndebugcounterstatsentry.Value = uint64(decoder.ReadUint64())
	return _bsndebugcounterstatsentry, nil
}

func NewBsnDebugCounterStatsEntry() *BsnDebugCounterStatsEntry {
	obj := &BsnDebugCounterStatsEntry{}
	return obj
}

type BsnFlowChecksumBucketStatsEntry struct {
	Checksum uint64
}

type IBsnFlowChecksumBucketStatsEntry interface {
	goloxi.Serializable
	GetChecksum() uint64
}

func (self *BsnFlowChecksumBucketStatsEntry) GetChecksum() uint64 {
	return self.Checksum
}

func (self *BsnFlowChecksumBucketStatsEntry) SetChecksum(v uint64) {
	self.Checksum = v
}

func (self *BsnFlowChecksumBucketStatsEntry) Serialize(encoder *goloxi.Encoder) error {

	encoder.PutUint64(uint64(self.Checksum))

	return nil
}

func DecodeBsnFlowChecksumBucketStatsEntry(decoder *goloxi.Decoder) (*BsnFlowChecksumBucketStatsEntry, error) {
	_bsnflowchecksumbucketstatsentry := &BsnFlowChecksumBucketStatsEntry{}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("BsnFlowChecksumBucketStatsEntry packet too short: %d < 8", decoder.Length())
	}
	_bsnflowchecksumbucketstatsentry.Checksum = uint64(decoder.ReadUint64())
	return _bsnflowchecksumbucketstatsentry, nil
}

func NewBsnFlowChecksumBucketStatsEntry() *BsnFlowChecksumBucketStatsEntry {
	obj := &BsnFlowChecksumBucketStatsEntry{}
	return obj
}

type BsnGenericStatsEntry struct {
	Length uint16
	Tlvs   []IBsnTlv
}

type IBsnGenericStatsEntry interface {
	goloxi.Serializable
	GetLength() uint16
	GetTlvs() []IBsnTlv
}

func (self *BsnGenericStatsEntry) GetLength() uint16 {
	return self.Length
}

func (self *BsnGenericStatsEntry) SetLength(v uint16) {
	self.Length = v
}

func (self *BsnGenericStatsEntry) GetTlvs() []IBsnTlv {
	return self.Tlvs
}

func (self *BsnGenericStatsEntry) SetTlvs(v []IBsnTlv) {
	self.Tlvs = v
}

func (self *BsnGenericStatsEntry) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())

	encoder.PutUint16(uint16(self.Length))
	for _, obj := range self.Tlvs {
		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 DecodeBsnGenericStatsEntry(decoder *goloxi.Decoder) (*BsnGenericStatsEntry, error) {
	_bsngenericstatsentry := &BsnGenericStatsEntry{}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("BsnGenericStatsEntry packet too short: %d < 2", decoder.Length())
	}
	_bsngenericstatsentry.Length = uint16(decoder.ReadUint16())
	oldDecoder := decoder
	defer func() { decoder = oldDecoder }()
	decoder = decoder.SliceDecoder(int(_bsngenericstatsentry.Length), 2+0)

	for decoder.Length() >= 4 {
		item, err := DecodeBsnTlv(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_bsngenericstatsentry.Tlvs = append(_bsngenericstatsentry.Tlvs, item)
		}
	}
	return _bsngenericstatsentry, nil
}

func NewBsnGenericStatsEntry() *BsnGenericStatsEntry {
	obj := &BsnGenericStatsEntry{}
	return obj
}

type BsnGentableBucketStatsEntry struct {
	Checksum Checksum128
}

type IBsnGentableBucketStatsEntry interface {
	goloxi.Serializable
	GetChecksum() Checksum128
}

func (self *BsnGentableBucketStatsEntry) GetChecksum() Checksum128 {
	return self.Checksum
}

func (self *BsnGentableBucketStatsEntry) SetChecksum(v Checksum128) {
	self.Checksum = v
}

func (self *BsnGentableBucketStatsEntry) Serialize(encoder *goloxi.Encoder) error {

	self.Checksum.Serialize(encoder)

	return nil
}

func DecodeBsnGentableBucketStatsEntry(decoder *goloxi.Decoder) (*BsnGentableBucketStatsEntry, error) {
	_bsngentablebucketstatsentry := &BsnGentableBucketStatsEntry{}
	if decoder.Length() < 16 {
		return nil, fmt.Errorf("BsnGentableBucketStatsEntry packet too short: %d < 16", decoder.Length())
	}
	_bsngentablebucketstatsentry.Checksum.Decode(decoder)
	return _bsngentablebucketstatsentry, nil
}

func NewBsnGentableBucketStatsEntry() *BsnGentableBucketStatsEntry {
	obj := &BsnGentableBucketStatsEntry{}
	return obj
}

type BsnGentableDescStatsEntry struct {
	Length      uint16
	TableId     uint16
	Name        string
	BucketsSize uint32
	MaxEntries  uint32
}

type IBsnGentableDescStatsEntry interface {
	goloxi.Serializable
	GetLength() uint16
	GetTableId() uint16
	GetName() string
	GetBucketsSize() uint32
	GetMaxEntries() uint32
}

func (self *BsnGentableDescStatsEntry) GetLength() uint16 {
	return self.Length
}

func (self *BsnGentableDescStatsEntry) SetLength(v uint16) {
	self.Length = v
}

func (self *BsnGentableDescStatsEntry) GetTableId() uint16 {
	return self.TableId
}

func (self *BsnGentableDescStatsEntry) SetTableId(v uint16) {
	self.TableId = v
}

func (self *BsnGentableDescStatsEntry) GetName() string {
	return self.Name
}

func (self *BsnGentableDescStatsEntry) SetName(v string) {
	self.Name = v
}

func (self *BsnGentableDescStatsEntry) GetBucketsSize() uint32 {
	return self.BucketsSize
}

func (self *BsnGentableDescStatsEntry) SetBucketsSize(v uint32) {
	self.BucketsSize = v
}

func (self *BsnGentableDescStatsEntry) GetMaxEntries() uint32 {
	return self.MaxEntries
}

func (self *BsnGentableDescStatsEntry) SetMaxEntries(v uint32) {
	self.MaxEntries = v
}

func (self *BsnGentableDescStatsEntry) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())

	encoder.PutUint16(uint16(self.Length))
	encoder.PutUint16(uint16(self.TableId))
	encoder.Write([]byte(self.Name))
	encoder.PutUint32(uint32(self.BucketsSize))
	encoder.PutUint32(uint32(self.MaxEntries))
	encoder.Write(bytes.Repeat([]byte{0}, 4))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))

	return nil
}

func DecodeBsnGentableDescStatsEntry(decoder *goloxi.Decoder) (*BsnGentableDescStatsEntry, error) {
	_bsngentabledescstatsentry := &BsnGentableDescStatsEntry{}
	if decoder.Length() < 48 {
		return nil, fmt.Errorf("BsnGentableDescStatsEntry packet too short: %d < 48", decoder.Length())
	}
	_bsngentabledescstatsentry.Length = uint16(decoder.ReadUint16())
	oldDecoder := decoder
	defer func() { decoder = oldDecoder }()
	decoder = decoder.SliceDecoder(int(_bsngentabledescstatsentry.Length), 2+0)
	_bsngentabledescstatsentry.TableId = uint16(decoder.ReadUint16())
	_bsngentabledescstatsentry.Name = string(bytes.Trim(decoder.Read(32), "\x00"))
	_bsngentabledescstatsentry.BucketsSize = uint32(decoder.ReadUint32())
	_bsngentabledescstatsentry.MaxEntries = uint32(decoder.ReadUint32())
	decoder.Skip(4)
	return _bsngentabledescstatsentry, nil
}

func NewBsnGentableDescStatsEntry() *BsnGentableDescStatsEntry {
	obj := &BsnGentableDescStatsEntry{}
	return obj
}

type BsnGentableEntryDescStatsEntry struct {
	Length    uint16
	KeyLength uint16
	Checksum  Checksum128
	Key       []IBsnTlv
	Value     []IBsnTlv
}

type IBsnGentableEntryDescStatsEntry interface {
	goloxi.Serializable
	GetLength() uint16
	GetKeyLength() uint16
	GetChecksum() Checksum128
	GetKey() []IBsnTlv
	GetValue() []IBsnTlv
}

func (self *BsnGentableEntryDescStatsEntry) GetLength() uint16 {
	return self.Length
}

func (self *BsnGentableEntryDescStatsEntry) SetLength(v uint16) {
	self.Length = v
}

func (self *BsnGentableEntryDescStatsEntry) GetKeyLength() uint16 {
	return self.KeyLength
}

func (self *BsnGentableEntryDescStatsEntry) SetKeyLength(v uint16) {
	self.KeyLength = v
}

func (self *BsnGentableEntryDescStatsEntry) GetChecksum() Checksum128 {
	return self.Checksum
}

func (self *BsnGentableEntryDescStatsEntry) SetChecksum(v Checksum128) {
	self.Checksum = v
}

func (self *BsnGentableEntryDescStatsEntry) GetKey() []IBsnTlv {
	return self.Key
}

func (self *BsnGentableEntryDescStatsEntry) SetKey(v []IBsnTlv) {
	self.Key = v
}

func (self *BsnGentableEntryDescStatsEntry) GetValue() []IBsnTlv {
	return self.Value
}

func (self *BsnGentableEntryDescStatsEntry) SetValue(v []IBsnTlv) {
	self.Value = v
}

func (self *BsnGentableEntryDescStatsEntry) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())

	encoder.PutUint16(uint16(self.Length))
	encoder.PutUint16(uint16(self.KeyLength))
	self.Checksum.Serialize(encoder)
	for _, obj := range self.Key {
		if err := obj.Serialize(encoder); err != nil {
			return err
		}
	}
	for _, obj := range self.Value {
		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 DecodeBsnGentableEntryDescStatsEntry(decoder *goloxi.Decoder) (*BsnGentableEntryDescStatsEntry, error) {
	_bsngentableentrydescstatsentry := &BsnGentableEntryDescStatsEntry{}
	if decoder.Length() < 20 {
		return nil, fmt.Errorf("BsnGentableEntryDescStatsEntry packet too short: %d < 20", decoder.Length())
	}
	_bsngentableentrydescstatsentry.Length = uint16(decoder.ReadUint16())
	oldDecoder := decoder
	defer func() { decoder = oldDecoder }()
	decoder = decoder.SliceDecoder(int(_bsngentableentrydescstatsentry.Length), 2+0)
	_bsngentableentrydescstatsentry.KeyLength = uint16(decoder.ReadUint16())
	_bsngentableentrydescstatsentry.Checksum.Decode(decoder)

	end := decoder.Offset() + int(_bsngentableentrydescstatsentry.KeyLength)
	for decoder.Offset() < end {
		item, err := DecodeBsnTlv(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_bsngentableentrydescstatsentry.Key = append(_bsngentableentrydescstatsentry.Key, item)
		}
	}

	for decoder.Length() >= 4 {
		item, err := DecodeBsnTlv(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_bsngentableentrydescstatsentry.Value = append(_bsngentableentrydescstatsentry.Value, item)
		}
	}
	return _bsngentableentrydescstatsentry, nil
}

func NewBsnGentableEntryDescStatsEntry() *BsnGentableEntryDescStatsEntry {
	obj := &BsnGentableEntryDescStatsEntry{}
	return obj
}

type BsnGentableEntryStatsEntry struct {
	Length    uint16
	KeyLength uint16
	Key       []IBsnTlv
	Stats     []IBsnTlv
}

type IBsnGentableEntryStatsEntry interface {
	goloxi.Serializable
	GetLength() uint16
	GetKeyLength() uint16
	GetKey() []IBsnTlv
	GetStats() []IBsnTlv
}

func (self *BsnGentableEntryStatsEntry) GetLength() uint16 {
	return self.Length
}

func (self *BsnGentableEntryStatsEntry) SetLength(v uint16) {
	self.Length = v
}

func (self *BsnGentableEntryStatsEntry) GetKeyLength() uint16 {
	return self.KeyLength
}

func (self *BsnGentableEntryStatsEntry) SetKeyLength(v uint16) {
	self.KeyLength = v
}

func (self *BsnGentableEntryStatsEntry) GetKey() []IBsnTlv {
	return self.Key
}

func (self *BsnGentableEntryStatsEntry) SetKey(v []IBsnTlv) {
	self.Key = v
}

func (self *BsnGentableEntryStatsEntry) GetStats() []IBsnTlv {
	return self.Stats
}

func (self *BsnGentableEntryStatsEntry) SetStats(v []IBsnTlv) {
	self.Stats = v
}

func (self *BsnGentableEntryStatsEntry) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())

	encoder.PutUint16(uint16(self.Length))
	encoder.PutUint16(uint16(self.KeyLength))
	for _, obj := range self.Key {
		if err := obj.Serialize(encoder); err != nil {
			return err
		}
	}
	for _, obj := range self.Stats {
		if err := obj.Serialize(encoder); err != nil {
			return err
		}
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))

	return nil
}

func DecodeBsnGentableEntryStatsEntry(decoder *goloxi.Decoder) (*BsnGentableEntryStatsEntry, error) {
	_bsngentableentrystatsentry := &BsnGentableEntryStatsEntry{}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("BsnGentableEntryStatsEntry packet too short: %d < 4", decoder.Length())
	}
	_bsngentableentrystatsentry.Length = uint16(decoder.ReadUint16())
	oldDecoder := decoder
	defer func() { decoder = oldDecoder }()
	decoder = decoder.SliceDecoder(int(_bsngentableentrystatsentry.Length), 2+0)
	_bsngentableentrystatsentry.KeyLength = uint16(decoder.ReadUint16())

	end := decoder.Offset() + int(_bsngentableentrystatsentry.KeyLength)
	for decoder.Offset() < end {
		item, err := DecodeBsnTlv(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_bsngentableentrystatsentry.Key = append(_bsngentableentrystatsentry.Key, item)
		}
	}

	for decoder.Length() >= 4 {
		item, err := DecodeBsnTlv(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_bsngentableentrystatsentry.Stats = append(_bsngentableentrystatsentry.Stats, item)
		}
	}
	return _bsngentableentrystatsentry, nil
}

func NewBsnGentableEntryStatsEntry() *BsnGentableEntryStatsEntry {
	obj := &BsnGentableEntryStatsEntry{}
	return obj
}

type BsnGentableStatsEntry struct {
	TableId    uint16
	EntryCount uint32
	Checksum   Checksum128
}

type IBsnGentableStatsEntry interface {
	goloxi.Serializable
	GetTableId() uint16
	GetEntryCount() uint32
	GetChecksum() Checksum128
}

func (self *BsnGentableStatsEntry) GetTableId() uint16 {
	return self.TableId
}

func (self *BsnGentableStatsEntry) SetTableId(v uint16) {
	self.TableId = v
}

func (self *BsnGentableStatsEntry) GetEntryCount() uint32 {
	return self.EntryCount
}

func (self *BsnGentableStatsEntry) SetEntryCount(v uint32) {
	self.EntryCount = v
}

func (self *BsnGentableStatsEntry) GetChecksum() Checksum128 {
	return self.Checksum
}

func (self *BsnGentableStatsEntry) SetChecksum(v Checksum128) {
	self.Checksum = v
}

func (self *BsnGentableStatsEntry) Serialize(encoder *goloxi.Encoder) error {

	encoder.PutUint16(uint16(self.TableId))
	encoder.Write(bytes.Repeat([]byte{0}, 2))
	encoder.PutUint32(uint32(self.EntryCount))
	self.Checksum.Serialize(encoder)

	return nil
}

func DecodeBsnGentableStatsEntry(decoder *goloxi.Decoder) (*BsnGentableStatsEntry, error) {
	_bsngentablestatsentry := &BsnGentableStatsEntry{}
	if decoder.Length() < 24 {
		return nil, fmt.Errorf("BsnGentableStatsEntry packet too short: %d < 24", decoder.Length())
	}
	_bsngentablestatsentry.TableId = uint16(decoder.ReadUint16())
	decoder.Skip(2)
	_bsngentablestatsentry.EntryCount = uint32(decoder.ReadUint32())
	_bsngentablestatsentry.Checksum.Decode(decoder)
	return _bsngentablestatsentry, nil
}

func NewBsnGentableStatsEntry() *BsnGentableStatsEntry {
	obj := &BsnGentableStatsEntry{}
	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 BsnLacpStatsEntry struct {
	PortNo              Port
	ActorSysPriority    uint16
	ActorSysMac         net.HardwareAddr
	ActorPortPriority   uint16
	ActorPortNum        uint16
	ActorKey            uint16
	ConvergenceStatus   uint8
	PartnerSysPriority  uint16
	PartnerSysMac       net.HardwareAddr
	PartnerPortPriority uint16
	PartnerPortNum      uint16
	PartnerKey          uint16
}

type IBsnLacpStatsEntry interface {
	goloxi.Serializable
	GetPortNo() Port
	GetActorSysPriority() uint16
	GetActorSysMac() net.HardwareAddr
	GetActorPortPriority() uint16
	GetActorPortNum() uint16
	GetActorKey() uint16
	GetConvergenceStatus() uint8
	GetPartnerSysPriority() uint16
	GetPartnerSysMac() net.HardwareAddr
	GetPartnerPortPriority() uint16
	GetPartnerPortNum() uint16
	GetPartnerKey() uint16
}

func (self *BsnLacpStatsEntry) GetPortNo() Port {
	return self.PortNo
}

func (self *BsnLacpStatsEntry) SetPortNo(v Port) {
	self.PortNo = v
}

func (self *BsnLacpStatsEntry) GetActorSysPriority() uint16 {
	return self.ActorSysPriority
}

func (self *BsnLacpStatsEntry) SetActorSysPriority(v uint16) {
	self.ActorSysPriority = v
}

func (self *BsnLacpStatsEntry) GetActorSysMac() net.HardwareAddr {
	return self.ActorSysMac
}

func (self *BsnLacpStatsEntry) SetActorSysMac(v net.HardwareAddr) {
	self.ActorSysMac = v
}

func (self *BsnLacpStatsEntry) GetActorPortPriority() uint16 {
	return self.ActorPortPriority
}

func (self *BsnLacpStatsEntry) SetActorPortPriority(v uint16) {
	self.ActorPortPriority = v
}

func (self *BsnLacpStatsEntry) GetActorPortNum() uint16 {
	return self.ActorPortNum
}

func (self *BsnLacpStatsEntry) SetActorPortNum(v uint16) {
	self.ActorPortNum = v
}

func (self *BsnLacpStatsEntry) GetActorKey() uint16 {
	return self.ActorKey
}

func (self *BsnLacpStatsEntry) SetActorKey(v uint16) {
	self.ActorKey = v
}

func (self *BsnLacpStatsEntry) GetConvergenceStatus() uint8 {
	return self.ConvergenceStatus
}

func (self *BsnLacpStatsEntry) SetConvergenceStatus(v uint8) {
	self.ConvergenceStatus = v
}

func (self *BsnLacpStatsEntry) GetPartnerSysPriority() uint16 {
	return self.PartnerSysPriority
}

func (self *BsnLacpStatsEntry) SetPartnerSysPriority(v uint16) {
	self.PartnerSysPriority = v
}

func (self *BsnLacpStatsEntry) GetPartnerSysMac() net.HardwareAddr {
	return self.PartnerSysMac
}

func (self *BsnLacpStatsEntry) SetPartnerSysMac(v net.HardwareAddr) {
	self.PartnerSysMac = v
}

func (self *BsnLacpStatsEntry) GetPartnerPortPriority() uint16 {
	return self.PartnerPortPriority
}

func (self *BsnLacpStatsEntry) SetPartnerPortPriority(v uint16) {
	self.PartnerPortPriority = v
}

func (self *BsnLacpStatsEntry) GetPartnerPortNum() uint16 {
	return self.PartnerPortNum
}

func (self *BsnLacpStatsEntry) SetPartnerPortNum(v uint16) {
	self.PartnerPortNum = v
}

func (self *BsnLacpStatsEntry) GetPartnerKey() uint16 {
	return self.PartnerKey
}

func (self *BsnLacpStatsEntry) SetPartnerKey(v uint16) {
	self.PartnerKey = v
}

func (self *BsnLacpStatsEntry) Serialize(encoder *goloxi.Encoder) error {

	self.PortNo.Serialize(encoder)
	encoder.PutUint16(uint16(self.ActorSysPriority))
	encoder.Write(self.ActorSysMac)
	encoder.PutUint16(uint16(self.ActorPortPriority))
	encoder.PutUint16(uint16(self.ActorPortNum))
	encoder.PutUint16(uint16(self.ActorKey))
	encoder.PutUint8(uint8(self.ConvergenceStatus))
	encoder.Write(bytes.Repeat([]byte{0}, 1))
	encoder.PutUint16(uint16(self.PartnerSysPriority))
	encoder.Write(self.PartnerSysMac)
	encoder.PutUint16(uint16(self.PartnerPortPriority))
	encoder.PutUint16(uint16(self.PartnerPortNum))
	encoder.PutUint16(uint16(self.PartnerKey))
	encoder.Write(bytes.Repeat([]byte{0}, 2))

	return nil
}

func DecodeBsnLacpStatsEntry(decoder *goloxi.Decoder) (*BsnLacpStatsEntry, error) {
	_bsnlacpstatsentry := &BsnLacpStatsEntry{}
	if decoder.Length() < 36 {
		return nil, fmt.Errorf("BsnLacpStatsEntry packet too short: %d < 36", decoder.Length())
	}
	_bsnlacpstatsentry.PortNo.Decode(decoder)
	_bsnlacpstatsentry.ActorSysPriority = uint16(decoder.ReadUint16())
	_bsnlacpstatsentry.ActorSysMac = net.HardwareAddr(decoder.Read(6))
	_bsnlacpstatsentry.ActorPortPriority = uint16(decoder.ReadUint16())
	_bsnlacpstatsentry.ActorPortNum = uint16(decoder.ReadUint16())
	_bsnlacpstatsentry.ActorKey = uint16(decoder.ReadUint16())
	_bsnlacpstatsentry.ConvergenceStatus = uint8(decoder.ReadByte())
	decoder.Skip(1)
	_bsnlacpstatsentry.PartnerSysPriority = uint16(decoder.ReadUint16())
	_bsnlacpstatsentry.PartnerSysMac = net.HardwareAddr(decoder.Read(6))
	_bsnlacpstatsentry.PartnerPortPriority = uint16(decoder.ReadUint16())
	_bsnlacpstatsentry.PartnerPortNum = uint16(decoder.ReadUint16())
	_bsnlacpstatsentry.PartnerKey = uint16(decoder.ReadUint16())
	decoder.Skip(2)
	return _bsnlacpstatsentry, nil
}

func NewBsnLacpStatsEntry() *BsnLacpStatsEntry {
	obj := &BsnLacpStatsEntry{}
	return obj
}

type BsnPortCounterStatsEntry struct {
	Length uint16
	PortNo Port
	Values []*Uint64
}

type IBsnPortCounterStatsEntry interface {
	goloxi.Serializable
	GetLength() uint16
	GetPortNo() Port
	GetValues() []*Uint64
}

func (self *BsnPortCounterStatsEntry) GetLength() uint16 {
	return self.Length
}

func (self *BsnPortCounterStatsEntry) SetLength(v uint16) {
	self.Length = v
}

func (self *BsnPortCounterStatsEntry) GetPortNo() Port {
	return self.PortNo
}

func (self *BsnPortCounterStatsEntry) SetPortNo(v Port) {
	self.PortNo = v
}

func (self *BsnPortCounterStatsEntry) GetValues() []*Uint64 {
	return self.Values
}

func (self *BsnPortCounterStatsEntry) SetValues(v []*Uint64) {
	self.Values = v
}

func (self *BsnPortCounterStatsEntry) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())

	encoder.PutUint16(uint16(self.Length))
	encoder.Write(bytes.Repeat([]byte{0}, 2))
	self.PortNo.Serialize(encoder)
	for _, obj := range self.Values {
		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 DecodeBsnPortCounterStatsEntry(decoder *goloxi.Decoder) (*BsnPortCounterStatsEntry, error) {
	_bsnportcounterstatsentry := &BsnPortCounterStatsEntry{}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("BsnPortCounterStatsEntry packet too short: %d < 8", decoder.Length())
	}
	_bsnportcounterstatsentry.Length = uint16(decoder.ReadUint16())
	oldDecoder := decoder
	defer func() { decoder = oldDecoder }()
	decoder = decoder.SliceDecoder(int(_bsnportcounterstatsentry.Length), 2+0)
	decoder.Skip(2)
	_bsnportcounterstatsentry.PortNo.Decode(decoder)

	for decoder.Length() >= 8 {
		item, err := DecodeUint64(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_bsnportcounterstatsentry.Values = append(_bsnportcounterstatsentry.Values, item)
		}
	}
	return _bsnportcounterstatsentry, nil
}

func NewBsnPortCounterStatsEntry() *BsnPortCounterStatsEntry {
	obj := &BsnPortCounterStatsEntry{}
	return obj
}

type BsnSwitchPipelineStatsEntry struct {
	Pipeline string
}

type IBsnSwitchPipelineStatsEntry interface {
	goloxi.Serializable
	GetPipeline() string
}

func (self *BsnSwitchPipelineStatsEntry) GetPipeline() string {
	return self.Pipeline
}

func (self *BsnSwitchPipelineStatsEntry) SetPipeline(v string) {
	self.Pipeline = v
}

func (self *BsnSwitchPipelineStatsEntry) Serialize(encoder *goloxi.Encoder) error {

	encoder.Write([]byte(self.Pipeline))

	return nil
}

func DecodeBsnSwitchPipelineStatsEntry(decoder *goloxi.Decoder) (*BsnSwitchPipelineStatsEntry, error) {
	_bsnswitchpipelinestatsentry := &BsnSwitchPipelineStatsEntry{}
	if decoder.Length() < 256 {
		return nil, fmt.Errorf("BsnSwitchPipelineStatsEntry packet too short: %d < 256", decoder.Length())
	}
	_bsnswitchpipelinestatsentry.Pipeline = string(bytes.Trim(decoder.Read(256), "\x00"))
	return _bsnswitchpipelinestatsentry, nil
}

func NewBsnSwitchPipelineStatsEntry() *BsnSwitchPipelineStatsEntry {
	obj := &BsnSwitchPipelineStatsEntry{}
	return obj
}

type BsnTableChecksumStatsEntry struct {
	TableId  uint8
	Checksum uint64
}

type IBsnTableChecksumStatsEntry interface {
	goloxi.Serializable
	GetTableId() uint8
	GetChecksum() uint64
}

func (self *BsnTableChecksumStatsEntry) GetTableId() uint8 {
	return self.TableId
}

func (self *BsnTableChecksumStatsEntry) SetTableId(v uint8) {
	self.TableId = v
}

func (self *BsnTableChecksumStatsEntry) GetChecksum() uint64 {
	return self.Checksum
}

func (self *BsnTableChecksumStatsEntry) SetChecksum(v uint64) {
	self.Checksum = v
}

func (self *BsnTableChecksumStatsEntry) Serialize(encoder *goloxi.Encoder) error {

	encoder.PutUint8(uint8(self.TableId))
	encoder.PutUint64(uint64(self.Checksum))

	return nil
}

func DecodeBsnTableChecksumStatsEntry(decoder *goloxi.Decoder) (*BsnTableChecksumStatsEntry, error) {
	_bsntablechecksumstatsentry := &BsnTableChecksumStatsEntry{}
	if decoder.Length() < 9 {
		return nil, fmt.Errorf("BsnTableChecksumStatsEntry packet too short: %d < 9", decoder.Length())
	}
	_bsntablechecksumstatsentry.TableId = uint8(decoder.ReadByte())
	_bsntablechecksumstatsentry.Checksum = uint64(decoder.ReadUint64())
	return _bsntablechecksumstatsentry, nil
}

func NewBsnTableChecksumStatsEntry() *BsnTableChecksumStatsEntry {
	obj := &BsnTableChecksumStatsEntry{}
	return obj
}

type BsnTlv struct {
	Type   uint16
	Length uint16
}

type IBsnTlv interface {
	goloxi.Serializable
	GetType() uint16
	GetLength() uint16
}

func (self *BsnTlv) GetType() uint16 {
	return self.Type
}

func (self *BsnTlv) SetType(v uint16) {
	self.Type = v
}

func (self *BsnTlv) GetLength() uint16 {
	return self.Length
}

func (self *BsnTlv) SetLength(v uint16) {
	self.Length = v
}

func (self *BsnTlv) Serialize(encoder *goloxi.Encoder) error {

	encoder.PutUint16(uint16(self.Type))
	encoder.PutUint16(uint16(self.Length))

	return nil
}

func DecodeBsnTlv(decoder *goloxi.Decoder) (IBsnTlv, error) {
	_bsntlv := &BsnTlv{}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("BsnTlv packet too short: %d < 4", decoder.Length())
	}
	_bsntlv.Type = uint16(decoder.ReadUint16())
	_bsntlv.Length = uint16(decoder.ReadUint16())
	oldDecoder := decoder
	defer func() { decoder = oldDecoder }()
	decoder = decoder.SliceDecoder(int(_bsntlv.Length), 2+2)

	switch _bsntlv.Type {
	case 0:
		return DecodeBsnTlvPort(_bsntlv, decoder)
	case 1:
		return DecodeBsnTlvMac(_bsntlv, decoder)
	case 2:
		return DecodeBsnTlvRxPackets(_bsntlv, decoder)
	case 3:
		return DecodeBsnTlvTxPackets(_bsntlv, decoder)
	case 4:
		return DecodeBsnTlvIpv4(_bsntlv, decoder)
	case 5:
		return DecodeBsnTlvIdleTime(_bsntlv, decoder)
	case 6:
		return DecodeBsnTlvVlanVid(_bsntlv, decoder)
	case 7:
		return DecodeBsnTlvIdleNotification(_bsntlv, decoder)
	case 8:
		return DecodeBsnTlvIdleTimeout(_bsntlv, decoder)
	case 9:
		return DecodeBsnTlvUnicastQueryTimeout(_bsntlv, decoder)
	case 10:
		return DecodeBsnTlvBroadcastQueryTimeout(_bsntlv, decoder)
	case 11:
		return DecodeBsnTlvRequestPackets(_bsntlv, decoder)
	case 12:
		return DecodeBsnTlvReplyPackets(_bsntlv, decoder)
	case 13:
		return DecodeBsnTlvMissPackets(_bsntlv, decoder)
	case 14:
		return DecodeBsnTlvCircuitId(_bsntlv, decoder)
	case 15:
		return DecodeBsnTlvUdfId(_bsntlv, decoder)
	case 16:
		return DecodeBsnTlvUdfAnchor(_bsntlv, decoder)
	case 17:
		return DecodeBsnTlvUdfOffset(_bsntlv, decoder)
	case 18:
		return DecodeBsnTlvUdfLength(_bsntlv, decoder)
	case 19:
		return DecodeBsnTlvVrf(_bsntlv, decoder)
	case 20:
		return DecodeBsnTlvQueueId(_bsntlv, decoder)
	case 21:
		return DecodeBsnTlvQueueWeight(_bsntlv, decoder)
	case 22:
		return DecodeBsnTlvCrcEnabled(_bsntlv, decoder)
	case 23:
		return DecodeBsnTlvExternalIp(_bsntlv, decoder)
	case 24:
		return DecodeBsnTlvExternalMac(_bsntlv, decoder)
	case 25:
		return DecodeBsnTlvExternalNetmask(_bsntlv, decoder)
	case 26:
		return DecodeBsnTlvExternalGatewayIp(_bsntlv, decoder)
	case 27:
		return DecodeBsnTlvInternalMac(_bsntlv, decoder)
	case 28:
		return DecodeBsnTlvInternalGatewayMac(_bsntlv, decoder)
	case 29:
		return DecodeBsnTlvExternalGatewayMac(_bsntlv, decoder)
	case 30:
		return DecodeBsnTlvSamplingRate(_bsntlv, decoder)
	case 31:
		return DecodeBsnTlvHeaderSize(_bsntlv, decoder)
	case 32:
		return DecodeBsnTlvEthSrc(_bsntlv, decoder)
	case 33:
		return DecodeBsnTlvEthDst(_bsntlv, decoder)
	case 34:
		return DecodeBsnTlvIpv4Src(_bsntlv, decoder)
	case 35:
		return DecodeBsnTlvIpv4Dst(_bsntlv, decoder)
	case 36:
		return DecodeBsnTlvUdpSrc(_bsntlv, decoder)
	case 37:
		return DecodeBsnTlvUdpDst(_bsntlv, decoder)
	case 38:
		return DecodeBsnTlvSubAgentId(_bsntlv, decoder)
	case 39:
		return DecodeBsnTlvTxBytes(_bsntlv, decoder)
	case 40:
		return DecodeBsnTlvActorSystemPriority(_bsntlv, decoder)
	case 41:
		return DecodeBsnTlvActorSystemMac(_bsntlv, decoder)
	case 42:
		return DecodeBsnTlvActorPortPriority(_bsntlv, decoder)
	case 43:
		return DecodeBsnTlvActorPortNum(_bsntlv, decoder)
	case 44:
		return DecodeBsnTlvActorKey(_bsntlv, decoder)
	case 45:
		return DecodeBsnTlvConvergenceStatus(_bsntlv, decoder)
	case 47:
		return DecodeBsnTlvPartnerSystemPriority(_bsntlv, decoder)
	case 48:
		return DecodeBsnTlvPartnerSystemMac(_bsntlv, decoder)
	case 49:
		return DecodeBsnTlvPartnerPortPriority(_bsntlv, decoder)
	case 50:
		return DecodeBsnTlvPartnerPortNum(_bsntlv, decoder)
	case 51:
		return DecodeBsnTlvPartnerKey(_bsntlv, decoder)
	case 52:
		return DecodeBsnTlvName(_bsntlv, decoder)
	case 53:
		return DecodeBsnTlvActorState(_bsntlv, decoder)
	case 54:
		return DecodeBsnTlvPartnerState(_bsntlv, decoder)
	case 55:
		return DecodeBsnTlvData(_bsntlv, decoder)
	case 56:
		return DecodeBsnTlvMacMask(_bsntlv, decoder)
	case 57:
		return DecodeBsnTlvPriority(_bsntlv, decoder)
	case 58:
		return DecodeBsnTlvInterval(_bsntlv, decoder)
	case 59:
		return DecodeBsnTlvReference(_bsntlv, decoder)
	case 60:
		return DecodeBsnTlvIpv4Netmask(_bsntlv, decoder)
	case 61:
		return DecodeBsnTlvMplsLabel(_bsntlv, decoder)
	case 62:
		return DecodeBsnTlvMplsControlWord(_bsntlv, decoder)
	case 63:
		return DecodeBsnTlvMplsSequenced(_bsntlv, decoder)
	case 64:
		return DecodeBsnTlvBucket(_bsntlv, decoder)
	case 65:
		return DecodeBsnTlvTcpSrc(_bsntlv, decoder)
	case 66:
		return DecodeBsnTlvTcpDst(_bsntlv, decoder)
	case 67:
		return DecodeBsnTlvIpProto(_bsntlv, decoder)
	case 68:
		return DecodeBsnTlvIcmpType(_bsntlv, decoder)
	case 69:
		return DecodeBsnTlvIcmpCode(_bsntlv, decoder)
	case 70:
		return DecodeBsnTlvIcmpId(_bsntlv, decoder)
	case 71:
		return DecodeBsnTlvRxBytes(_bsntlv, decoder)
	case 72:
		return DecodeBsnTlvVlanPcp(_bsntlv, decoder)
	case 73:
		return DecodeBsnTlvStripVlanOnEgress(_bsntlv, decoder)
	case 74:
		return DecodeBsnTlvSetLoopbackMode(_bsntlv, decoder)
	case 75:
		return DecodeBsnTlvStripMplsL2OnIngress(_bsntlv, decoder)
	case 76:
		return DecodeBsnTlvStripMplsL3OnIngress(_bsntlv, decoder)
	case 77:
		return DecodeBsnTlvVlanVidMask(_bsntlv, decoder)
	case 78:
		return DecodeBsnTlvIgmpSnooping(_bsntlv, decoder)
	case 79:
		return DecodeBsnTlvL2MulticastLookup(_bsntlv, decoder)
	case 80:
		return DecodeBsnTlvGenerationId(_bsntlv, decoder)
	case 81:
		return DecodeBsnTlvAnchor(_bsntlv, decoder)
	case 82:
		return DecodeBsnTlvOffset(_bsntlv, decoder)
	case 83:
		return DecodeBsnTlvNegate(_bsntlv, decoder)
	case 84:
		return DecodeBsnTlvIpv6(_bsntlv, decoder)
	case 85:
		return DecodeBsnTlvDecap(_bsntlv, decoder)
	case 86:
		return DecodeBsnTlvVni(_bsntlv, decoder)
	case 87:
		return DecodeBsnTlvMcgTypeVxlan(_bsntlv, decoder)
	case 88:
		return DecodeBsnTlvPortVxlanMode(_bsntlv, decoder)
	case 89:
		return DecodeBsnTlvRateUnit(_bsntlv, decoder)
	case 90:
		return DecodeBsnTlvBroadcastRate(_bsntlv, decoder)
	case 91:
		return DecodeBsnTlvKnownMulticastRate(_bsntlv, decoder)
	case 92:
		return DecodeBsnTlvUnknownMulticastRate(_bsntlv, decoder)
	case 93:
		return DecodeBsnTlvUnicastRate(_bsntlv, decoder)
	case 94:
		return DecodeBsnTlvNexthopTypeVxlan(_bsntlv, decoder)
	case 95:
		return DecodeBsnTlvMulticastInterfaceId(_bsntlv, decoder)
	case 96:
		return DecodeBsnTlvUsePacketState(_bsntlv, decoder)
	case 97:
		return DecodeBsnTlvStatus(_bsntlv, decoder)
	case 98:
		return DecodeBsnTlvVlanMacList(_bsntlv, decoder)
	case 99:
		return DecodeBsnTlvVfi(_bsntlv, decoder)
	case 100:
		return DecodeBsnTlvHashSeed(_bsntlv, decoder)
	case 101:
		return DecodeBsnTlvHashType(_bsntlv, decoder)
	case 102:
		return DecodeBsnTlvHashPacketType(_bsntlv, decoder)
	case 103:
		return DecodeBsnTlvHashPacketField(_bsntlv, decoder)
	case 104:
		return DecodeBsnTlvHashGtpHeaderMatch(_bsntlv, decoder)
	case 105:
		return DecodeBsnTlvHashGtpPortMatch(_bsntlv, decoder)
	case 106:
		return DecodeBsnTlvUntagged(_bsntlv, decoder)
	case 107:
		return DecodeBsnTlvVfpClassId(_bsntlv, decoder)
	case 108:
		return DecodeBsnTlvQosPriority(_bsntlv, decoder)
	case 109:
		return DecodeBsnTlvParentPort(_bsntlv, decoder)
	case 110:
		return DecodeBsnTlvLoopbackPort(_bsntlv, decoder)
	case 111:
		return DecodeBsnTlvVpnKey(_bsntlv, decoder)
	case 112:
		return DecodeBsnTlvDscp(_bsntlv, decoder)
	case 113:
		return DecodeBsnTlvTtl(_bsntlv, decoder)
	case 114:
		return DecodeBsnTlvNextHopMac(_bsntlv, decoder)
	case 115:
		return DecodeBsnTlvNextHopIpv4(_bsntlv, decoder)
	case 116:
		return DecodeBsnTlvRateLimit(_bsntlv, decoder)
	case 117:
		return DecodeBsnTlvVxlanEgressLag(_bsntlv, decoder)
	case 118:
		return DecodeBsnTlvCpuLag(_bsntlv, decoder)
	case 119:
		return DecodeBsnTlvUint64List(_bsntlv, decoder)
	case 120:
		return DecodeBsnTlvDisableSrcMacCheck(_bsntlv, decoder)
	case 121:
		return DecodeBsnTlvDrop(_bsntlv, decoder)
	case 122:
		return DecodeBsnTlvIpv6Prefix(_bsntlv, decoder)
	case 123:
		return DecodeBsnTlvNdpOffload(_bsntlv, decoder)
	case 124:
		return DecodeBsnTlvNdpStatic(_bsntlv, decoder)
	case 125:
		return DecodeBsnTlvIcmpv6Chksum(_bsntlv, decoder)
	case 126:
		return DecodeBsnTlvIpv6Src(_bsntlv, decoder)
	case 127:
		return DecodeBsnTlvIpv6Dst(_bsntlv, decoder)
	case 128:
		return DecodeBsnTlvPushVlanOnIngress(_bsntlv, decoder)
	case 129:
		return DecodeBsnTlvApplyPackets(_bsntlv, decoder)
	case 130:
		return DecodeBsnTlvApplyBytes(_bsntlv, decoder)
	case 131:
		return DecodeBsnTlvEthType(_bsntlv, decoder)
	case 132:
		return DecodeBsnTlvEcn(_bsntlv, decoder)
	case 133:
		return DecodeBsnTlvTcpFlags(_bsntlv, decoder)
	case 134:
		return DecodeBsnTlvL3InterfaceClassId(_bsntlv, decoder)
	case 135:
		return DecodeBsnTlvL3SrcClassId(_bsntlv, decoder)
	case 136:
		return DecodeBsnTlvL3DstClassId(_bsntlv, decoder)
	case 137:
		return DecodeBsnTlvEgressOnly(_bsntlv, decoder)
	case 138:
		return DecodeBsnTlvIngressPortGroupId(_bsntlv, decoder)
	case 139:
		return DecodeBsnTlvEgressPortGroupId(_bsntlv, decoder)
	case 140:
		return DecodeBsnTlvDataMask(_bsntlv, decoder)
	case 141:
		return DecodeBsnTlvPortUsage(_bsntlv, decoder)
	case 142:
		return DecodeBsnTlvTunnelCapability(_bsntlv, decoder)
	case 143:
		return DecodeBsnTlvEnhancedHashCapability(_bsntlv, decoder)
	case 144:
		return DecodeBsnTlvAutoNegotiation(_bsntlv, decoder)
	case 145:
		return DecodeBsnTlvHashAlgorithm(_bsntlv, decoder)
	case 146:
		return DecodeBsnTlvLoopbackMode(_bsntlv, decoder)
	case 147:
		return DecodeBsnTlvNoArpResponse(_bsntlv, decoder)
	case 148:
		return DecodeBsnTlvNoNsResponse(_bsntlv, decoder)
	case 149:
		return DecodeBsnTlvForwardErrorCorrection(_bsntlv, decoder)
	case 150:
		return DecodeBsnTlvOpticsAlwaysEnabled(_bsntlv, decoder)
	case 151:
		return DecodeBsnTlvForceLinkUp(_bsntlv, decoder)
	case 152:
		return DecodeBsnTlvRestServer(_bsntlv, decoder)
	case 153:
		return DecodeBsnTlvUriScheme(_bsntlv, decoder)
	case 154:
		return DecodeBsnTlvTimestamp(_bsntlv, decoder)
	case 155:
		return DecodeBsnTlvRecordPackets(_bsntlv, decoder)
	case 156:
		return DecodeBsnTlvPortSpeedGbps(_bsntlv, decoder)
	case 157:
		return DecodeBsnTlvOuterSrcMac(_bsntlv, decoder)
	case 158:
		return DecodeBsnTlvVirtual(_bsntlv, decoder)
	case 159:
		return DecodeBsnTlvPduaRxInstance(_bsntlv, decoder)
	case 160:
		return DecodeBsnTlvLagOptions(_bsntlv, decoder)
	case 161:
		return DecodeBsnTlvRoutingParam(_bsntlv, decoder)
	case 162:
		return DecodeBsnTlvPushVlanOnEgress(_bsntlv, decoder)
	case 163:
		return DecodeBsnTlvFlood(_bsntlv, decoder)
	case 164:
		return DecodeBsnTlvUpgrade(_bsntlv, decoder)
	case 165:
		return DecodeBsnTlvFabricPortRole(_bsntlv, decoder)
	case 166:
		return DecodeBsnTlvUserConfigured(_bsntlv, decoder)
	case 167:
		return DecodeBsnTlvUint32(_bsntlv, decoder)
	case 168:
		return DecodeBsnTlvL3(_bsntlv, decoder)
	case 169:
		return DecodeBsnTlvIpTunnelType(_bsntlv, decoder)
	case 170:
		return DecodeBsnTlvMulticastPacket(_bsntlv, decoder)
	case 171:
		return DecodeBsnTlvPimDr(_bsntlv, decoder)
	case 172:
		return DecodeBsnTlvPassive(_bsntlv, decoder)
	case 173:
		return DecodeBsnTlvIdentifier(_bsntlv, decoder)
	case 174:
		return DecodeBsnTlvMultiplier(_bsntlv, decoder)
	case 175:
		return DecodeBsnTlvEncap(_bsntlv, decoder)
	case 176:
		return DecodeBsnTlvBfdEndpoint(_bsntlv, decoder)
	case 177:
		return DecodeBsnTlvBfdState(_bsntlv, decoder)
	case 178:
		return DecodeBsnTlvLrAllEnabled(_bsntlv, decoder)
	case 179:
		return DecodeBsnTlvPortMode(_bsntlv, decoder)
	case 180:
		return DecodeBsnTlvUdfCapability(_bsntlv, decoder)
	case 181:
		return DecodeBsnTlvPimHelloFlood(_bsntlv, decoder)
	case 182:
		return DecodeBsnTlvFlowClassify(_bsntlv, decoder)
	case 183:
		return DecodeBsnTlvFlowIdentifier(_bsntlv, decoder)
	case 184:
		return DecodeBsnTlvFlowClassifier(_bsntlv, decoder)
	case 185:
		return DecodeBsnTlvDisableXmit(_bsntlv, decoder)
	case 186:
		return DecodeBsnTlvPreserveVlan(_bsntlv, decoder)
	case 187:
		return DecodeBsnTlvDropControl(_bsntlv, decoder)
	case 188:
		return DecodeBsnTlvLossless(_bsntlv, decoder)
	case 189:
		return DecodeBsnTlvRedundantMgmt(_bsntlv, decoder)
	case 190:
		return DecodeBsnTlvDnsAnalytics(_bsntlv, decoder)
	case 191:
		return DecodeBsnTlvSrcMacCml(_bsntlv, decoder)
	case 192:
		return DecodeBsnTlvActive(_bsntlv, decoder)
	case 193:
		return DecodeBsnTlvLinkUp(_bsntlv, decoder)
	case 194:
		return DecodeBsnTlvFailCount(_bsntlv, decoder)
	case 195:
		return DecodeBsnTlvEgressSamplingRate(_bsntlv, decoder)
	default:
		return nil, fmt.Errorf("Invalid type '%d' for 'BsnTlv'", _bsntlv.Type)
	}
}

func NewBsnTlv(_type uint16) *BsnTlv {
	obj := &BsnTlv{}
	obj.Type = _type
	return obj
}

type BsnTlvActive struct {
	*BsnTlv
}

type IBsnTlvActive interface {
	IBsnTlv
}

func (self *BsnTlvActive) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvActive(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvActive, error) {
	_bsntlvactive := &BsnTlvActive{BsnTlv: parent}
	return _bsntlvactive, nil
}

func NewBsnTlvActive() *BsnTlvActive {
	obj := &BsnTlvActive{
		BsnTlv: NewBsnTlv(192),
	}
	return obj
}

type BsnTlvActorKey struct {
	*BsnTlv
	Value uint16
}

type IBsnTlvActorKey interface {
	IBsnTlv
	GetValue() uint16
}

func (self *BsnTlvActorKey) GetValue() uint16 {
	return self.Value
}

func (self *BsnTlvActorKey) SetValue(v uint16) {
	self.Value = v
}

func (self *BsnTlvActorKey) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint16(uint16(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvActorKey(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvActorKey, error) {
	_bsntlvactorkey := &BsnTlvActorKey{BsnTlv: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("BsnTlvActorKey packet too short: %d < 2", decoder.Length())
	}
	_bsntlvactorkey.Value = uint16(decoder.ReadUint16())
	return _bsntlvactorkey, nil
}

func NewBsnTlvActorKey() *BsnTlvActorKey {
	obj := &BsnTlvActorKey{
		BsnTlv: NewBsnTlv(44),
	}
	return obj
}

type BsnTlvActorPortNum struct {
	*BsnTlv
	Value uint16
}

type IBsnTlvActorPortNum interface {
	IBsnTlv
	GetValue() uint16
}

func (self *BsnTlvActorPortNum) GetValue() uint16 {
	return self.Value
}

func (self *BsnTlvActorPortNum) SetValue(v uint16) {
	self.Value = v
}

func (self *BsnTlvActorPortNum) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint16(uint16(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvActorPortNum(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvActorPortNum, error) {
	_bsntlvactorportnum := &BsnTlvActorPortNum{BsnTlv: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("BsnTlvActorPortNum packet too short: %d < 2", decoder.Length())
	}
	_bsntlvactorportnum.Value = uint16(decoder.ReadUint16())
	return _bsntlvactorportnum, nil
}

func NewBsnTlvActorPortNum() *BsnTlvActorPortNum {
	obj := &BsnTlvActorPortNum{
		BsnTlv: NewBsnTlv(43),
	}
	return obj
}

type BsnTlvActorPortPriority struct {
	*BsnTlv
	Value uint16
}

type IBsnTlvActorPortPriority interface {
	IBsnTlv
	GetValue() uint16
}

func (self *BsnTlvActorPortPriority) GetValue() uint16 {
	return self.Value
}

func (self *BsnTlvActorPortPriority) SetValue(v uint16) {
	self.Value = v
}

func (self *BsnTlvActorPortPriority) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint16(uint16(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvActorPortPriority(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvActorPortPriority, error) {
	_bsntlvactorportpriority := &BsnTlvActorPortPriority{BsnTlv: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("BsnTlvActorPortPriority packet too short: %d < 2", decoder.Length())
	}
	_bsntlvactorportpriority.Value = uint16(decoder.ReadUint16())
	return _bsntlvactorportpriority, nil
}

func NewBsnTlvActorPortPriority() *BsnTlvActorPortPriority {
	obj := &BsnTlvActorPortPriority{
		BsnTlv: NewBsnTlv(42),
	}
	return obj
}

type BsnTlvActorState struct {
	*BsnTlv
	Value BsnLacpState
}

type IBsnTlvActorState interface {
	IBsnTlv
	GetValue() BsnLacpState
}

func (self *BsnTlvActorState) GetValue() BsnLacpState {
	return self.Value
}

func (self *BsnTlvActorState) SetValue(v BsnLacpState) {
	self.Value = v
}

func (self *BsnTlvActorState) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint8(uint8(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvActorState(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvActorState, error) {
	_bsntlvactorstate := &BsnTlvActorState{BsnTlv: parent}
	if decoder.Length() < 1 {
		return nil, fmt.Errorf("BsnTlvActorState packet too short: %d < 1", decoder.Length())
	}
	_bsntlvactorstate.Value = BsnLacpState(decoder.ReadByte())
	return _bsntlvactorstate, nil
}

func NewBsnTlvActorState() *BsnTlvActorState {
	obj := &BsnTlvActorState{
		BsnTlv: NewBsnTlv(53),
	}
	return obj
}

type BsnTlvActorSystemMac struct {
	*BsnTlv
	Value net.HardwareAddr
}

type IBsnTlvActorSystemMac interface {
	IBsnTlv
	GetValue() net.HardwareAddr
}

func (self *BsnTlvActorSystemMac) GetValue() net.HardwareAddr {
	return self.Value
}

func (self *BsnTlvActorSystemMac) SetValue(v net.HardwareAddr) {
	self.Value = v
}

func (self *BsnTlvActorSystemMac) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.Write(self.Value)
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvActorSystemMac(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvActorSystemMac, error) {
	_bsntlvactorsystemmac := &BsnTlvActorSystemMac{BsnTlv: parent}
	if decoder.Length() < 6 {
		return nil, fmt.Errorf("BsnTlvActorSystemMac packet too short: %d < 6", decoder.Length())
	}
	_bsntlvactorsystemmac.Value = net.HardwareAddr(decoder.Read(6))
	return _bsntlvactorsystemmac, nil
}

func NewBsnTlvActorSystemMac() *BsnTlvActorSystemMac {
	obj := &BsnTlvActorSystemMac{
		BsnTlv: NewBsnTlv(41),
	}
	return obj
}

type BsnTlvActorSystemPriority struct {
	*BsnTlv
	Value uint16
}

type IBsnTlvActorSystemPriority interface {
	IBsnTlv
	GetValue() uint16
}

func (self *BsnTlvActorSystemPriority) GetValue() uint16 {
	return self.Value
}

func (self *BsnTlvActorSystemPriority) SetValue(v uint16) {
	self.Value = v
}

func (self *BsnTlvActorSystemPriority) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint16(uint16(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvActorSystemPriority(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvActorSystemPriority, error) {
	_bsntlvactorsystempriority := &BsnTlvActorSystemPriority{BsnTlv: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("BsnTlvActorSystemPriority packet too short: %d < 2", decoder.Length())
	}
	_bsntlvactorsystempriority.Value = uint16(decoder.ReadUint16())
	return _bsntlvactorsystempriority, nil
}

func NewBsnTlvActorSystemPriority() *BsnTlvActorSystemPriority {
	obj := &BsnTlvActorSystemPriority{
		BsnTlv: NewBsnTlv(40),
	}
	return obj
}

type BsnTlvAnchor struct {
	*BsnTlv
	Value BsnAnchor
}

type IBsnTlvAnchor interface {
	IBsnTlv
	GetValue() BsnAnchor
}

func (self *BsnTlvAnchor) GetValue() BsnAnchor {
	return self.Value
}

func (self *BsnTlvAnchor) SetValue(v BsnAnchor) {
	self.Value = v
}

func (self *BsnTlvAnchor) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint16(uint16(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvAnchor(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvAnchor, error) {
	_bsntlvanchor := &BsnTlvAnchor{BsnTlv: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("BsnTlvAnchor packet too short: %d < 2", decoder.Length())
	}
	_bsntlvanchor.Value = BsnAnchor(decoder.ReadUint16())
	return _bsntlvanchor, nil
}

func NewBsnTlvAnchor() *BsnTlvAnchor {
	obj := &BsnTlvAnchor{
		BsnTlv: NewBsnTlv(81),
	}
	return obj
}

type BsnTlvApplyBytes struct {
	*BsnTlv
	Value uint64
}

type IBsnTlvApplyBytes interface {
	IBsnTlv
	GetValue() uint64
}

func (self *BsnTlvApplyBytes) GetValue() uint64 {
	return self.Value
}

func (self *BsnTlvApplyBytes) SetValue(v uint64) {
	self.Value = v
}

func (self *BsnTlvApplyBytes) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint64(uint64(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvApplyBytes(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvApplyBytes, error) {
	_bsntlvapplybytes := &BsnTlvApplyBytes{BsnTlv: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("BsnTlvApplyBytes packet too short: %d < 8", decoder.Length())
	}
	_bsntlvapplybytes.Value = uint64(decoder.ReadUint64())
	return _bsntlvapplybytes, nil
}

func NewBsnTlvApplyBytes() *BsnTlvApplyBytes {
	obj := &BsnTlvApplyBytes{
		BsnTlv: NewBsnTlv(130),
	}
	return obj
}

type BsnTlvApplyPackets struct {
	*BsnTlv
	Value uint64
}

type IBsnTlvApplyPackets interface {
	IBsnTlv
	GetValue() uint64
}

func (self *BsnTlvApplyPackets) GetValue() uint64 {
	return self.Value
}

func (self *BsnTlvApplyPackets) SetValue(v uint64) {
	self.Value = v
}

func (self *BsnTlvApplyPackets) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint64(uint64(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvApplyPackets(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvApplyPackets, error) {
	_bsntlvapplypackets := &BsnTlvApplyPackets{BsnTlv: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("BsnTlvApplyPackets packet too short: %d < 8", decoder.Length())
	}
	_bsntlvapplypackets.Value = uint64(decoder.ReadUint64())
	return _bsntlvapplypackets, nil
}

func NewBsnTlvApplyPackets() *BsnTlvApplyPackets {
	obj := &BsnTlvApplyPackets{
		BsnTlv: NewBsnTlv(129),
	}
	return obj
}

type BsnTlvAutoNegotiation struct {
	*BsnTlv
	Value BsnAutoNegotiationType
}

type IBsnTlvAutoNegotiation interface {
	IBsnTlv
	GetValue() BsnAutoNegotiationType
}

func (self *BsnTlvAutoNegotiation) GetValue() BsnAutoNegotiationType {
	return self.Value
}

func (self *BsnTlvAutoNegotiation) SetValue(v BsnAutoNegotiationType) {
	self.Value = v
}

func (self *BsnTlvAutoNegotiation) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint8(uint8(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvAutoNegotiation(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvAutoNegotiation, error) {
	_bsntlvautonegotiation := &BsnTlvAutoNegotiation{BsnTlv: parent}
	if decoder.Length() < 1 {
		return nil, fmt.Errorf("BsnTlvAutoNegotiation packet too short: %d < 1", decoder.Length())
	}
	_bsntlvautonegotiation.Value = BsnAutoNegotiationType(decoder.ReadByte())
	return _bsntlvautonegotiation, nil
}

func NewBsnTlvAutoNegotiation() *BsnTlvAutoNegotiation {
	obj := &BsnTlvAutoNegotiation{
		BsnTlv: NewBsnTlv(144),
	}
	return obj
}

type BsnTlvBfdEndpoint struct {
	*BsnTlv
	Value BsnBfdEndpoint
}

type IBsnTlvBfdEndpoint interface {
	IBsnTlv
	GetValue() BsnBfdEndpoint
}

func (self *BsnTlvBfdEndpoint) GetValue() BsnBfdEndpoint {
	return self.Value
}

func (self *BsnTlvBfdEndpoint) SetValue(v BsnBfdEndpoint) {
	self.Value = v
}

func (self *BsnTlvBfdEndpoint) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint8(uint8(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvBfdEndpoint(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvBfdEndpoint, error) {
	_bsntlvbfdendpoint := &BsnTlvBfdEndpoint{BsnTlv: parent}
	if decoder.Length() < 1 {
		return nil, fmt.Errorf("BsnTlvBfdEndpoint packet too short: %d < 1", decoder.Length())
	}
	_bsntlvbfdendpoint.Value = BsnBfdEndpoint(decoder.ReadByte())
	return _bsntlvbfdendpoint, nil
}

func NewBsnTlvBfdEndpoint() *BsnTlvBfdEndpoint {
	obj := &BsnTlvBfdEndpoint{
		BsnTlv: NewBsnTlv(176),
	}
	return obj
}

type BsnTlvBfdState struct {
	*BsnTlv
	Value BsnBfdEndpointState
}

type IBsnTlvBfdState interface {
	IBsnTlv
	GetValue() BsnBfdEndpointState
}

func (self *BsnTlvBfdState) GetValue() BsnBfdEndpointState {
	return self.Value
}

func (self *BsnTlvBfdState) SetValue(v BsnBfdEndpointState) {
	self.Value = v
}

func (self *BsnTlvBfdState) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint8(uint8(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvBfdState(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvBfdState, error) {
	_bsntlvbfdstate := &BsnTlvBfdState{BsnTlv: parent}
	if decoder.Length() < 1 {
		return nil, fmt.Errorf("BsnTlvBfdState packet too short: %d < 1", decoder.Length())
	}
	_bsntlvbfdstate.Value = BsnBfdEndpointState(decoder.ReadByte())
	return _bsntlvbfdstate, nil
}

func NewBsnTlvBfdState() *BsnTlvBfdState {
	obj := &BsnTlvBfdState{
		BsnTlv: NewBsnTlv(177),
	}
	return obj
}

type BsnTlvBroadcastQueryTimeout struct {
	*BsnTlv
	Value uint32
}

type IBsnTlvBroadcastQueryTimeout interface {
	IBsnTlv
	GetValue() uint32
}

func (self *BsnTlvBroadcastQueryTimeout) GetValue() uint32 {
	return self.Value
}

func (self *BsnTlvBroadcastQueryTimeout) SetValue(v uint32) {
	self.Value = v
}

func (self *BsnTlvBroadcastQueryTimeout) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint32(uint32(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvBroadcastQueryTimeout(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvBroadcastQueryTimeout, error) {
	_bsntlvbroadcastquerytimeout := &BsnTlvBroadcastQueryTimeout{BsnTlv: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("BsnTlvBroadcastQueryTimeout packet too short: %d < 4", decoder.Length())
	}
	_bsntlvbroadcastquerytimeout.Value = uint32(decoder.ReadUint32())
	return _bsntlvbroadcastquerytimeout, nil
}

func NewBsnTlvBroadcastQueryTimeout() *BsnTlvBroadcastQueryTimeout {
	obj := &BsnTlvBroadcastQueryTimeout{
		BsnTlv: NewBsnTlv(10),
	}
	return obj
}

type BsnTlvBroadcastRate struct {
	*BsnTlv
	Value uint32
}

type IBsnTlvBroadcastRate interface {
	IBsnTlv
	GetValue() uint32
}

func (self *BsnTlvBroadcastRate) GetValue() uint32 {
	return self.Value
}

func (self *BsnTlvBroadcastRate) SetValue(v uint32) {
	self.Value = v
}

func (self *BsnTlvBroadcastRate) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint32(uint32(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvBroadcastRate(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvBroadcastRate, error) {
	_bsntlvbroadcastrate := &BsnTlvBroadcastRate{BsnTlv: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("BsnTlvBroadcastRate packet too short: %d < 4", decoder.Length())
	}
	_bsntlvbroadcastrate.Value = uint32(decoder.ReadUint32())
	return _bsntlvbroadcastrate, nil
}

func NewBsnTlvBroadcastRate() *BsnTlvBroadcastRate {
	obj := &BsnTlvBroadcastRate{
		BsnTlv: NewBsnTlv(90),
	}
	return obj
}

type BsnTlvBucket struct {
	*BsnTlv
	Value []IBsnTlv
}

type IBsnTlvBucket interface {
	IBsnTlv
	GetValue() []IBsnTlv
}

func (self *BsnTlvBucket) GetValue() []IBsnTlv {
	return self.Value
}

func (self *BsnTlvBucket) SetValue(v []IBsnTlv) {
	self.Value = v
}

func (self *BsnTlvBucket) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	for _, obj := range self.Value {
		if err := obj.Serialize(encoder); err != nil {
			return err
		}
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvBucket(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvBucket, error) {
	_bsntlvbucket := &BsnTlvBucket{BsnTlv: parent}

	for decoder.Length() >= 4 {
		item, err := DecodeBsnTlv(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_bsntlvbucket.Value = append(_bsntlvbucket.Value, item)
		}
	}
	return _bsntlvbucket, nil
}

func NewBsnTlvBucket() *BsnTlvBucket {
	obj := &BsnTlvBucket{
		BsnTlv: NewBsnTlv(64),
	}
	return obj
}

type BsnTlvCircuitId struct {
	*BsnTlv
	Value []byte
}

type IBsnTlvCircuitId interface {
	IBsnTlv
	GetValue() []byte
}

func (self *BsnTlvCircuitId) GetValue() []byte {
	return self.Value
}

func (self *BsnTlvCircuitId) SetValue(v []byte) {
	self.Value = v
}

func (self *BsnTlvCircuitId) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.Write(self.Value)
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvCircuitId(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvCircuitId, error) {
	_bsntlvcircuitid := &BsnTlvCircuitId{BsnTlv: parent}
	_bsntlvcircuitid.Value = decoder.Read(int(decoder.Length()))
	return _bsntlvcircuitid, nil
}

func NewBsnTlvCircuitId() *BsnTlvCircuitId {
	obj := &BsnTlvCircuitId{
		BsnTlv: NewBsnTlv(14),
	}
	return obj
}

type BsnTlvConvergenceStatus struct {
	*BsnTlv
	Value uint8
}

type IBsnTlvConvergenceStatus interface {
	IBsnTlv
	GetValue() uint8
}

func (self *BsnTlvConvergenceStatus) GetValue() uint8 {
	return self.Value
}

func (self *BsnTlvConvergenceStatus) SetValue(v uint8) {
	self.Value = v
}

func (self *BsnTlvConvergenceStatus) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint8(uint8(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvConvergenceStatus(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvConvergenceStatus, error) {
	_bsntlvconvergencestatus := &BsnTlvConvergenceStatus{BsnTlv: parent}
	if decoder.Length() < 1 {
		return nil, fmt.Errorf("BsnTlvConvergenceStatus packet too short: %d < 1", decoder.Length())
	}
	_bsntlvconvergencestatus.Value = uint8(decoder.ReadByte())
	return _bsntlvconvergencestatus, nil
}

func NewBsnTlvConvergenceStatus() *BsnTlvConvergenceStatus {
	obj := &BsnTlvConvergenceStatus{
		BsnTlv: NewBsnTlv(45),
	}
	return obj
}

type BsnTlvCpuLag struct {
	*BsnTlv
}

type IBsnTlvCpuLag interface {
	IBsnTlv
}

func (self *BsnTlvCpuLag) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvCpuLag(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvCpuLag, error) {
	_bsntlvcpulag := &BsnTlvCpuLag{BsnTlv: parent}
	return _bsntlvcpulag, nil
}

func NewBsnTlvCpuLag() *BsnTlvCpuLag {
	obj := &BsnTlvCpuLag{
		BsnTlv: NewBsnTlv(118),
	}
	return obj
}

type BsnTlvCrcEnabled struct {
	*BsnTlv
	Value uint8
}

type IBsnTlvCrcEnabled interface {
	IBsnTlv
	GetValue() uint8
}

func (self *BsnTlvCrcEnabled) GetValue() uint8 {
	return self.Value
}

func (self *BsnTlvCrcEnabled) SetValue(v uint8) {
	self.Value = v
}

func (self *BsnTlvCrcEnabled) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint8(uint8(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvCrcEnabled(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvCrcEnabled, error) {
	_bsntlvcrcenabled := &BsnTlvCrcEnabled{BsnTlv: parent}
	if decoder.Length() < 1 {
		return nil, fmt.Errorf("BsnTlvCrcEnabled packet too short: %d < 1", decoder.Length())
	}
	_bsntlvcrcenabled.Value = uint8(decoder.ReadByte())
	return _bsntlvcrcenabled, nil
}

func NewBsnTlvCrcEnabled() *BsnTlvCrcEnabled {
	obj := &BsnTlvCrcEnabled{
		BsnTlv: NewBsnTlv(22),
	}
	return obj
}

type BsnTlvData struct {
	*BsnTlv
	Value []byte
}

type IBsnTlvData interface {
	IBsnTlv
	GetValue() []byte
}

func (self *BsnTlvData) GetValue() []byte {
	return self.Value
}

func (self *BsnTlvData) SetValue(v []byte) {
	self.Value = v
}

func (self *BsnTlvData) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.Write(self.Value)
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvData(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvData, error) {
	_bsntlvdata := &BsnTlvData{BsnTlv: parent}
	_bsntlvdata.Value = decoder.Read(int(decoder.Length()))
	return _bsntlvdata, nil
}

func NewBsnTlvData() *BsnTlvData {
	obj := &BsnTlvData{
		BsnTlv: NewBsnTlv(55),
	}
	return obj
}

type BsnTlvDataMask struct {
	*BsnTlv
	Value []byte
}

type IBsnTlvDataMask interface {
	IBsnTlv
	GetValue() []byte
}

func (self *BsnTlvDataMask) GetValue() []byte {
	return self.Value
}

func (self *BsnTlvDataMask) SetValue(v []byte) {
	self.Value = v
}

func (self *BsnTlvDataMask) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.Write(self.Value)
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvDataMask(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvDataMask, error) {
	_bsntlvdatamask := &BsnTlvDataMask{BsnTlv: parent}
	_bsntlvdatamask.Value = decoder.Read(int(decoder.Length()))
	return _bsntlvdatamask, nil
}

func NewBsnTlvDataMask() *BsnTlvDataMask {
	obj := &BsnTlvDataMask{
		BsnTlv: NewBsnTlv(140),
	}
	return obj
}

type BsnTlvDecap struct {
	*BsnTlv
	Value BsnDecap
}

type IBsnTlvDecap interface {
	IBsnTlv
	GetValue() BsnDecap
}

func (self *BsnTlvDecap) GetValue() BsnDecap {
	return self.Value
}

func (self *BsnTlvDecap) SetValue(v BsnDecap) {
	self.Value = v
}

func (self *BsnTlvDecap) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint16(uint16(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvDecap(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvDecap, error) {
	_bsntlvdecap := &BsnTlvDecap{BsnTlv: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("BsnTlvDecap packet too short: %d < 2", decoder.Length())
	}
	_bsntlvdecap.Value = BsnDecap(decoder.ReadUint16())
	return _bsntlvdecap, nil
}

func NewBsnTlvDecap() *BsnTlvDecap {
	obj := &BsnTlvDecap{
		BsnTlv: NewBsnTlv(85),
	}
	return obj
}

type BsnTlvDisableSrcMacCheck struct {
	*BsnTlv
}

type IBsnTlvDisableSrcMacCheck interface {
	IBsnTlv
}

func (self *BsnTlvDisableSrcMacCheck) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvDisableSrcMacCheck(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvDisableSrcMacCheck, error) {
	_bsntlvdisablesrcmaccheck := &BsnTlvDisableSrcMacCheck{BsnTlv: parent}
	return _bsntlvdisablesrcmaccheck, nil
}

func NewBsnTlvDisableSrcMacCheck() *BsnTlvDisableSrcMacCheck {
	obj := &BsnTlvDisableSrcMacCheck{
		BsnTlv: NewBsnTlv(120),
	}
	return obj
}

type BsnTlvDisableXmit struct {
	*BsnTlv
}

type IBsnTlvDisableXmit interface {
	IBsnTlv
}

func (self *BsnTlvDisableXmit) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvDisableXmit(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvDisableXmit, error) {
	_bsntlvdisablexmit := &BsnTlvDisableXmit{BsnTlv: parent}
	return _bsntlvdisablexmit, nil
}

func NewBsnTlvDisableXmit() *BsnTlvDisableXmit {
	obj := &BsnTlvDisableXmit{
		BsnTlv: NewBsnTlv(185),
	}
	return obj
}

type BsnTlvDnsAnalytics struct {
	*BsnTlv
}

type IBsnTlvDnsAnalytics interface {
	IBsnTlv
}

func (self *BsnTlvDnsAnalytics) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvDnsAnalytics(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvDnsAnalytics, error) {
	_bsntlvdnsanalytics := &BsnTlvDnsAnalytics{BsnTlv: parent}
	return _bsntlvdnsanalytics, nil
}

func NewBsnTlvDnsAnalytics() *BsnTlvDnsAnalytics {
	obj := &BsnTlvDnsAnalytics{
		BsnTlv: NewBsnTlv(190),
	}
	return obj
}

type BsnTlvDrop struct {
	*BsnTlv
}

type IBsnTlvDrop interface {
	IBsnTlv
}

func (self *BsnTlvDrop) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvDrop(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvDrop, error) {
	_bsntlvdrop := &BsnTlvDrop{BsnTlv: parent}
	return _bsntlvdrop, nil
}

func NewBsnTlvDrop() *BsnTlvDrop {
	obj := &BsnTlvDrop{
		BsnTlv: NewBsnTlv(121),
	}
	return obj
}

type BsnTlvDropControl struct {
	*BsnTlv
}

type IBsnTlvDropControl interface {
	IBsnTlv
}

func (self *BsnTlvDropControl) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvDropControl(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvDropControl, error) {
	_bsntlvdropcontrol := &BsnTlvDropControl{BsnTlv: parent}
	return _bsntlvdropcontrol, nil
}

func NewBsnTlvDropControl() *BsnTlvDropControl {
	obj := &BsnTlvDropControl{
		BsnTlv: NewBsnTlv(187),
	}
	return obj
}

type BsnTlvDscp struct {
	*BsnTlv
	Value uint16
}

type IBsnTlvDscp interface {
	IBsnTlv
	GetValue() uint16
}

func (self *BsnTlvDscp) GetValue() uint16 {
	return self.Value
}

func (self *BsnTlvDscp) SetValue(v uint16) {
	self.Value = v
}

func (self *BsnTlvDscp) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint16(uint16(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvDscp(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvDscp, error) {
	_bsntlvdscp := &BsnTlvDscp{BsnTlv: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("BsnTlvDscp packet too short: %d < 2", decoder.Length())
	}
	_bsntlvdscp.Value = uint16(decoder.ReadUint16())
	return _bsntlvdscp, nil
}

func NewBsnTlvDscp() *BsnTlvDscp {
	obj := &BsnTlvDscp{
		BsnTlv: NewBsnTlv(112),
	}
	return obj
}

type BsnTlvEcn struct {
	*BsnTlv
	Value uint8
}

type IBsnTlvEcn interface {
	IBsnTlv
	GetValue() uint8
}

func (self *BsnTlvEcn) GetValue() uint8 {
	return self.Value
}

func (self *BsnTlvEcn) SetValue(v uint8) {
	self.Value = v
}

func (self *BsnTlvEcn) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint8(uint8(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvEcn(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvEcn, error) {
	_bsntlvecn := &BsnTlvEcn{BsnTlv: parent}
	if decoder.Length() < 1 {
		return nil, fmt.Errorf("BsnTlvEcn packet too short: %d < 1", decoder.Length())
	}
	_bsntlvecn.Value = uint8(decoder.ReadByte())
	return _bsntlvecn, nil
}

func NewBsnTlvEcn() *BsnTlvEcn {
	obj := &BsnTlvEcn{
		BsnTlv: NewBsnTlv(132),
	}
	return obj
}

type BsnTlvEgressOnly struct {
	*BsnTlv
}

type IBsnTlvEgressOnly interface {
	IBsnTlv
}

func (self *BsnTlvEgressOnly) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvEgressOnly(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvEgressOnly, error) {
	_bsntlvegressonly := &BsnTlvEgressOnly{BsnTlv: parent}
	return _bsntlvegressonly, nil
}

func NewBsnTlvEgressOnly() *BsnTlvEgressOnly {
	obj := &BsnTlvEgressOnly{
		BsnTlv: NewBsnTlv(137),
	}
	return obj
}

type BsnTlvEgressPortGroupId struct {
	*BsnTlv
	Value uint32
}

type IBsnTlvEgressPortGroupId interface {
	IBsnTlv
	GetValue() uint32
}

func (self *BsnTlvEgressPortGroupId) GetValue() uint32 {
	return self.Value
}

func (self *BsnTlvEgressPortGroupId) SetValue(v uint32) {
	self.Value = v
}

func (self *BsnTlvEgressPortGroupId) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint32(uint32(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvEgressPortGroupId(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvEgressPortGroupId, error) {
	_bsntlvegressportgroupid := &BsnTlvEgressPortGroupId{BsnTlv: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("BsnTlvEgressPortGroupId packet too short: %d < 4", decoder.Length())
	}
	_bsntlvegressportgroupid.Value = uint32(decoder.ReadUint32())
	return _bsntlvegressportgroupid, nil
}

func NewBsnTlvEgressPortGroupId() *BsnTlvEgressPortGroupId {
	obj := &BsnTlvEgressPortGroupId{
		BsnTlv: NewBsnTlv(139),
	}
	return obj
}

type BsnTlvEgressSamplingRate struct {
	*BsnTlv
	Value uint32
}

type IBsnTlvEgressSamplingRate interface {
	IBsnTlv
	GetValue() uint32
}

func (self *BsnTlvEgressSamplingRate) GetValue() uint32 {
	return self.Value
}

func (self *BsnTlvEgressSamplingRate) SetValue(v uint32) {
	self.Value = v
}

func (self *BsnTlvEgressSamplingRate) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint32(uint32(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvEgressSamplingRate(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvEgressSamplingRate, error) {
	_bsntlvegresssamplingrate := &BsnTlvEgressSamplingRate{BsnTlv: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("BsnTlvEgressSamplingRate packet too short: %d < 4", decoder.Length())
	}
	_bsntlvegresssamplingrate.Value = uint32(decoder.ReadUint32())
	return _bsntlvegresssamplingrate, nil
}

func NewBsnTlvEgressSamplingRate() *BsnTlvEgressSamplingRate {
	obj := &BsnTlvEgressSamplingRate{
		BsnTlv: NewBsnTlv(195),
	}
	return obj
}

type BsnTlvEncap struct {
	*BsnTlv
	Value BsnEncap
}

type IBsnTlvEncap interface {
	IBsnTlv
	GetValue() BsnEncap
}

func (self *BsnTlvEncap) GetValue() BsnEncap {
	return self.Value
}

func (self *BsnTlvEncap) SetValue(v BsnEncap) {
	self.Value = v
}

func (self *BsnTlvEncap) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint8(uint8(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvEncap(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvEncap, error) {
	_bsntlvencap := &BsnTlvEncap{BsnTlv: parent}
	if decoder.Length() < 1 {
		return nil, fmt.Errorf("BsnTlvEncap packet too short: %d < 1", decoder.Length())
	}
	_bsntlvencap.Value = BsnEncap(decoder.ReadByte())
	return _bsntlvencap, nil
}

func NewBsnTlvEncap() *BsnTlvEncap {
	obj := &BsnTlvEncap{
		BsnTlv: NewBsnTlv(175),
	}
	return obj
}

type BsnTlvEnhancedHashCapability struct {
	*BsnTlv
	Value BsnEnhancedHashType
}

type IBsnTlvEnhancedHashCapability interface {
	IBsnTlv
	GetValue() BsnEnhancedHashType
}

func (self *BsnTlvEnhancedHashCapability) GetValue() BsnEnhancedHashType {
	return self.Value
}

func (self *BsnTlvEnhancedHashCapability) SetValue(v BsnEnhancedHashType) {
	self.Value = v
}

func (self *BsnTlvEnhancedHashCapability) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint64(uint64(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvEnhancedHashCapability(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvEnhancedHashCapability, error) {
	_bsntlvenhancedhashcapability := &BsnTlvEnhancedHashCapability{BsnTlv: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("BsnTlvEnhancedHashCapability packet too short: %d < 8", decoder.Length())
	}
	_bsntlvenhancedhashcapability.Value = BsnEnhancedHashType(decoder.ReadUint64())
	return _bsntlvenhancedhashcapability, nil
}

func NewBsnTlvEnhancedHashCapability() *BsnTlvEnhancedHashCapability {
	obj := &BsnTlvEnhancedHashCapability{
		BsnTlv: NewBsnTlv(143),
	}
	return obj
}

type BsnTlvEthDst struct {
	*BsnTlv
	Value net.HardwareAddr
}

type IBsnTlvEthDst interface {
	IBsnTlv
	GetValue() net.HardwareAddr
}

func (self *BsnTlvEthDst) GetValue() net.HardwareAddr {
	return self.Value
}

func (self *BsnTlvEthDst) SetValue(v net.HardwareAddr) {
	self.Value = v
}

func (self *BsnTlvEthDst) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.Write(self.Value)
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvEthDst(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvEthDst, error) {
	_bsntlvethdst := &BsnTlvEthDst{BsnTlv: parent}
	if decoder.Length() < 6 {
		return nil, fmt.Errorf("BsnTlvEthDst packet too short: %d < 6", decoder.Length())
	}
	_bsntlvethdst.Value = net.HardwareAddr(decoder.Read(6))
	return _bsntlvethdst, nil
}

func NewBsnTlvEthDst() *BsnTlvEthDst {
	obj := &BsnTlvEthDst{
		BsnTlv: NewBsnTlv(33),
	}
	return obj
}

type BsnTlvEthSrc struct {
	*BsnTlv
	Value net.HardwareAddr
}

type IBsnTlvEthSrc interface {
	IBsnTlv
	GetValue() net.HardwareAddr
}

func (self *BsnTlvEthSrc) GetValue() net.HardwareAddr {
	return self.Value
}

func (self *BsnTlvEthSrc) SetValue(v net.HardwareAddr) {
	self.Value = v
}

func (self *BsnTlvEthSrc) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.Write(self.Value)
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvEthSrc(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvEthSrc, error) {
	_bsntlvethsrc := &BsnTlvEthSrc{BsnTlv: parent}
	if decoder.Length() < 6 {
		return nil, fmt.Errorf("BsnTlvEthSrc packet too short: %d < 6", decoder.Length())
	}
	_bsntlvethsrc.Value = net.HardwareAddr(decoder.Read(6))
	return _bsntlvethsrc, nil
}

func NewBsnTlvEthSrc() *BsnTlvEthSrc {
	obj := &BsnTlvEthSrc{
		BsnTlv: NewBsnTlv(32),
	}
	return obj
}

type BsnTlvEthType struct {
	*BsnTlv
	Value uint16
}

type IBsnTlvEthType interface {
	IBsnTlv
	GetValue() uint16
}

func (self *BsnTlvEthType) GetValue() uint16 {
	return self.Value
}

func (self *BsnTlvEthType) SetValue(v uint16) {
	self.Value = v
}

func (self *BsnTlvEthType) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint16(uint16(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvEthType(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvEthType, error) {
	_bsntlvethtype := &BsnTlvEthType{BsnTlv: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("BsnTlvEthType packet too short: %d < 2", decoder.Length())
	}
	_bsntlvethtype.Value = uint16(decoder.ReadUint16())
	return _bsntlvethtype, nil
}

func NewBsnTlvEthType() *BsnTlvEthType {
	obj := &BsnTlvEthType{
		BsnTlv: NewBsnTlv(131),
	}
	return obj
}

type BsnTlvExternalGatewayIp struct {
	*BsnTlv
	Value net.IP
}

type IBsnTlvExternalGatewayIp interface {
	IBsnTlv
	GetValue() net.IP
}

func (self *BsnTlvExternalGatewayIp) GetValue() net.IP {
	return self.Value
}

func (self *BsnTlvExternalGatewayIp) SetValue(v net.IP) {
	self.Value = v
}

func (self *BsnTlvExternalGatewayIp) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.Write(self.Value.To4())
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvExternalGatewayIp(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvExternalGatewayIp, error) {
	_bsntlvexternalgatewayip := &BsnTlvExternalGatewayIp{BsnTlv: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("BsnTlvExternalGatewayIp packet too short: %d < 4", decoder.Length())
	}
	_bsntlvexternalgatewayip.Value = net.IP(decoder.Read(4))
	return _bsntlvexternalgatewayip, nil
}

func NewBsnTlvExternalGatewayIp() *BsnTlvExternalGatewayIp {
	obj := &BsnTlvExternalGatewayIp{
		BsnTlv: NewBsnTlv(26),
	}
	return obj
}

type BsnTlvExternalGatewayMac struct {
	*BsnTlv
	Value net.HardwareAddr
}

type IBsnTlvExternalGatewayMac interface {
	IBsnTlv
	GetValue() net.HardwareAddr
}

func (self *BsnTlvExternalGatewayMac) GetValue() net.HardwareAddr {
	return self.Value
}

func (self *BsnTlvExternalGatewayMac) SetValue(v net.HardwareAddr) {
	self.Value = v
}

func (self *BsnTlvExternalGatewayMac) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.Write(self.Value)
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvExternalGatewayMac(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvExternalGatewayMac, error) {
	_bsntlvexternalgatewaymac := &BsnTlvExternalGatewayMac{BsnTlv: parent}
	if decoder.Length() < 6 {
		return nil, fmt.Errorf("BsnTlvExternalGatewayMac packet too short: %d < 6", decoder.Length())
	}
	_bsntlvexternalgatewaymac.Value = net.HardwareAddr(decoder.Read(6))
	return _bsntlvexternalgatewaymac, nil
}

func NewBsnTlvExternalGatewayMac() *BsnTlvExternalGatewayMac {
	obj := &BsnTlvExternalGatewayMac{
		BsnTlv: NewBsnTlv(29),
	}
	return obj
}

type BsnTlvExternalIp struct {
	*BsnTlv
	Value net.IP
}

type IBsnTlvExternalIp interface {
	IBsnTlv
	GetValue() net.IP
}

func (self *BsnTlvExternalIp) GetValue() net.IP {
	return self.Value
}

func (self *BsnTlvExternalIp) SetValue(v net.IP) {
	self.Value = v
}

func (self *BsnTlvExternalIp) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.Write(self.Value.To4())
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvExternalIp(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvExternalIp, error) {
	_bsntlvexternalip := &BsnTlvExternalIp{BsnTlv: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("BsnTlvExternalIp packet too short: %d < 4", decoder.Length())
	}
	_bsntlvexternalip.Value = net.IP(decoder.Read(4))
	return _bsntlvexternalip, nil
}

func NewBsnTlvExternalIp() *BsnTlvExternalIp {
	obj := &BsnTlvExternalIp{
		BsnTlv: NewBsnTlv(23),
	}
	return obj
}

type BsnTlvExternalMac struct {
	*BsnTlv
	Value net.HardwareAddr
}

type IBsnTlvExternalMac interface {
	IBsnTlv
	GetValue() net.HardwareAddr
}

func (self *BsnTlvExternalMac) GetValue() net.HardwareAddr {
	return self.Value
}

func (self *BsnTlvExternalMac) SetValue(v net.HardwareAddr) {
	self.Value = v
}

func (self *BsnTlvExternalMac) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.Write(self.Value)
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvExternalMac(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvExternalMac, error) {
	_bsntlvexternalmac := &BsnTlvExternalMac{BsnTlv: parent}
	if decoder.Length() < 6 {
		return nil, fmt.Errorf("BsnTlvExternalMac packet too short: %d < 6", decoder.Length())
	}
	_bsntlvexternalmac.Value = net.HardwareAddr(decoder.Read(6))
	return _bsntlvexternalmac, nil
}

func NewBsnTlvExternalMac() *BsnTlvExternalMac {
	obj := &BsnTlvExternalMac{
		BsnTlv: NewBsnTlv(24),
	}
	return obj
}

type BsnTlvExternalNetmask struct {
	*BsnTlv
	Value net.IP
}

type IBsnTlvExternalNetmask interface {
	IBsnTlv
	GetValue() net.IP
}

func (self *BsnTlvExternalNetmask) GetValue() net.IP {
	return self.Value
}

func (self *BsnTlvExternalNetmask) SetValue(v net.IP) {
	self.Value = v
}

func (self *BsnTlvExternalNetmask) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.Write(self.Value.To4())
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvExternalNetmask(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvExternalNetmask, error) {
	_bsntlvexternalnetmask := &BsnTlvExternalNetmask{BsnTlv: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("BsnTlvExternalNetmask packet too short: %d < 4", decoder.Length())
	}
	_bsntlvexternalnetmask.Value = net.IP(decoder.Read(4))
	return _bsntlvexternalnetmask, nil
}

func NewBsnTlvExternalNetmask() *BsnTlvExternalNetmask {
	obj := &BsnTlvExternalNetmask{
		BsnTlv: NewBsnTlv(25),
	}
	return obj
}

type BsnTlvFabricPortRole struct {
	*BsnTlv
	Value BsnFabricPortRole
}

type IBsnTlvFabricPortRole interface {
	IBsnTlv
	GetValue() BsnFabricPortRole
}

func (self *BsnTlvFabricPortRole) GetValue() BsnFabricPortRole {
	return self.Value
}

func (self *BsnTlvFabricPortRole) SetValue(v BsnFabricPortRole) {
	self.Value = v
}

func (self *BsnTlvFabricPortRole) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint16(uint16(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvFabricPortRole(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvFabricPortRole, error) {
	_bsntlvfabricportrole := &BsnTlvFabricPortRole{BsnTlv: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("BsnTlvFabricPortRole packet too short: %d < 2", decoder.Length())
	}
	_bsntlvfabricportrole.Value = BsnFabricPortRole(decoder.ReadUint16())
	return _bsntlvfabricportrole, nil
}

func NewBsnTlvFabricPortRole() *BsnTlvFabricPortRole {
	obj := &BsnTlvFabricPortRole{
		BsnTlv: NewBsnTlv(165),
	}
	return obj
}

type BsnTlvFailCount struct {
	*BsnTlv
	Value uint64
}

type IBsnTlvFailCount interface {
	IBsnTlv
	GetValue() uint64
}

func (self *BsnTlvFailCount) GetValue() uint64 {
	return self.Value
}

func (self *BsnTlvFailCount) SetValue(v uint64) {
	self.Value = v
}

func (self *BsnTlvFailCount) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint64(uint64(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvFailCount(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvFailCount, error) {
	_bsntlvfailcount := &BsnTlvFailCount{BsnTlv: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("BsnTlvFailCount packet too short: %d < 8", decoder.Length())
	}
	_bsntlvfailcount.Value = uint64(decoder.ReadUint64())
	return _bsntlvfailcount, nil
}

func NewBsnTlvFailCount() *BsnTlvFailCount {
	obj := &BsnTlvFailCount{
		BsnTlv: NewBsnTlv(194),
	}
	return obj
}

type BsnTlvFlood struct {
	*BsnTlv
}

type IBsnTlvFlood interface {
	IBsnTlv
}

func (self *BsnTlvFlood) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvFlood(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvFlood, error) {
	_bsntlvflood := &BsnTlvFlood{BsnTlv: parent}
	return _bsntlvflood, nil
}

func NewBsnTlvFlood() *BsnTlvFlood {
	obj := &BsnTlvFlood{
		BsnTlv: NewBsnTlv(163),
	}
	return obj
}

type BsnTlvFlowClassifier struct {
	*BsnTlv
	Value BsnFlowClassifier
}

type IBsnTlvFlowClassifier interface {
	IBsnTlv
	GetValue() BsnFlowClassifier
}

func (self *BsnTlvFlowClassifier) GetValue() BsnFlowClassifier {
	return self.Value
}

func (self *BsnTlvFlowClassifier) SetValue(v BsnFlowClassifier) {
	self.Value = v
}

func (self *BsnTlvFlowClassifier) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint16(uint16(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvFlowClassifier(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvFlowClassifier, error) {
	_bsntlvflowclassifier := &BsnTlvFlowClassifier{BsnTlv: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("BsnTlvFlowClassifier packet too short: %d < 2", decoder.Length())
	}
	_bsntlvflowclassifier.Value = BsnFlowClassifier(decoder.ReadUint16())
	return _bsntlvflowclassifier, nil
}

func NewBsnTlvFlowClassifier() *BsnTlvFlowClassifier {
	obj := &BsnTlvFlowClassifier{
		BsnTlv: NewBsnTlv(184),
	}
	return obj
}

type BsnTlvFlowClassify struct {
	*BsnTlv
}

type IBsnTlvFlowClassify interface {
	IBsnTlv
}

func (self *BsnTlvFlowClassify) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvFlowClassify(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvFlowClassify, error) {
	_bsntlvflowclassify := &BsnTlvFlowClassify{BsnTlv: parent}
	return _bsntlvflowclassify, nil
}

func NewBsnTlvFlowClassify() *BsnTlvFlowClassify {
	obj := &BsnTlvFlowClassify{
		BsnTlv: NewBsnTlv(182),
	}
	return obj
}

type BsnTlvFlowIdentifier struct {
	*BsnTlv
	Value uint32
}

type IBsnTlvFlowIdentifier interface {
	IBsnTlv
	GetValue() uint32
}

func (self *BsnTlvFlowIdentifier) GetValue() uint32 {
	return self.Value
}

func (self *BsnTlvFlowIdentifier) SetValue(v uint32) {
	self.Value = v
}

func (self *BsnTlvFlowIdentifier) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint32(uint32(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvFlowIdentifier(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvFlowIdentifier, error) {
	_bsntlvflowidentifier := &BsnTlvFlowIdentifier{BsnTlv: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("BsnTlvFlowIdentifier packet too short: %d < 4", decoder.Length())
	}
	_bsntlvflowidentifier.Value = uint32(decoder.ReadUint32())
	return _bsntlvflowidentifier, nil
}

func NewBsnTlvFlowIdentifier() *BsnTlvFlowIdentifier {
	obj := &BsnTlvFlowIdentifier{
		BsnTlv: NewBsnTlv(183),
	}
	return obj
}

type BsnTlvForceLinkUp struct {
	*BsnTlv
}

type IBsnTlvForceLinkUp interface {
	IBsnTlv
}

func (self *BsnTlvForceLinkUp) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvForceLinkUp(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvForceLinkUp, error) {
	_bsntlvforcelinkup := &BsnTlvForceLinkUp{BsnTlv: parent}
	return _bsntlvforcelinkup, nil
}

func NewBsnTlvForceLinkUp() *BsnTlvForceLinkUp {
	obj := &BsnTlvForceLinkUp{
		BsnTlv: NewBsnTlv(151),
	}
	return obj
}

type BsnTlvForwardErrorCorrection struct {
	*BsnTlv
	Value BsnForwardErrorCorrectionType
}

type IBsnTlvForwardErrorCorrection interface {
	IBsnTlv
	GetValue() BsnForwardErrorCorrectionType
}

func (self *BsnTlvForwardErrorCorrection) GetValue() BsnForwardErrorCorrectionType {
	return self.Value
}

func (self *BsnTlvForwardErrorCorrection) SetValue(v BsnForwardErrorCorrectionType) {
	self.Value = v
}

func (self *BsnTlvForwardErrorCorrection) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint8(uint8(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvForwardErrorCorrection(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvForwardErrorCorrection, error) {
	_bsntlvforwarderrorcorrection := &BsnTlvForwardErrorCorrection{BsnTlv: parent}
	if decoder.Length() < 1 {
		return nil, fmt.Errorf("BsnTlvForwardErrorCorrection packet too short: %d < 1", decoder.Length())
	}
	_bsntlvforwarderrorcorrection.Value = BsnForwardErrorCorrectionType(decoder.ReadByte())
	return _bsntlvforwarderrorcorrection, nil
}

func NewBsnTlvForwardErrorCorrection() *BsnTlvForwardErrorCorrection {
	obj := &BsnTlvForwardErrorCorrection{
		BsnTlv: NewBsnTlv(149),
	}
	return obj
}

type BsnTlvGenerationId struct {
	*BsnTlv
	Value uint64
}

type IBsnTlvGenerationId interface {
	IBsnTlv
	GetValue() uint64
}

func (self *BsnTlvGenerationId) GetValue() uint64 {
	return self.Value
}

func (self *BsnTlvGenerationId) SetValue(v uint64) {
	self.Value = v
}

func (self *BsnTlvGenerationId) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint64(uint64(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvGenerationId(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvGenerationId, error) {
	_bsntlvgenerationid := &BsnTlvGenerationId{BsnTlv: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("BsnTlvGenerationId packet too short: %d < 8", decoder.Length())
	}
	_bsntlvgenerationid.Value = uint64(decoder.ReadUint64())
	return _bsntlvgenerationid, nil
}

func NewBsnTlvGenerationId() *BsnTlvGenerationId {
	obj := &BsnTlvGenerationId{
		BsnTlv: NewBsnTlv(80),
	}
	return obj
}

type BsnTlvHashAlgorithm struct {
	*BsnTlv
	Value BsnHashAlgorithmType
}

type IBsnTlvHashAlgorithm interface {
	IBsnTlv
	GetValue() BsnHashAlgorithmType
}

func (self *BsnTlvHashAlgorithm) GetValue() BsnHashAlgorithmType {
	return self.Value
}

func (self *BsnTlvHashAlgorithm) SetValue(v BsnHashAlgorithmType) {
	self.Value = v
}

func (self *BsnTlvHashAlgorithm) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint16(uint16(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvHashAlgorithm(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvHashAlgorithm, error) {
	_bsntlvhashalgorithm := &BsnTlvHashAlgorithm{BsnTlv: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("BsnTlvHashAlgorithm packet too short: %d < 2", decoder.Length())
	}
	_bsntlvhashalgorithm.Value = BsnHashAlgorithmType(decoder.ReadUint16())
	return _bsntlvhashalgorithm, nil
}

func NewBsnTlvHashAlgorithm() *BsnTlvHashAlgorithm {
	obj := &BsnTlvHashAlgorithm{
		BsnTlv: NewBsnTlv(145),
	}
	return obj
}

type BsnTlvHashGtpHeaderMatch struct {
	*BsnTlv
	FirstHeaderByte uint8
	FirstHeaderMask uint8
}

type IBsnTlvHashGtpHeaderMatch interface {
	IBsnTlv
	GetFirstHeaderByte() uint8
	GetFirstHeaderMask() uint8
}

func (self *BsnTlvHashGtpHeaderMatch) GetFirstHeaderByte() uint8 {
	return self.FirstHeaderByte
}

func (self *BsnTlvHashGtpHeaderMatch) SetFirstHeaderByte(v uint8) {
	self.FirstHeaderByte = v
}

func (self *BsnTlvHashGtpHeaderMatch) GetFirstHeaderMask() uint8 {
	return self.FirstHeaderMask
}

func (self *BsnTlvHashGtpHeaderMatch) SetFirstHeaderMask(v uint8) {
	self.FirstHeaderMask = v
}

func (self *BsnTlvHashGtpHeaderMatch) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint8(uint8(self.FirstHeaderByte))
	encoder.PutUint8(uint8(self.FirstHeaderMask))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvHashGtpHeaderMatch(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvHashGtpHeaderMatch, error) {
	_bsntlvhashgtpheadermatch := &BsnTlvHashGtpHeaderMatch{BsnTlv: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("BsnTlvHashGtpHeaderMatch packet too short: %d < 2", decoder.Length())
	}
	_bsntlvhashgtpheadermatch.FirstHeaderByte = uint8(decoder.ReadByte())
	_bsntlvhashgtpheadermatch.FirstHeaderMask = uint8(decoder.ReadByte())
	return _bsntlvhashgtpheadermatch, nil
}

func NewBsnTlvHashGtpHeaderMatch() *BsnTlvHashGtpHeaderMatch {
	obj := &BsnTlvHashGtpHeaderMatch{
		BsnTlv: NewBsnTlv(104),
	}
	return obj
}

type BsnTlvHashGtpPortMatch struct {
	*BsnTlv
	Match   BsnHashGtpPortMatch
	SrcPort uint16
	DstPort uint16
}

type IBsnTlvHashGtpPortMatch interface {
	IBsnTlv
	GetMatch() BsnHashGtpPortMatch
	GetSrcPort() uint16
	GetDstPort() uint16
}

func (self *BsnTlvHashGtpPortMatch) GetMatch() BsnHashGtpPortMatch {
	return self.Match
}

func (self *BsnTlvHashGtpPortMatch) SetMatch(v BsnHashGtpPortMatch) {
	self.Match = v
}

func (self *BsnTlvHashGtpPortMatch) GetSrcPort() uint16 {
	return self.SrcPort
}

func (self *BsnTlvHashGtpPortMatch) SetSrcPort(v uint16) {
	self.SrcPort = v
}

func (self *BsnTlvHashGtpPortMatch) GetDstPort() uint16 {
	return self.DstPort
}

func (self *BsnTlvHashGtpPortMatch) SetDstPort(v uint16) {
	self.DstPort = v
}

func (self *BsnTlvHashGtpPortMatch) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint8(uint8(self.Match))
	encoder.PutUint16(uint16(self.SrcPort))
	encoder.PutUint16(uint16(self.DstPort))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvHashGtpPortMatch(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvHashGtpPortMatch, error) {
	_bsntlvhashgtpportmatch := &BsnTlvHashGtpPortMatch{BsnTlv: parent}
	if decoder.Length() < 5 {
		return nil, fmt.Errorf("BsnTlvHashGtpPortMatch packet too short: %d < 5", decoder.Length())
	}
	_bsntlvhashgtpportmatch.Match = BsnHashGtpPortMatch(decoder.ReadByte())
	_bsntlvhashgtpportmatch.SrcPort = uint16(decoder.ReadUint16())
	_bsntlvhashgtpportmatch.DstPort = uint16(decoder.ReadUint16())
	return _bsntlvhashgtpportmatch, nil
}

func NewBsnTlvHashGtpPortMatch() *BsnTlvHashGtpPortMatch {
	obj := &BsnTlvHashGtpPortMatch{
		BsnTlv: NewBsnTlv(105),
	}
	return obj
}

type BsnTlvHashPacketField struct {
	*BsnTlv
	Value BsnHashPacketField
}

type IBsnTlvHashPacketField interface {
	IBsnTlv
	GetValue() BsnHashPacketField
}

func (self *BsnTlvHashPacketField) GetValue() BsnHashPacketField {
	return self.Value
}

func (self *BsnTlvHashPacketField) SetValue(v BsnHashPacketField) {
	self.Value = v
}

func (self *BsnTlvHashPacketField) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint64(uint64(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvHashPacketField(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvHashPacketField, error) {
	_bsntlvhashpacketfield := &BsnTlvHashPacketField{BsnTlv: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("BsnTlvHashPacketField packet too short: %d < 8", decoder.Length())
	}
	_bsntlvhashpacketfield.Value = BsnHashPacketField(decoder.ReadUint64())
	return _bsntlvhashpacketfield, nil
}

func NewBsnTlvHashPacketField() *BsnTlvHashPacketField {
	obj := &BsnTlvHashPacketField{
		BsnTlv: NewBsnTlv(103),
	}
	return obj
}

type BsnTlvHashPacketType struct {
	*BsnTlv
	Value BsnHashPacketType
}

type IBsnTlvHashPacketType interface {
	IBsnTlv
	GetValue() BsnHashPacketType
}

func (self *BsnTlvHashPacketType) GetValue() BsnHashPacketType {
	return self.Value
}

func (self *BsnTlvHashPacketType) SetValue(v BsnHashPacketType) {
	self.Value = v
}

func (self *BsnTlvHashPacketType) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint8(uint8(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvHashPacketType(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvHashPacketType, error) {
	_bsntlvhashpackettype := &BsnTlvHashPacketType{BsnTlv: parent}
	if decoder.Length() < 1 {
		return nil, fmt.Errorf("BsnTlvHashPacketType packet too short: %d < 1", decoder.Length())
	}
	_bsntlvhashpackettype.Value = BsnHashPacketType(decoder.ReadByte())
	return _bsntlvhashpackettype, nil
}

func NewBsnTlvHashPacketType() *BsnTlvHashPacketType {
	obj := &BsnTlvHashPacketType{
		BsnTlv: NewBsnTlv(102),
	}
	return obj
}

type BsnTlvHashSeed struct {
	*BsnTlv
	Seed1 uint32
	Seed2 uint32
}

type IBsnTlvHashSeed interface {
	IBsnTlv
	GetSeed1() uint32
	GetSeed2() uint32
}

func (self *BsnTlvHashSeed) GetSeed1() uint32 {
	return self.Seed1
}

func (self *BsnTlvHashSeed) SetSeed1(v uint32) {
	self.Seed1 = v
}

func (self *BsnTlvHashSeed) GetSeed2() uint32 {
	return self.Seed2
}

func (self *BsnTlvHashSeed) SetSeed2(v uint32) {
	self.Seed2 = v
}

func (self *BsnTlvHashSeed) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint32(uint32(self.Seed1))
	encoder.PutUint32(uint32(self.Seed2))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvHashSeed(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvHashSeed, error) {
	_bsntlvhashseed := &BsnTlvHashSeed{BsnTlv: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("BsnTlvHashSeed packet too short: %d < 8", decoder.Length())
	}
	_bsntlvhashseed.Seed1 = uint32(decoder.ReadUint32())
	_bsntlvhashseed.Seed2 = uint32(decoder.ReadUint32())
	return _bsntlvhashseed, nil
}

func NewBsnTlvHashSeed() *BsnTlvHashSeed {
	obj := &BsnTlvHashSeed{
		BsnTlv: NewBsnTlv(100),
	}
	return obj
}

type BsnTlvHashType struct {
	*BsnTlv
	Value BsnHashType
}

type IBsnTlvHashType interface {
	IBsnTlv
	GetValue() BsnHashType
}

func (self *BsnTlvHashType) GetValue() BsnHashType {
	return self.Value
}

func (self *BsnTlvHashType) SetValue(v BsnHashType) {
	self.Value = v
}

func (self *BsnTlvHashType) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint8(uint8(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvHashType(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvHashType, error) {
	_bsntlvhashtype := &BsnTlvHashType{BsnTlv: parent}
	if decoder.Length() < 1 {
		return nil, fmt.Errorf("BsnTlvHashType packet too short: %d < 1", decoder.Length())
	}
	_bsntlvhashtype.Value = BsnHashType(decoder.ReadByte())
	return _bsntlvhashtype, nil
}

func NewBsnTlvHashType() *BsnTlvHashType {
	obj := &BsnTlvHashType{
		BsnTlv: NewBsnTlv(101),
	}
	return obj
}

type BsnTlvHeaderSize struct {
	*BsnTlv
	Value uint32
}

type IBsnTlvHeaderSize interface {
	IBsnTlv
	GetValue() uint32
}

func (self *BsnTlvHeaderSize) GetValue() uint32 {
	return self.Value
}

func (self *BsnTlvHeaderSize) SetValue(v uint32) {
	self.Value = v
}

func (self *BsnTlvHeaderSize) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint32(uint32(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvHeaderSize(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvHeaderSize, error) {
	_bsntlvheadersize := &BsnTlvHeaderSize{BsnTlv: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("BsnTlvHeaderSize packet too short: %d < 4", decoder.Length())
	}
	_bsntlvheadersize.Value = uint32(decoder.ReadUint32())
	return _bsntlvheadersize, nil
}

func NewBsnTlvHeaderSize() *BsnTlvHeaderSize {
	obj := &BsnTlvHeaderSize{
		BsnTlv: NewBsnTlv(31),
	}
	return obj
}

type BsnTlvIcmpCode struct {
	*BsnTlv
	Value uint8
}

type IBsnTlvIcmpCode interface {
	IBsnTlv
	GetValue() uint8
}

func (self *BsnTlvIcmpCode) GetValue() uint8 {
	return self.Value
}

func (self *BsnTlvIcmpCode) SetValue(v uint8) {
	self.Value = v
}

func (self *BsnTlvIcmpCode) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint8(uint8(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvIcmpCode(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIcmpCode, error) {
	_bsntlvicmpcode := &BsnTlvIcmpCode{BsnTlv: parent}
	if decoder.Length() < 1 {
		return nil, fmt.Errorf("BsnTlvIcmpCode packet too short: %d < 1", decoder.Length())
	}
	_bsntlvicmpcode.Value = uint8(decoder.ReadByte())
	return _bsntlvicmpcode, nil
}

func NewBsnTlvIcmpCode() *BsnTlvIcmpCode {
	obj := &BsnTlvIcmpCode{
		BsnTlv: NewBsnTlv(69),
	}
	return obj
}

type BsnTlvIcmpId struct {
	*BsnTlv
	Value uint16
}

type IBsnTlvIcmpId interface {
	IBsnTlv
	GetValue() uint16
}

func (self *BsnTlvIcmpId) GetValue() uint16 {
	return self.Value
}

func (self *BsnTlvIcmpId) SetValue(v uint16) {
	self.Value = v
}

func (self *BsnTlvIcmpId) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint16(uint16(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvIcmpId(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIcmpId, error) {
	_bsntlvicmpid := &BsnTlvIcmpId{BsnTlv: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("BsnTlvIcmpId packet too short: %d < 2", decoder.Length())
	}
	_bsntlvicmpid.Value = uint16(decoder.ReadUint16())
	return _bsntlvicmpid, nil
}

func NewBsnTlvIcmpId() *BsnTlvIcmpId {
	obj := &BsnTlvIcmpId{
		BsnTlv: NewBsnTlv(70),
	}
	return obj
}

type BsnTlvIcmpType struct {
	*BsnTlv
	Value uint8
}

type IBsnTlvIcmpType interface {
	IBsnTlv
	GetValue() uint8
}

func (self *BsnTlvIcmpType) GetValue() uint8 {
	return self.Value
}

func (self *BsnTlvIcmpType) SetValue(v uint8) {
	self.Value = v
}

func (self *BsnTlvIcmpType) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint8(uint8(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvIcmpType(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIcmpType, error) {
	_bsntlvicmptype := &BsnTlvIcmpType{BsnTlv: parent}
	if decoder.Length() < 1 {
		return nil, fmt.Errorf("BsnTlvIcmpType packet too short: %d < 1", decoder.Length())
	}
	_bsntlvicmptype.Value = uint8(decoder.ReadByte())
	return _bsntlvicmptype, nil
}

func NewBsnTlvIcmpType() *BsnTlvIcmpType {
	obj := &BsnTlvIcmpType{
		BsnTlv: NewBsnTlv(68),
	}
	return obj
}

type BsnTlvIcmpv6Chksum struct {
	*BsnTlv
	Value uint16
}

type IBsnTlvIcmpv6Chksum interface {
	IBsnTlv
	GetValue() uint16
}

func (self *BsnTlvIcmpv6Chksum) GetValue() uint16 {
	return self.Value
}

func (self *BsnTlvIcmpv6Chksum) SetValue(v uint16) {
	self.Value = v
}

func (self *BsnTlvIcmpv6Chksum) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint16(uint16(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvIcmpv6Chksum(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIcmpv6Chksum, error) {
	_bsntlvicmpv6chksum := &BsnTlvIcmpv6Chksum{BsnTlv: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("BsnTlvIcmpv6Chksum packet too short: %d < 2", decoder.Length())
	}
	_bsntlvicmpv6chksum.Value = uint16(decoder.ReadUint16())
	return _bsntlvicmpv6chksum, nil
}

func NewBsnTlvIcmpv6Chksum() *BsnTlvIcmpv6Chksum {
	obj := &BsnTlvIcmpv6Chksum{
		BsnTlv: NewBsnTlv(125),
	}
	return obj
}

type BsnTlvIdentifier struct {
	*BsnTlv
	Value uint32
}

type IBsnTlvIdentifier interface {
	IBsnTlv
	GetValue() uint32
}

func (self *BsnTlvIdentifier) GetValue() uint32 {
	return self.Value
}

func (self *BsnTlvIdentifier) SetValue(v uint32) {
	self.Value = v
}

func (self *BsnTlvIdentifier) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint32(uint32(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvIdentifier(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIdentifier, error) {
	_bsntlvidentifier := &BsnTlvIdentifier{BsnTlv: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("BsnTlvIdentifier packet too short: %d < 4", decoder.Length())
	}
	_bsntlvidentifier.Value = uint32(decoder.ReadUint32())
	return _bsntlvidentifier, nil
}

func NewBsnTlvIdentifier() *BsnTlvIdentifier {
	obj := &BsnTlvIdentifier{
		BsnTlv: NewBsnTlv(173),
	}
	return obj
}

type BsnTlvIdleNotification struct {
	*BsnTlv
}

type IBsnTlvIdleNotification interface {
	IBsnTlv
}

func (self *BsnTlvIdleNotification) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvIdleNotification(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIdleNotification, error) {
	_bsntlvidlenotification := &BsnTlvIdleNotification{BsnTlv: parent}
	return _bsntlvidlenotification, nil
}

func NewBsnTlvIdleNotification() *BsnTlvIdleNotification {
	obj := &BsnTlvIdleNotification{
		BsnTlv: NewBsnTlv(7),
	}
	return obj
}

type BsnTlvIdleTime struct {
	*BsnTlv
	Value uint64
}

type IBsnTlvIdleTime interface {
	IBsnTlv
	GetValue() uint64
}

func (self *BsnTlvIdleTime) GetValue() uint64 {
	return self.Value
}

func (self *BsnTlvIdleTime) SetValue(v uint64) {
	self.Value = v
}

func (self *BsnTlvIdleTime) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint64(uint64(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvIdleTime(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIdleTime, error) {
	_bsntlvidletime := &BsnTlvIdleTime{BsnTlv: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("BsnTlvIdleTime packet too short: %d < 8", decoder.Length())
	}
	_bsntlvidletime.Value = uint64(decoder.ReadUint64())
	return _bsntlvidletime, nil
}

func NewBsnTlvIdleTime() *BsnTlvIdleTime {
	obj := &BsnTlvIdleTime{
		BsnTlv: NewBsnTlv(5),
	}
	return obj
}

type BsnTlvIdleTimeout struct {
	*BsnTlv
	Value uint32
}

type IBsnTlvIdleTimeout interface {
	IBsnTlv
	GetValue() uint32
}

func (self *BsnTlvIdleTimeout) GetValue() uint32 {
	return self.Value
}

func (self *BsnTlvIdleTimeout) SetValue(v uint32) {
	self.Value = v
}

func (self *BsnTlvIdleTimeout) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint32(uint32(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvIdleTimeout(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIdleTimeout, error) {
	_bsntlvidletimeout := &BsnTlvIdleTimeout{BsnTlv: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("BsnTlvIdleTimeout packet too short: %d < 4", decoder.Length())
	}
	_bsntlvidletimeout.Value = uint32(decoder.ReadUint32())
	return _bsntlvidletimeout, nil
}

func NewBsnTlvIdleTimeout() *BsnTlvIdleTimeout {
	obj := &BsnTlvIdleTimeout{
		BsnTlv: NewBsnTlv(8),
	}
	return obj
}

type BsnTlvIgmpSnooping struct {
	*BsnTlv
}

type IBsnTlvIgmpSnooping interface {
	IBsnTlv
}

func (self *BsnTlvIgmpSnooping) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvIgmpSnooping(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIgmpSnooping, error) {
	_bsntlvigmpsnooping := &BsnTlvIgmpSnooping{BsnTlv: parent}
	return _bsntlvigmpsnooping, nil
}

func NewBsnTlvIgmpSnooping() *BsnTlvIgmpSnooping {
	obj := &BsnTlvIgmpSnooping{
		BsnTlv: NewBsnTlv(78),
	}
	return obj
}

type BsnTlvIngressPortGroupId struct {
	*BsnTlv
	Value uint32
}

type IBsnTlvIngressPortGroupId interface {
	IBsnTlv
	GetValue() uint32
}

func (self *BsnTlvIngressPortGroupId) GetValue() uint32 {
	return self.Value
}

func (self *BsnTlvIngressPortGroupId) SetValue(v uint32) {
	self.Value = v
}

func (self *BsnTlvIngressPortGroupId) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint32(uint32(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvIngressPortGroupId(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIngressPortGroupId, error) {
	_bsntlvingressportgroupid := &BsnTlvIngressPortGroupId{BsnTlv: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("BsnTlvIngressPortGroupId packet too short: %d < 4", decoder.Length())
	}
	_bsntlvingressportgroupid.Value = uint32(decoder.ReadUint32())
	return _bsntlvingressportgroupid, nil
}

func NewBsnTlvIngressPortGroupId() *BsnTlvIngressPortGroupId {
	obj := &BsnTlvIngressPortGroupId{
		BsnTlv: NewBsnTlv(138),
	}
	return obj
}

type BsnTlvInternalGatewayMac struct {
	*BsnTlv
	Value net.HardwareAddr
}

type IBsnTlvInternalGatewayMac interface {
	IBsnTlv
	GetValue() net.HardwareAddr
}

func (self *BsnTlvInternalGatewayMac) GetValue() net.HardwareAddr {
	return self.Value
}

func (self *BsnTlvInternalGatewayMac) SetValue(v net.HardwareAddr) {
	self.Value = v
}

func (self *BsnTlvInternalGatewayMac) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.Write(self.Value)
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvInternalGatewayMac(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvInternalGatewayMac, error) {
	_bsntlvinternalgatewaymac := &BsnTlvInternalGatewayMac{BsnTlv: parent}
	if decoder.Length() < 6 {
		return nil, fmt.Errorf("BsnTlvInternalGatewayMac packet too short: %d < 6", decoder.Length())
	}
	_bsntlvinternalgatewaymac.Value = net.HardwareAddr(decoder.Read(6))
	return _bsntlvinternalgatewaymac, nil
}

func NewBsnTlvInternalGatewayMac() *BsnTlvInternalGatewayMac {
	obj := &BsnTlvInternalGatewayMac{
		BsnTlv: NewBsnTlv(28),
	}
	return obj
}

type BsnTlvInternalMac struct {
	*BsnTlv
	Value net.HardwareAddr
}

type IBsnTlvInternalMac interface {
	IBsnTlv
	GetValue() net.HardwareAddr
}

func (self *BsnTlvInternalMac) GetValue() net.HardwareAddr {
	return self.Value
}

func (self *BsnTlvInternalMac) SetValue(v net.HardwareAddr) {
	self.Value = v
}

func (self *BsnTlvInternalMac) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.Write(self.Value)
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvInternalMac(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvInternalMac, error) {
	_bsntlvinternalmac := &BsnTlvInternalMac{BsnTlv: parent}
	if decoder.Length() < 6 {
		return nil, fmt.Errorf("BsnTlvInternalMac packet too short: %d < 6", decoder.Length())
	}
	_bsntlvinternalmac.Value = net.HardwareAddr(decoder.Read(6))
	return _bsntlvinternalmac, nil
}

func NewBsnTlvInternalMac() *BsnTlvInternalMac {
	obj := &BsnTlvInternalMac{
		BsnTlv: NewBsnTlv(27),
	}
	return obj
}

type BsnTlvInterval struct {
	*BsnTlv
	Value uint32
}

type IBsnTlvInterval interface {
	IBsnTlv
	GetValue() uint32
}

func (self *BsnTlvInterval) GetValue() uint32 {
	return self.Value
}

func (self *BsnTlvInterval) SetValue(v uint32) {
	self.Value = v
}

func (self *BsnTlvInterval) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint32(uint32(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvInterval(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvInterval, error) {
	_bsntlvinterval := &BsnTlvInterval{BsnTlv: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("BsnTlvInterval packet too short: %d < 4", decoder.Length())
	}
	_bsntlvinterval.Value = uint32(decoder.ReadUint32())
	return _bsntlvinterval, nil
}

func NewBsnTlvInterval() *BsnTlvInterval {
	obj := &BsnTlvInterval{
		BsnTlv: NewBsnTlv(58),
	}
	return obj
}

type BsnTlvIpProto struct {
	*BsnTlv
	Value uint8
}

type IBsnTlvIpProto interface {
	IBsnTlv
	GetValue() uint8
}

func (self *BsnTlvIpProto) GetValue() uint8 {
	return self.Value
}

func (self *BsnTlvIpProto) SetValue(v uint8) {
	self.Value = v
}

func (self *BsnTlvIpProto) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint8(uint8(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvIpProto(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIpProto, error) {
	_bsntlvipproto := &BsnTlvIpProto{BsnTlv: parent}
	if decoder.Length() < 1 {
		return nil, fmt.Errorf("BsnTlvIpProto packet too short: %d < 1", decoder.Length())
	}
	_bsntlvipproto.Value = uint8(decoder.ReadByte())
	return _bsntlvipproto, nil
}

func NewBsnTlvIpProto() *BsnTlvIpProto {
	obj := &BsnTlvIpProto{
		BsnTlv: NewBsnTlv(67),
	}
	return obj
}

type BsnTlvIpTunnelType struct {
	*BsnTlv
	Value BsnIpTunnelType
}

type IBsnTlvIpTunnelType interface {
	IBsnTlv
	GetValue() BsnIpTunnelType
}

func (self *BsnTlvIpTunnelType) GetValue() BsnIpTunnelType {
	return self.Value
}

func (self *BsnTlvIpTunnelType) SetValue(v BsnIpTunnelType) {
	self.Value = v
}

func (self *BsnTlvIpTunnelType) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint16(uint16(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvIpTunnelType(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIpTunnelType, error) {
	_bsntlviptunneltype := &BsnTlvIpTunnelType{BsnTlv: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("BsnTlvIpTunnelType packet too short: %d < 2", decoder.Length())
	}
	_bsntlviptunneltype.Value = BsnIpTunnelType(decoder.ReadUint16())
	return _bsntlviptunneltype, nil
}

func NewBsnTlvIpTunnelType() *BsnTlvIpTunnelType {
	obj := &BsnTlvIpTunnelType{
		BsnTlv: NewBsnTlv(169),
	}
	return obj
}

type BsnTlvIpv4 struct {
	*BsnTlv
	Value net.IP
}

type IBsnTlvIpv4 interface {
	IBsnTlv
	GetValue() net.IP
}

func (self *BsnTlvIpv4) GetValue() net.IP {
	return self.Value
}

func (self *BsnTlvIpv4) SetValue(v net.IP) {
	self.Value = v
}

func (self *BsnTlvIpv4) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.Write(self.Value.To4())
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvIpv4(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIpv4, error) {
	_bsntlvipv4 := &BsnTlvIpv4{BsnTlv: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("BsnTlvIpv4 packet too short: %d < 4", decoder.Length())
	}
	_bsntlvipv4.Value = net.IP(decoder.Read(4))
	return _bsntlvipv4, nil
}

func NewBsnTlvIpv4() *BsnTlvIpv4 {
	obj := &BsnTlvIpv4{
		BsnTlv: NewBsnTlv(4),
	}
	return obj
}

type BsnTlvIpv4Dst struct {
	*BsnTlv
	Value net.IP
}

type IBsnTlvIpv4Dst interface {
	IBsnTlv
	GetValue() net.IP
}

func (self *BsnTlvIpv4Dst) GetValue() net.IP {
	return self.Value
}

func (self *BsnTlvIpv4Dst) SetValue(v net.IP) {
	self.Value = v
}

func (self *BsnTlvIpv4Dst) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.Write(self.Value.To4())
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvIpv4Dst(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIpv4Dst, error) {
	_bsntlvipv4dst := &BsnTlvIpv4Dst{BsnTlv: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("BsnTlvIpv4Dst packet too short: %d < 4", decoder.Length())
	}
	_bsntlvipv4dst.Value = net.IP(decoder.Read(4))
	return _bsntlvipv4dst, nil
}

func NewBsnTlvIpv4Dst() *BsnTlvIpv4Dst {
	obj := &BsnTlvIpv4Dst{
		BsnTlv: NewBsnTlv(35),
	}
	return obj
}

type BsnTlvIpv4Netmask struct {
	*BsnTlv
	Value net.IP
}

type IBsnTlvIpv4Netmask interface {
	IBsnTlv
	GetValue() net.IP
}

func (self *BsnTlvIpv4Netmask) GetValue() net.IP {
	return self.Value
}

func (self *BsnTlvIpv4Netmask) SetValue(v net.IP) {
	self.Value = v
}

func (self *BsnTlvIpv4Netmask) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.Write(self.Value.To4())
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvIpv4Netmask(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIpv4Netmask, error) {
	_bsntlvipv4netmask := &BsnTlvIpv4Netmask{BsnTlv: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("BsnTlvIpv4Netmask packet too short: %d < 4", decoder.Length())
	}
	_bsntlvipv4netmask.Value = net.IP(decoder.Read(4))
	return _bsntlvipv4netmask, nil
}

func NewBsnTlvIpv4Netmask() *BsnTlvIpv4Netmask {
	obj := &BsnTlvIpv4Netmask{
		BsnTlv: NewBsnTlv(60),
	}
	return obj
}

type BsnTlvIpv4Src struct {
	*BsnTlv
	Value net.IP
}

type IBsnTlvIpv4Src interface {
	IBsnTlv
	GetValue() net.IP
}

func (self *BsnTlvIpv4Src) GetValue() net.IP {
	return self.Value
}

func (self *BsnTlvIpv4Src) SetValue(v net.IP) {
	self.Value = v
}

func (self *BsnTlvIpv4Src) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.Write(self.Value.To4())
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvIpv4Src(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIpv4Src, error) {
	_bsntlvipv4src := &BsnTlvIpv4Src{BsnTlv: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("BsnTlvIpv4Src packet too short: %d < 4", decoder.Length())
	}
	_bsntlvipv4src.Value = net.IP(decoder.Read(4))
	return _bsntlvipv4src, nil
}

func NewBsnTlvIpv4Src() *BsnTlvIpv4Src {
	obj := &BsnTlvIpv4Src{
		BsnTlv: NewBsnTlv(34),
	}
	return obj
}

type BsnTlvIpv6 struct {
	*BsnTlv
	Value net.IP
}

type IBsnTlvIpv6 interface {
	IBsnTlv
	GetValue() net.IP
}

func (self *BsnTlvIpv6) GetValue() net.IP {
	return self.Value
}

func (self *BsnTlvIpv6) SetValue(v net.IP) {
	self.Value = v
}

func (self *BsnTlvIpv6) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.Write(self.Value.To16())
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvIpv6(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIpv6, error) {
	_bsntlvipv6 := &BsnTlvIpv6{BsnTlv: parent}
	if decoder.Length() < 16 {
		return nil, fmt.Errorf("BsnTlvIpv6 packet too short: %d < 16", decoder.Length())
	}
	_bsntlvipv6.Value = net.IP(decoder.Read(16))
	return _bsntlvipv6, nil
}

func NewBsnTlvIpv6() *BsnTlvIpv6 {
	obj := &BsnTlvIpv6{
		BsnTlv: NewBsnTlv(84),
	}
	return obj
}

type BsnTlvIpv6Dst struct {
	*BsnTlv
	Value net.IP
}

type IBsnTlvIpv6Dst interface {
	IBsnTlv
	GetValue() net.IP
}

func (self *BsnTlvIpv6Dst) GetValue() net.IP {
	return self.Value
}

func (self *BsnTlvIpv6Dst) SetValue(v net.IP) {
	self.Value = v
}

func (self *BsnTlvIpv6Dst) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.Write(self.Value.To16())
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvIpv6Dst(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIpv6Dst, error) {
	_bsntlvipv6dst := &BsnTlvIpv6Dst{BsnTlv: parent}
	if decoder.Length() < 16 {
		return nil, fmt.Errorf("BsnTlvIpv6Dst packet too short: %d < 16", decoder.Length())
	}
	_bsntlvipv6dst.Value = net.IP(decoder.Read(16))
	return _bsntlvipv6dst, nil
}

func NewBsnTlvIpv6Dst() *BsnTlvIpv6Dst {
	obj := &BsnTlvIpv6Dst{
		BsnTlv: NewBsnTlv(127),
	}
	return obj
}

type BsnTlvIpv6Prefix struct {
	*BsnTlv
	Value        net.IP
	PrefixLength uint8
}

type IBsnTlvIpv6Prefix interface {
	IBsnTlv
	GetValue() net.IP
	GetPrefixLength() uint8
}

func (self *BsnTlvIpv6Prefix) GetValue() net.IP {
	return self.Value
}

func (self *BsnTlvIpv6Prefix) SetValue(v net.IP) {
	self.Value = v
}

func (self *BsnTlvIpv6Prefix) GetPrefixLength() uint8 {
	return self.PrefixLength
}

func (self *BsnTlvIpv6Prefix) SetPrefixLength(v uint8) {
	self.PrefixLength = v
}

func (self *BsnTlvIpv6Prefix) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.Write(self.Value.To16())
	encoder.PutUint8(uint8(self.PrefixLength))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvIpv6Prefix(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIpv6Prefix, error) {
	_bsntlvipv6prefix := &BsnTlvIpv6Prefix{BsnTlv: parent}
	if decoder.Length() < 17 {
		return nil, fmt.Errorf("BsnTlvIpv6Prefix packet too short: %d < 17", decoder.Length())
	}
	_bsntlvipv6prefix.Value = net.IP(decoder.Read(16))
	_bsntlvipv6prefix.PrefixLength = uint8(decoder.ReadByte())
	return _bsntlvipv6prefix, nil
}

func NewBsnTlvIpv6Prefix() *BsnTlvIpv6Prefix {
	obj := &BsnTlvIpv6Prefix{
		BsnTlv: NewBsnTlv(122),
	}
	return obj
}

type BsnTlvIpv6Src struct {
	*BsnTlv
	Value net.IP
}

type IBsnTlvIpv6Src interface {
	IBsnTlv
	GetValue() net.IP
}

func (self *BsnTlvIpv6Src) GetValue() net.IP {
	return self.Value
}

func (self *BsnTlvIpv6Src) SetValue(v net.IP) {
	self.Value = v
}

func (self *BsnTlvIpv6Src) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.Write(self.Value.To16())
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvIpv6Src(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIpv6Src, error) {
	_bsntlvipv6src := &BsnTlvIpv6Src{BsnTlv: parent}
	if decoder.Length() < 16 {
		return nil, fmt.Errorf("BsnTlvIpv6Src packet too short: %d < 16", decoder.Length())
	}
	_bsntlvipv6src.Value = net.IP(decoder.Read(16))
	return _bsntlvipv6src, nil
}

func NewBsnTlvIpv6Src() *BsnTlvIpv6Src {
	obj := &BsnTlvIpv6Src{
		BsnTlv: NewBsnTlv(126),
	}
	return obj
}

type BsnTlvKnownMulticastRate struct {
	*BsnTlv
	Value uint32
}

type IBsnTlvKnownMulticastRate interface {
	IBsnTlv
	GetValue() uint32
}

func (self *BsnTlvKnownMulticastRate) GetValue() uint32 {
	return self.Value
}

func (self *BsnTlvKnownMulticastRate) SetValue(v uint32) {
	self.Value = v
}

func (self *BsnTlvKnownMulticastRate) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint32(uint32(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvKnownMulticastRate(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvKnownMulticastRate, error) {
	_bsntlvknownmulticastrate := &BsnTlvKnownMulticastRate{BsnTlv: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("BsnTlvKnownMulticastRate packet too short: %d < 4", decoder.Length())
	}
	_bsntlvknownmulticastrate.Value = uint32(decoder.ReadUint32())
	return _bsntlvknownmulticastrate, nil
}

func NewBsnTlvKnownMulticastRate() *BsnTlvKnownMulticastRate {
	obj := &BsnTlvKnownMulticastRate{
		BsnTlv: NewBsnTlv(91),
	}
	return obj
}

type BsnTlvL2MulticastLookup struct {
	*BsnTlv
}

type IBsnTlvL2MulticastLookup interface {
	IBsnTlv
}

func (self *BsnTlvL2MulticastLookup) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvL2MulticastLookup(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvL2MulticastLookup, error) {
	_bsntlvl2multicastlookup := &BsnTlvL2MulticastLookup{BsnTlv: parent}
	return _bsntlvl2multicastlookup, nil
}

func NewBsnTlvL2MulticastLookup() *BsnTlvL2MulticastLookup {
	obj := &BsnTlvL2MulticastLookup{
		BsnTlv: NewBsnTlv(79),
	}
	return obj
}

type BsnTlvL3 struct {
	*BsnTlv
}

type IBsnTlvL3 interface {
	IBsnTlv
}

func (self *BsnTlvL3) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvL3(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvL3, error) {
	_bsntlvl3 := &BsnTlvL3{BsnTlv: parent}
	return _bsntlvl3, nil
}

func NewBsnTlvL3() *BsnTlvL3 {
	obj := &BsnTlvL3{
		BsnTlv: NewBsnTlv(168),
	}
	return obj
}

type BsnTlvL3DstClassId struct {
	*BsnTlv
	Value uint32
}

type IBsnTlvL3DstClassId interface {
	IBsnTlv
	GetValue() uint32
}

func (self *BsnTlvL3DstClassId) GetValue() uint32 {
	return self.Value
}

func (self *BsnTlvL3DstClassId) SetValue(v uint32) {
	self.Value = v
}

func (self *BsnTlvL3DstClassId) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint32(uint32(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvL3DstClassId(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvL3DstClassId, error) {
	_bsntlvl3dstclassid := &BsnTlvL3DstClassId{BsnTlv: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("BsnTlvL3DstClassId packet too short: %d < 4", decoder.Length())
	}
	_bsntlvl3dstclassid.Value = uint32(decoder.ReadUint32())
	return _bsntlvl3dstclassid, nil
}

func NewBsnTlvL3DstClassId() *BsnTlvL3DstClassId {
	obj := &BsnTlvL3DstClassId{
		BsnTlv: NewBsnTlv(136),
	}
	return obj
}

type BsnTlvL3InterfaceClassId struct {
	*BsnTlv
	Value uint32
}

type IBsnTlvL3InterfaceClassId interface {
	IBsnTlv
	GetValue() uint32
}

func (self *BsnTlvL3InterfaceClassId) GetValue() uint32 {
	return self.Value
}

func (self *BsnTlvL3InterfaceClassId) SetValue(v uint32) {
	self.Value = v
}

func (self *BsnTlvL3InterfaceClassId) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint32(uint32(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvL3InterfaceClassId(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvL3InterfaceClassId, error) {
	_bsntlvl3interfaceclassid := &BsnTlvL3InterfaceClassId{BsnTlv: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("BsnTlvL3InterfaceClassId packet too short: %d < 4", decoder.Length())
	}
	_bsntlvl3interfaceclassid.Value = uint32(decoder.ReadUint32())
	return _bsntlvl3interfaceclassid, nil
}

func NewBsnTlvL3InterfaceClassId() *BsnTlvL3InterfaceClassId {
	obj := &BsnTlvL3InterfaceClassId{
		BsnTlv: NewBsnTlv(134),
	}
	return obj
}

type BsnTlvL3SrcClassId struct {
	*BsnTlv
	Value uint32
}

type IBsnTlvL3SrcClassId interface {
	IBsnTlv
	GetValue() uint32
}

func (self *BsnTlvL3SrcClassId) GetValue() uint32 {
	return self.Value
}

func (self *BsnTlvL3SrcClassId) SetValue(v uint32) {
	self.Value = v
}

func (self *BsnTlvL3SrcClassId) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint32(uint32(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvL3SrcClassId(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvL3SrcClassId, error) {
	_bsntlvl3srcclassid := &BsnTlvL3SrcClassId{BsnTlv: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("BsnTlvL3SrcClassId packet too short: %d < 4", decoder.Length())
	}
	_bsntlvl3srcclassid.Value = uint32(decoder.ReadUint32())
	return _bsntlvl3srcclassid, nil
}

func NewBsnTlvL3SrcClassId() *BsnTlvL3SrcClassId {
	obj := &BsnTlvL3SrcClassId{
		BsnTlv: NewBsnTlv(135),
	}
	return obj
}

type BsnTlvLagOptions struct {
	*BsnTlv
	Flags BsnLagFlag
}

type IBsnTlvLagOptions interface {
	IBsnTlv
	GetFlags() BsnLagFlag
}

func (self *BsnTlvLagOptions) GetFlags() BsnLagFlag {
	return self.Flags
}

func (self *BsnTlvLagOptions) SetFlags(v BsnLagFlag) {
	self.Flags = v
}

func (self *BsnTlvLagOptions) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint16(uint16(self.Flags))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvLagOptions(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvLagOptions, error) {
	_bsntlvlagoptions := &BsnTlvLagOptions{BsnTlv: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("BsnTlvLagOptions packet too short: %d < 2", decoder.Length())
	}
	_bsntlvlagoptions.Flags = BsnLagFlag(decoder.ReadUint16())
	return _bsntlvlagoptions, nil
}

func NewBsnTlvLagOptions() *BsnTlvLagOptions {
	obj := &BsnTlvLagOptions{
		BsnTlv: NewBsnTlv(160),
	}
	return obj
}

type BsnTlvLinkUp struct {
	*BsnTlv
}

type IBsnTlvLinkUp interface {
	IBsnTlv
}

func (self *BsnTlvLinkUp) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvLinkUp(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvLinkUp, error) {
	_bsntlvlinkup := &BsnTlvLinkUp{BsnTlv: parent}
	return _bsntlvlinkup, nil
}

func NewBsnTlvLinkUp() *BsnTlvLinkUp {
	obj := &BsnTlvLinkUp{
		BsnTlv: NewBsnTlv(193),
	}
	return obj
}

type BsnTlvLoopbackMode struct {
	*BsnTlv
	Value BsnLoopbackMode
}

type IBsnTlvLoopbackMode interface {
	IBsnTlv
	GetValue() BsnLoopbackMode
}

func (self *BsnTlvLoopbackMode) GetValue() BsnLoopbackMode {
	return self.Value
}

func (self *BsnTlvLoopbackMode) SetValue(v BsnLoopbackMode) {
	self.Value = v
}

func (self *BsnTlvLoopbackMode) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint8(uint8(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvLoopbackMode(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvLoopbackMode, error) {
	_bsntlvloopbackmode := &BsnTlvLoopbackMode{BsnTlv: parent}
	if decoder.Length() < 1 {
		return nil, fmt.Errorf("BsnTlvLoopbackMode packet too short: %d < 1", decoder.Length())
	}
	_bsntlvloopbackmode.Value = BsnLoopbackMode(decoder.ReadByte())
	return _bsntlvloopbackmode, nil
}

func NewBsnTlvLoopbackMode() *BsnTlvLoopbackMode {
	obj := &BsnTlvLoopbackMode{
		BsnTlv: NewBsnTlv(146),
	}
	return obj
}

type BsnTlvLoopbackPort struct {
	*BsnTlv
	Value Port
}

type IBsnTlvLoopbackPort interface {
	IBsnTlv
	GetValue() Port
}

func (self *BsnTlvLoopbackPort) GetValue() Port {
	return self.Value
}

func (self *BsnTlvLoopbackPort) SetValue(v Port) {
	self.Value = v
}

func (self *BsnTlvLoopbackPort) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	self.Value.Serialize(encoder)
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvLoopbackPort(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvLoopbackPort, error) {
	_bsntlvloopbackport := &BsnTlvLoopbackPort{BsnTlv: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("BsnTlvLoopbackPort packet too short: %d < 4", decoder.Length())
	}
	_bsntlvloopbackport.Value.Decode(decoder)
	return _bsntlvloopbackport, nil
}

func NewBsnTlvLoopbackPort() *BsnTlvLoopbackPort {
	obj := &BsnTlvLoopbackPort{
		BsnTlv: NewBsnTlv(110),
	}
	return obj
}

type BsnTlvLossless struct {
	*BsnTlv
}

type IBsnTlvLossless interface {
	IBsnTlv
}

func (self *BsnTlvLossless) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvLossless(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvLossless, error) {
	_bsntlvlossless := &BsnTlvLossless{BsnTlv: parent}
	return _bsntlvlossless, nil
}

func NewBsnTlvLossless() *BsnTlvLossless {
	obj := &BsnTlvLossless{
		BsnTlv: NewBsnTlv(188),
	}
	return obj
}

type BsnTlvLrAllEnabled struct {
	*BsnTlv
}

type IBsnTlvLrAllEnabled interface {
	IBsnTlv
}

func (self *BsnTlvLrAllEnabled) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvLrAllEnabled(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvLrAllEnabled, error) {
	_bsntlvlrallenabled := &BsnTlvLrAllEnabled{BsnTlv: parent}
	return _bsntlvlrallenabled, nil
}

func NewBsnTlvLrAllEnabled() *BsnTlvLrAllEnabled {
	obj := &BsnTlvLrAllEnabled{
		BsnTlv: NewBsnTlv(178),
	}
	return obj
}

type BsnTlvMac struct {
	*BsnTlv
	Value net.HardwareAddr
}

type IBsnTlvMac interface {
	IBsnTlv
	GetValue() net.HardwareAddr
}

func (self *BsnTlvMac) GetValue() net.HardwareAddr {
	return self.Value
}

func (self *BsnTlvMac) SetValue(v net.HardwareAddr) {
	self.Value = v
}

func (self *BsnTlvMac) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.Write(self.Value)
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvMac(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvMac, error) {
	_bsntlvmac := &BsnTlvMac{BsnTlv: parent}
	if decoder.Length() < 6 {
		return nil, fmt.Errorf("BsnTlvMac packet too short: %d < 6", decoder.Length())
	}
	_bsntlvmac.Value = net.HardwareAddr(decoder.Read(6))
	return _bsntlvmac, nil
}

func NewBsnTlvMac() *BsnTlvMac {
	obj := &BsnTlvMac{
		BsnTlv: NewBsnTlv(1),
	}
	return obj
}

type BsnTlvMacMask struct {
	*BsnTlv
	Value net.HardwareAddr
}

type IBsnTlvMacMask interface {
	IBsnTlv
	GetValue() net.HardwareAddr
}

func (self *BsnTlvMacMask) GetValue() net.HardwareAddr {
	return self.Value
}

func (self *BsnTlvMacMask) SetValue(v net.HardwareAddr) {
	self.Value = v
}

func (self *BsnTlvMacMask) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.Write(self.Value)
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvMacMask(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvMacMask, error) {
	_bsntlvmacmask := &BsnTlvMacMask{BsnTlv: parent}
	if decoder.Length() < 6 {
		return nil, fmt.Errorf("BsnTlvMacMask packet too short: %d < 6", decoder.Length())
	}
	_bsntlvmacmask.Value = net.HardwareAddr(decoder.Read(6))
	return _bsntlvmacmask, nil
}

func NewBsnTlvMacMask() *BsnTlvMacMask {
	obj := &BsnTlvMacMask{
		BsnTlv: NewBsnTlv(56),
	}
	return obj
}

type BsnTlvMcgTypeVxlan struct {
	*BsnTlv
}

type IBsnTlvMcgTypeVxlan interface {
	IBsnTlv
}

func (self *BsnTlvMcgTypeVxlan) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvMcgTypeVxlan(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvMcgTypeVxlan, error) {
	_bsntlvmcgtypevxlan := &BsnTlvMcgTypeVxlan{BsnTlv: parent}
	return _bsntlvmcgtypevxlan, nil
}

func NewBsnTlvMcgTypeVxlan() *BsnTlvMcgTypeVxlan {
	obj := &BsnTlvMcgTypeVxlan{
		BsnTlv: NewBsnTlv(87),
	}
	return obj
}

type BsnTlvMissPackets struct {
	*BsnTlv
	Value uint64
}

type IBsnTlvMissPackets interface {
	IBsnTlv
	GetValue() uint64
}

func (self *BsnTlvMissPackets) GetValue() uint64 {
	return self.Value
}

func (self *BsnTlvMissPackets) SetValue(v uint64) {
	self.Value = v
}

func (self *BsnTlvMissPackets) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint64(uint64(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvMissPackets(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvMissPackets, error) {
	_bsntlvmisspackets := &BsnTlvMissPackets{BsnTlv: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("BsnTlvMissPackets packet too short: %d < 8", decoder.Length())
	}
	_bsntlvmisspackets.Value = uint64(decoder.ReadUint64())
	return _bsntlvmisspackets, nil
}

func NewBsnTlvMissPackets() *BsnTlvMissPackets {
	obj := &BsnTlvMissPackets{
		BsnTlv: NewBsnTlv(13),
	}
	return obj
}

type BsnTlvMplsControlWord struct {
	*BsnTlv
	Value uint8
}

type IBsnTlvMplsControlWord interface {
	IBsnTlv
	GetValue() uint8
}

func (self *BsnTlvMplsControlWord) GetValue() uint8 {
	return self.Value
}

func (self *BsnTlvMplsControlWord) SetValue(v uint8) {
	self.Value = v
}

func (self *BsnTlvMplsControlWord) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint8(uint8(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvMplsControlWord(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvMplsControlWord, error) {
	_bsntlvmplscontrolword := &BsnTlvMplsControlWord{BsnTlv: parent}
	if decoder.Length() < 1 {
		return nil, fmt.Errorf("BsnTlvMplsControlWord packet too short: %d < 1", decoder.Length())
	}
	_bsntlvmplscontrolword.Value = uint8(decoder.ReadByte())
	return _bsntlvmplscontrolword, nil
}

func NewBsnTlvMplsControlWord() *BsnTlvMplsControlWord {
	obj := &BsnTlvMplsControlWord{
		BsnTlv: NewBsnTlv(62),
	}
	return obj
}

type BsnTlvMplsLabel struct {
	*BsnTlv
	Value uint32
}

type IBsnTlvMplsLabel interface {
	IBsnTlv
	GetValue() uint32
}

func (self *BsnTlvMplsLabel) GetValue() uint32 {
	return self.Value
}

func (self *BsnTlvMplsLabel) SetValue(v uint32) {
	self.Value = v
}

func (self *BsnTlvMplsLabel) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint32(uint32(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvMplsLabel(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvMplsLabel, error) {
	_bsntlvmplslabel := &BsnTlvMplsLabel{BsnTlv: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("BsnTlvMplsLabel packet too short: %d < 4", decoder.Length())
	}
	_bsntlvmplslabel.Value = uint32(decoder.ReadUint32())
	return _bsntlvmplslabel, nil
}

func NewBsnTlvMplsLabel() *BsnTlvMplsLabel {
	obj := &BsnTlvMplsLabel{
		BsnTlv: NewBsnTlv(61),
	}
	return obj
}

type BsnTlvMplsSequenced struct {
	*BsnTlv
	Value uint8
}

type IBsnTlvMplsSequenced interface {
	IBsnTlv
	GetValue() uint8
}

func (self *BsnTlvMplsSequenced) GetValue() uint8 {
	return self.Value
}

func (self *BsnTlvMplsSequenced) SetValue(v uint8) {
	self.Value = v
}

func (self *BsnTlvMplsSequenced) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint8(uint8(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvMplsSequenced(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvMplsSequenced, error) {
	_bsntlvmplssequenced := &BsnTlvMplsSequenced{BsnTlv: parent}
	if decoder.Length() < 1 {
		return nil, fmt.Errorf("BsnTlvMplsSequenced packet too short: %d < 1", decoder.Length())
	}
	_bsntlvmplssequenced.Value = uint8(decoder.ReadByte())
	return _bsntlvmplssequenced, nil
}

func NewBsnTlvMplsSequenced() *BsnTlvMplsSequenced {
	obj := &BsnTlvMplsSequenced{
		BsnTlv: NewBsnTlv(63),
	}
	return obj
}

type BsnTlvMulticastInterfaceId struct {
	*BsnTlv
	Value uint32
}

type IBsnTlvMulticastInterfaceId interface {
	IBsnTlv
	GetValue() uint32
}

func (self *BsnTlvMulticastInterfaceId) GetValue() uint32 {
	return self.Value
}

func (self *BsnTlvMulticastInterfaceId) SetValue(v uint32) {
	self.Value = v
}

func (self *BsnTlvMulticastInterfaceId) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint32(uint32(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvMulticastInterfaceId(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvMulticastInterfaceId, error) {
	_bsntlvmulticastinterfaceid := &BsnTlvMulticastInterfaceId{BsnTlv: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("BsnTlvMulticastInterfaceId packet too short: %d < 4", decoder.Length())
	}
	_bsntlvmulticastinterfaceid.Value = uint32(decoder.ReadUint32())
	return _bsntlvmulticastinterfaceid, nil
}

func NewBsnTlvMulticastInterfaceId() *BsnTlvMulticastInterfaceId {
	obj := &BsnTlvMulticastInterfaceId{
		BsnTlv: NewBsnTlv(95),
	}
	return obj
}

type BsnTlvMulticastPacket struct {
	*BsnTlv
	Value BsnMulticastPacket
}

type IBsnTlvMulticastPacket interface {
	IBsnTlv
	GetValue() BsnMulticastPacket
}

func (self *BsnTlvMulticastPacket) GetValue() BsnMulticastPacket {
	return self.Value
}

func (self *BsnTlvMulticastPacket) SetValue(v BsnMulticastPacket) {
	self.Value = v
}

func (self *BsnTlvMulticastPacket) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint16(uint16(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvMulticastPacket(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvMulticastPacket, error) {
	_bsntlvmulticastpacket := &BsnTlvMulticastPacket{BsnTlv: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("BsnTlvMulticastPacket packet too short: %d < 2", decoder.Length())
	}
	_bsntlvmulticastpacket.Value = BsnMulticastPacket(decoder.ReadUint16())
	return _bsntlvmulticastpacket, nil
}

func NewBsnTlvMulticastPacket() *BsnTlvMulticastPacket {
	obj := &BsnTlvMulticastPacket{
		BsnTlv: NewBsnTlv(170),
	}
	return obj
}

type BsnTlvMultiplier struct {
	*BsnTlv
	Value uint32
}

type IBsnTlvMultiplier interface {
	IBsnTlv
	GetValue() uint32
}

func (self *BsnTlvMultiplier) GetValue() uint32 {
	return self.Value
}

func (self *BsnTlvMultiplier) SetValue(v uint32) {
	self.Value = v
}

func (self *BsnTlvMultiplier) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint32(uint32(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvMultiplier(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvMultiplier, error) {
	_bsntlvmultiplier := &BsnTlvMultiplier{BsnTlv: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("BsnTlvMultiplier packet too short: %d < 4", decoder.Length())
	}
	_bsntlvmultiplier.Value = uint32(decoder.ReadUint32())
	return _bsntlvmultiplier, nil
}

func NewBsnTlvMultiplier() *BsnTlvMultiplier {
	obj := &BsnTlvMultiplier{
		BsnTlv: NewBsnTlv(174),
	}
	return obj
}

type BsnTlvName struct {
	*BsnTlv
	Value []byte
}

type IBsnTlvName interface {
	IBsnTlv
	GetValue() []byte
}

func (self *BsnTlvName) GetValue() []byte {
	return self.Value
}

func (self *BsnTlvName) SetValue(v []byte) {
	self.Value = v
}

func (self *BsnTlvName) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.Write(self.Value)
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvName(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvName, error) {
	_bsntlvname := &BsnTlvName{BsnTlv: parent}
	_bsntlvname.Value = decoder.Read(int(decoder.Length()))
	return _bsntlvname, nil
}

func NewBsnTlvName() *BsnTlvName {
	obj := &BsnTlvName{
		BsnTlv: NewBsnTlv(52),
	}
	return obj
}

type BsnTlvNdpOffload struct {
	*BsnTlv
}

type IBsnTlvNdpOffload interface {
	IBsnTlv
}

func (self *BsnTlvNdpOffload) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvNdpOffload(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvNdpOffload, error) {
	_bsntlvndpoffload := &BsnTlvNdpOffload{BsnTlv: parent}
	return _bsntlvndpoffload, nil
}

func NewBsnTlvNdpOffload() *BsnTlvNdpOffload {
	obj := &BsnTlvNdpOffload{
		BsnTlv: NewBsnTlv(123),
	}
	return obj
}

type BsnTlvNdpStatic struct {
	*BsnTlv
}

type IBsnTlvNdpStatic interface {
	IBsnTlv
}

func (self *BsnTlvNdpStatic) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvNdpStatic(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvNdpStatic, error) {
	_bsntlvndpstatic := &BsnTlvNdpStatic{BsnTlv: parent}
	return _bsntlvndpstatic, nil
}

func NewBsnTlvNdpStatic() *BsnTlvNdpStatic {
	obj := &BsnTlvNdpStatic{
		BsnTlv: NewBsnTlv(124),
	}
	return obj
}

type BsnTlvNegate struct {
	*BsnTlv
}

type IBsnTlvNegate interface {
	IBsnTlv
}

func (self *BsnTlvNegate) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvNegate(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvNegate, error) {
	_bsntlvnegate := &BsnTlvNegate{BsnTlv: parent}
	return _bsntlvnegate, nil
}

func NewBsnTlvNegate() *BsnTlvNegate {
	obj := &BsnTlvNegate{
		BsnTlv: NewBsnTlv(83),
	}
	return obj
}

type BsnTlvNextHopIpv4 struct {
	*BsnTlv
	Value net.IP
}

type IBsnTlvNextHopIpv4 interface {
	IBsnTlv
	GetValue() net.IP
}

func (self *BsnTlvNextHopIpv4) GetValue() net.IP {
	return self.Value
}

func (self *BsnTlvNextHopIpv4) SetValue(v net.IP) {
	self.Value = v
}

func (self *BsnTlvNextHopIpv4) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.Write(self.Value.To4())
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvNextHopIpv4(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvNextHopIpv4, error) {
	_bsntlvnexthopipv4 := &BsnTlvNextHopIpv4{BsnTlv: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("BsnTlvNextHopIpv4 packet too short: %d < 4", decoder.Length())
	}
	_bsntlvnexthopipv4.Value = net.IP(decoder.Read(4))
	return _bsntlvnexthopipv4, nil
}

func NewBsnTlvNextHopIpv4() *BsnTlvNextHopIpv4 {
	obj := &BsnTlvNextHopIpv4{
		BsnTlv: NewBsnTlv(115),
	}
	return obj
}

type BsnTlvNextHopMac struct {
	*BsnTlv
	Value net.HardwareAddr
}

type IBsnTlvNextHopMac interface {
	IBsnTlv
	GetValue() net.HardwareAddr
}

func (self *BsnTlvNextHopMac) GetValue() net.HardwareAddr {
	return self.Value
}

func (self *BsnTlvNextHopMac) SetValue(v net.HardwareAddr) {
	self.Value = v
}

func (self *BsnTlvNextHopMac) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.Write(self.Value)
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvNextHopMac(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvNextHopMac, error) {
	_bsntlvnexthopmac := &BsnTlvNextHopMac{BsnTlv: parent}
	if decoder.Length() < 6 {
		return nil, fmt.Errorf("BsnTlvNextHopMac packet too short: %d < 6", decoder.Length())
	}
	_bsntlvnexthopmac.Value = net.HardwareAddr(decoder.Read(6))
	return _bsntlvnexthopmac, nil
}

func NewBsnTlvNextHopMac() *BsnTlvNextHopMac {
	obj := &BsnTlvNextHopMac{
		BsnTlv: NewBsnTlv(114),
	}
	return obj
}

type BsnTlvNexthopTypeVxlan struct {
	*BsnTlv
}

type IBsnTlvNexthopTypeVxlan interface {
	IBsnTlv
}

func (self *BsnTlvNexthopTypeVxlan) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvNexthopTypeVxlan(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvNexthopTypeVxlan, error) {
	_bsntlvnexthoptypevxlan := &BsnTlvNexthopTypeVxlan{BsnTlv: parent}
	return _bsntlvnexthoptypevxlan, nil
}

func NewBsnTlvNexthopTypeVxlan() *BsnTlvNexthopTypeVxlan {
	obj := &BsnTlvNexthopTypeVxlan{
		BsnTlv: NewBsnTlv(94),
	}
	return obj
}

type BsnTlvNoArpResponse struct {
	*BsnTlv
}

type IBsnTlvNoArpResponse interface {
	IBsnTlv
}

func (self *BsnTlvNoArpResponse) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvNoArpResponse(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvNoArpResponse, error) {
	_bsntlvnoarpresponse := &BsnTlvNoArpResponse{BsnTlv: parent}
	return _bsntlvnoarpresponse, nil
}

func NewBsnTlvNoArpResponse() *BsnTlvNoArpResponse {
	obj := &BsnTlvNoArpResponse{
		BsnTlv: NewBsnTlv(147),
	}
	return obj
}

type BsnTlvNoNsResponse struct {
	*BsnTlv
}

type IBsnTlvNoNsResponse interface {
	IBsnTlv
}

func (self *BsnTlvNoNsResponse) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvNoNsResponse(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvNoNsResponse, error) {
	_bsntlvnonsresponse := &BsnTlvNoNsResponse{BsnTlv: parent}
	return _bsntlvnonsresponse, nil
}

func NewBsnTlvNoNsResponse() *BsnTlvNoNsResponse {
	obj := &BsnTlvNoNsResponse{
		BsnTlv: NewBsnTlv(148),
	}
	return obj
}

type BsnTlvOffset struct {
	*BsnTlv
	Value uint16
}

type IBsnTlvOffset interface {
	IBsnTlv
	GetValue() uint16
}

func (self *BsnTlvOffset) GetValue() uint16 {
	return self.Value
}

func (self *BsnTlvOffset) SetValue(v uint16) {
	self.Value = v
}

func (self *BsnTlvOffset) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint16(uint16(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvOffset(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvOffset, error) {
	_bsntlvoffset := &BsnTlvOffset{BsnTlv: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("BsnTlvOffset packet too short: %d < 2", decoder.Length())
	}
	_bsntlvoffset.Value = uint16(decoder.ReadUint16())
	return _bsntlvoffset, nil
}

func NewBsnTlvOffset() *BsnTlvOffset {
	obj := &BsnTlvOffset{
		BsnTlv: NewBsnTlv(82),
	}
	return obj
}

type BsnTlvOpticsAlwaysEnabled struct {
	*BsnTlv
}

type IBsnTlvOpticsAlwaysEnabled interface {
	IBsnTlv
}

func (self *BsnTlvOpticsAlwaysEnabled) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvOpticsAlwaysEnabled(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvOpticsAlwaysEnabled, error) {
	_bsntlvopticsalwaysenabled := &BsnTlvOpticsAlwaysEnabled{BsnTlv: parent}
	return _bsntlvopticsalwaysenabled, nil
}

func NewBsnTlvOpticsAlwaysEnabled() *BsnTlvOpticsAlwaysEnabled {
	obj := &BsnTlvOpticsAlwaysEnabled{
		BsnTlv: NewBsnTlv(150),
	}
	return obj
}

type BsnTlvOuterSrcMac struct {
	*BsnTlv
	Value net.HardwareAddr
}

type IBsnTlvOuterSrcMac interface {
	IBsnTlv
	GetValue() net.HardwareAddr
}

func (self *BsnTlvOuterSrcMac) GetValue() net.HardwareAddr {
	return self.Value
}

func (self *BsnTlvOuterSrcMac) SetValue(v net.HardwareAddr) {
	self.Value = v
}

func (self *BsnTlvOuterSrcMac) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.Write(self.Value)
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvOuterSrcMac(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvOuterSrcMac, error) {
	_bsntlvoutersrcmac := &BsnTlvOuterSrcMac{BsnTlv: parent}
	if decoder.Length() < 6 {
		return nil, fmt.Errorf("BsnTlvOuterSrcMac packet too short: %d < 6", decoder.Length())
	}
	_bsntlvoutersrcmac.Value = net.HardwareAddr(decoder.Read(6))
	return _bsntlvoutersrcmac, nil
}

func NewBsnTlvOuterSrcMac() *BsnTlvOuterSrcMac {
	obj := &BsnTlvOuterSrcMac{
		BsnTlv: NewBsnTlv(157),
	}
	return obj
}

type BsnTlvParentPort struct {
	*BsnTlv
	Value Port
}

type IBsnTlvParentPort interface {
	IBsnTlv
	GetValue() Port
}

func (self *BsnTlvParentPort) GetValue() Port {
	return self.Value
}

func (self *BsnTlvParentPort) SetValue(v Port) {
	self.Value = v
}

func (self *BsnTlvParentPort) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	self.Value.Serialize(encoder)
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvParentPort(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvParentPort, error) {
	_bsntlvparentport := &BsnTlvParentPort{BsnTlv: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("BsnTlvParentPort packet too short: %d < 4", decoder.Length())
	}
	_bsntlvparentport.Value.Decode(decoder)
	return _bsntlvparentport, nil
}

func NewBsnTlvParentPort() *BsnTlvParentPort {
	obj := &BsnTlvParentPort{
		BsnTlv: NewBsnTlv(109),
	}
	return obj
}

type BsnTlvPartnerKey struct {
	*BsnTlv
	Value uint16
}

type IBsnTlvPartnerKey interface {
	IBsnTlv
	GetValue() uint16
}

func (self *BsnTlvPartnerKey) GetValue() uint16 {
	return self.Value
}

func (self *BsnTlvPartnerKey) SetValue(v uint16) {
	self.Value = v
}

func (self *BsnTlvPartnerKey) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint16(uint16(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvPartnerKey(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPartnerKey, error) {
	_bsntlvpartnerkey := &BsnTlvPartnerKey{BsnTlv: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("BsnTlvPartnerKey packet too short: %d < 2", decoder.Length())
	}
	_bsntlvpartnerkey.Value = uint16(decoder.ReadUint16())
	return _bsntlvpartnerkey, nil
}

func NewBsnTlvPartnerKey() *BsnTlvPartnerKey {
	obj := &BsnTlvPartnerKey{
		BsnTlv: NewBsnTlv(51),
	}
	return obj
}

type BsnTlvPartnerPortNum struct {
	*BsnTlv
	Value uint16
}

type IBsnTlvPartnerPortNum interface {
	IBsnTlv
	GetValue() uint16
}

func (self *BsnTlvPartnerPortNum) GetValue() uint16 {
	return self.Value
}

func (self *BsnTlvPartnerPortNum) SetValue(v uint16) {
	self.Value = v
}

func (self *BsnTlvPartnerPortNum) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint16(uint16(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvPartnerPortNum(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPartnerPortNum, error) {
	_bsntlvpartnerportnum := &BsnTlvPartnerPortNum{BsnTlv: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("BsnTlvPartnerPortNum packet too short: %d < 2", decoder.Length())
	}
	_bsntlvpartnerportnum.Value = uint16(decoder.ReadUint16())
	return _bsntlvpartnerportnum, nil
}

func NewBsnTlvPartnerPortNum() *BsnTlvPartnerPortNum {
	obj := &BsnTlvPartnerPortNum{
		BsnTlv: NewBsnTlv(50),
	}
	return obj
}

type BsnTlvPartnerPortPriority struct {
	*BsnTlv
	Value uint16
}

type IBsnTlvPartnerPortPriority interface {
	IBsnTlv
	GetValue() uint16
}

func (self *BsnTlvPartnerPortPriority) GetValue() uint16 {
	return self.Value
}

func (self *BsnTlvPartnerPortPriority) SetValue(v uint16) {
	self.Value = v
}

func (self *BsnTlvPartnerPortPriority) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint16(uint16(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvPartnerPortPriority(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPartnerPortPriority, error) {
	_bsntlvpartnerportpriority := &BsnTlvPartnerPortPriority{BsnTlv: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("BsnTlvPartnerPortPriority packet too short: %d < 2", decoder.Length())
	}
	_bsntlvpartnerportpriority.Value = uint16(decoder.ReadUint16())
	return _bsntlvpartnerportpriority, nil
}

func NewBsnTlvPartnerPortPriority() *BsnTlvPartnerPortPriority {
	obj := &BsnTlvPartnerPortPriority{
		BsnTlv: NewBsnTlv(49),
	}
	return obj
}

type BsnTlvPartnerState struct {
	*BsnTlv
	Value BsnLacpState
}

type IBsnTlvPartnerState interface {
	IBsnTlv
	GetValue() BsnLacpState
}

func (self *BsnTlvPartnerState) GetValue() BsnLacpState {
	return self.Value
}

func (self *BsnTlvPartnerState) SetValue(v BsnLacpState) {
	self.Value = v
}

func (self *BsnTlvPartnerState) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint8(uint8(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvPartnerState(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPartnerState, error) {
	_bsntlvpartnerstate := &BsnTlvPartnerState{BsnTlv: parent}
	if decoder.Length() < 1 {
		return nil, fmt.Errorf("BsnTlvPartnerState packet too short: %d < 1", decoder.Length())
	}
	_bsntlvpartnerstate.Value = BsnLacpState(decoder.ReadByte())
	return _bsntlvpartnerstate, nil
}

func NewBsnTlvPartnerState() *BsnTlvPartnerState {
	obj := &BsnTlvPartnerState{
		BsnTlv: NewBsnTlv(54),
	}
	return obj
}

type BsnTlvPartnerSystemMac struct {
	*BsnTlv
	Value net.HardwareAddr
}

type IBsnTlvPartnerSystemMac interface {
	IBsnTlv
	GetValue() net.HardwareAddr
}

func (self *BsnTlvPartnerSystemMac) GetValue() net.HardwareAddr {
	return self.Value
}

func (self *BsnTlvPartnerSystemMac) SetValue(v net.HardwareAddr) {
	self.Value = v
}

func (self *BsnTlvPartnerSystemMac) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.Write(self.Value)
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvPartnerSystemMac(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPartnerSystemMac, error) {
	_bsntlvpartnersystemmac := &BsnTlvPartnerSystemMac{BsnTlv: parent}
	if decoder.Length() < 6 {
		return nil, fmt.Errorf("BsnTlvPartnerSystemMac packet too short: %d < 6", decoder.Length())
	}
	_bsntlvpartnersystemmac.Value = net.HardwareAddr(decoder.Read(6))
	return _bsntlvpartnersystemmac, nil
}

func NewBsnTlvPartnerSystemMac() *BsnTlvPartnerSystemMac {
	obj := &BsnTlvPartnerSystemMac{
		BsnTlv: NewBsnTlv(48),
	}
	return obj
}

type BsnTlvPartnerSystemPriority struct {
	*BsnTlv
	Value uint16
}

type IBsnTlvPartnerSystemPriority interface {
	IBsnTlv
	GetValue() uint16
}

func (self *BsnTlvPartnerSystemPriority) GetValue() uint16 {
	return self.Value
}

func (self *BsnTlvPartnerSystemPriority) SetValue(v uint16) {
	self.Value = v
}

func (self *BsnTlvPartnerSystemPriority) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint16(uint16(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvPartnerSystemPriority(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPartnerSystemPriority, error) {
	_bsntlvpartnersystempriority := &BsnTlvPartnerSystemPriority{BsnTlv: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("BsnTlvPartnerSystemPriority packet too short: %d < 2", decoder.Length())
	}
	_bsntlvpartnersystempriority.Value = uint16(decoder.ReadUint16())
	return _bsntlvpartnersystempriority, nil
}

func NewBsnTlvPartnerSystemPriority() *BsnTlvPartnerSystemPriority {
	obj := &BsnTlvPartnerSystemPriority{
		BsnTlv: NewBsnTlv(47),
	}
	return obj
}

type BsnTlvPassive struct {
	*BsnTlv
}

type IBsnTlvPassive interface {
	IBsnTlv
}

func (self *BsnTlvPassive) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvPassive(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPassive, error) {
	_bsntlvpassive := &BsnTlvPassive{BsnTlv: parent}
	return _bsntlvpassive, nil
}

func NewBsnTlvPassive() *BsnTlvPassive {
	obj := &BsnTlvPassive{
		BsnTlv: NewBsnTlv(172),
	}
	return obj
}

type BsnTlvPduaRxInstance struct {
	*BsnTlv
	Value []byte
}

type IBsnTlvPduaRxInstance interface {
	IBsnTlv
	GetValue() []byte
}

func (self *BsnTlvPduaRxInstance) GetValue() []byte {
	return self.Value
}

func (self *BsnTlvPduaRxInstance) SetValue(v []byte) {
	self.Value = v
}

func (self *BsnTlvPduaRxInstance) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.Write(self.Value)
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvPduaRxInstance(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPduaRxInstance, error) {
	_bsntlvpduarxinstance := &BsnTlvPduaRxInstance{BsnTlv: parent}
	_bsntlvpduarxinstance.Value = decoder.Read(int(decoder.Length()))
	return _bsntlvpduarxinstance, nil
}

func NewBsnTlvPduaRxInstance() *BsnTlvPduaRxInstance {
	obj := &BsnTlvPduaRxInstance{
		BsnTlv: NewBsnTlv(159),
	}
	return obj
}

type BsnTlvPimDr struct {
	*BsnTlv
}

type IBsnTlvPimDr interface {
	IBsnTlv
}

func (self *BsnTlvPimDr) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvPimDr(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPimDr, error) {
	_bsntlvpimdr := &BsnTlvPimDr{BsnTlv: parent}
	return _bsntlvpimdr, nil
}

func NewBsnTlvPimDr() *BsnTlvPimDr {
	obj := &BsnTlvPimDr{
		BsnTlv: NewBsnTlv(171),
	}
	return obj
}

type BsnTlvPimHelloFlood struct {
	*BsnTlv
}

type IBsnTlvPimHelloFlood interface {
	IBsnTlv
}

func (self *BsnTlvPimHelloFlood) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvPimHelloFlood(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPimHelloFlood, error) {
	_bsntlvpimhelloflood := &BsnTlvPimHelloFlood{BsnTlv: parent}
	return _bsntlvpimhelloflood, nil
}

func NewBsnTlvPimHelloFlood() *BsnTlvPimHelloFlood {
	obj := &BsnTlvPimHelloFlood{
		BsnTlv: NewBsnTlv(181),
	}
	return obj
}

type BsnTlvPort struct {
	*BsnTlv
	Value Port
}

type IBsnTlvPort interface {
	IBsnTlv
	GetValue() Port
}

func (self *BsnTlvPort) GetValue() Port {
	return self.Value
}

func (self *BsnTlvPort) SetValue(v Port) {
	self.Value = v
}

func (self *BsnTlvPort) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	self.Value.Serialize(encoder)
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvPort(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPort, error) {
	_bsntlvport := &BsnTlvPort{BsnTlv: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("BsnTlvPort packet too short: %d < 4", decoder.Length())
	}
	_bsntlvport.Value.Decode(decoder)
	return _bsntlvport, nil
}

func NewBsnTlvPort() *BsnTlvPort {
	obj := &BsnTlvPort{
		BsnTlv: NewBsnTlv(0),
	}
	return obj
}

type BsnTlvPortMode struct {
	*BsnTlv
	Value BsnPortMode
}

type IBsnTlvPortMode interface {
	IBsnTlv
	GetValue() BsnPortMode
}

func (self *BsnTlvPortMode) GetValue() BsnPortMode {
	return self.Value
}

func (self *BsnTlvPortMode) SetValue(v BsnPortMode) {
	self.Value = v
}

func (self *BsnTlvPortMode) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint16(uint16(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvPortMode(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPortMode, error) {
	_bsntlvportmode := &BsnTlvPortMode{BsnTlv: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("BsnTlvPortMode packet too short: %d < 2", decoder.Length())
	}
	_bsntlvportmode.Value = BsnPortMode(decoder.ReadUint16())
	return _bsntlvportmode, nil
}

func NewBsnTlvPortMode() *BsnTlvPortMode {
	obj := &BsnTlvPortMode{
		BsnTlv: NewBsnTlv(179),
	}
	return obj
}

type BsnTlvPortSpeedGbps struct {
	*BsnTlv
	Value uint32
}

type IBsnTlvPortSpeedGbps interface {
	IBsnTlv
	GetValue() uint32
}

func (self *BsnTlvPortSpeedGbps) GetValue() uint32 {
	return self.Value
}

func (self *BsnTlvPortSpeedGbps) SetValue(v uint32) {
	self.Value = v
}

func (self *BsnTlvPortSpeedGbps) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint32(uint32(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvPortSpeedGbps(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPortSpeedGbps, error) {
	_bsntlvportspeedgbps := &BsnTlvPortSpeedGbps{BsnTlv: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("BsnTlvPortSpeedGbps packet too short: %d < 4", decoder.Length())
	}
	_bsntlvportspeedgbps.Value = uint32(decoder.ReadUint32())
	return _bsntlvportspeedgbps, nil
}

func NewBsnTlvPortSpeedGbps() *BsnTlvPortSpeedGbps {
	obj := &BsnTlvPortSpeedGbps{
		BsnTlv: NewBsnTlv(156),
	}
	return obj
}

type BsnTlvPortUsage struct {
	*BsnTlv
	Value BsnPortUsage
}

type IBsnTlvPortUsage interface {
	IBsnTlv
	GetValue() BsnPortUsage
}

func (self *BsnTlvPortUsage) GetValue() BsnPortUsage {
	return self.Value
}

func (self *BsnTlvPortUsage) SetValue(v BsnPortUsage) {
	self.Value = v
}

func (self *BsnTlvPortUsage) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint16(uint16(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvPortUsage(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPortUsage, error) {
	_bsntlvportusage := &BsnTlvPortUsage{BsnTlv: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("BsnTlvPortUsage packet too short: %d < 2", decoder.Length())
	}
	_bsntlvportusage.Value = BsnPortUsage(decoder.ReadUint16())
	return _bsntlvportusage, nil
}

func NewBsnTlvPortUsage() *BsnTlvPortUsage {
	obj := &BsnTlvPortUsage{
		BsnTlv: NewBsnTlv(141),
	}
	return obj
}

type BsnTlvPortVxlanMode struct {
	*BsnTlv
	Value BsnPortVxlanMode
}

type IBsnTlvPortVxlanMode interface {
	IBsnTlv
	GetValue() BsnPortVxlanMode
}

func (self *BsnTlvPortVxlanMode) GetValue() BsnPortVxlanMode {
	return self.Value
}

func (self *BsnTlvPortVxlanMode) SetValue(v BsnPortVxlanMode) {
	self.Value = v
}

func (self *BsnTlvPortVxlanMode) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint8(uint8(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvPortVxlanMode(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPortVxlanMode, error) {
	_bsntlvportvxlanmode := &BsnTlvPortVxlanMode{BsnTlv: parent}
	if decoder.Length() < 1 {
		return nil, fmt.Errorf("BsnTlvPortVxlanMode packet too short: %d < 1", decoder.Length())
	}
	_bsntlvportvxlanmode.Value = BsnPortVxlanMode(decoder.ReadByte())
	return _bsntlvportvxlanmode, nil
}

func NewBsnTlvPortVxlanMode() *BsnTlvPortVxlanMode {
	obj := &BsnTlvPortVxlanMode{
		BsnTlv: NewBsnTlv(88),
	}
	return obj
}

type BsnTlvPreserveVlan struct {
	*BsnTlv
}

type IBsnTlvPreserveVlan interface {
	IBsnTlv
}

func (self *BsnTlvPreserveVlan) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvPreserveVlan(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPreserveVlan, error) {
	_bsntlvpreservevlan := &BsnTlvPreserveVlan{BsnTlv: parent}
	return _bsntlvpreservevlan, nil
}

func NewBsnTlvPreserveVlan() *BsnTlvPreserveVlan {
	obj := &BsnTlvPreserveVlan{
		BsnTlv: NewBsnTlv(186),
	}
	return obj
}

type BsnTlvPriority struct {
	*BsnTlv
	Value uint32
}

type IBsnTlvPriority interface {
	IBsnTlv
	GetValue() uint32
}

func (self *BsnTlvPriority) GetValue() uint32 {
	return self.Value
}

func (self *BsnTlvPriority) SetValue(v uint32) {
	self.Value = v
}

func (self *BsnTlvPriority) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint32(uint32(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvPriority(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPriority, error) {
	_bsntlvpriority := &BsnTlvPriority{BsnTlv: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("BsnTlvPriority packet too short: %d < 4", decoder.Length())
	}
	_bsntlvpriority.Value = uint32(decoder.ReadUint32())
	return _bsntlvpriority, nil
}

func NewBsnTlvPriority() *BsnTlvPriority {
	obj := &BsnTlvPriority{
		BsnTlv: NewBsnTlv(57),
	}
	return obj
}

type BsnTlvPushVlanOnEgress struct {
	*BsnTlv
}

type IBsnTlvPushVlanOnEgress interface {
	IBsnTlv
}

func (self *BsnTlvPushVlanOnEgress) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvPushVlanOnEgress(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPushVlanOnEgress, error) {
	_bsntlvpushvlanonegress := &BsnTlvPushVlanOnEgress{BsnTlv: parent}
	return _bsntlvpushvlanonegress, nil
}

func NewBsnTlvPushVlanOnEgress() *BsnTlvPushVlanOnEgress {
	obj := &BsnTlvPushVlanOnEgress{
		BsnTlv: NewBsnTlv(162),
	}
	return obj
}

type BsnTlvPushVlanOnIngress struct {
	*BsnTlv
	Flags BsnPushVlan
}

type IBsnTlvPushVlanOnIngress interface {
	IBsnTlv
	GetFlags() BsnPushVlan
}

func (self *BsnTlvPushVlanOnIngress) GetFlags() BsnPushVlan {
	return self.Flags
}

func (self *BsnTlvPushVlanOnIngress) SetFlags(v BsnPushVlan) {
	self.Flags = v
}

func (self *BsnTlvPushVlanOnIngress) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint8(uint8(self.Flags))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvPushVlanOnIngress(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPushVlanOnIngress, error) {
	_bsntlvpushvlanoningress := &BsnTlvPushVlanOnIngress{BsnTlv: parent}
	if decoder.Length() < 1 {
		return nil, fmt.Errorf("BsnTlvPushVlanOnIngress packet too short: %d < 1", decoder.Length())
	}
	_bsntlvpushvlanoningress.Flags = BsnPushVlan(decoder.ReadByte())
	return _bsntlvpushvlanoningress, nil
}

func NewBsnTlvPushVlanOnIngress() *BsnTlvPushVlanOnIngress {
	obj := &BsnTlvPushVlanOnIngress{
		BsnTlv: NewBsnTlv(128),
	}
	return obj
}

type BsnTlvQosPriority struct {
	*BsnTlv
	Value uint32
}

type IBsnTlvQosPriority interface {
	IBsnTlv
	GetValue() uint32
}

func (self *BsnTlvQosPriority) GetValue() uint32 {
	return self.Value
}

func (self *BsnTlvQosPriority) SetValue(v uint32) {
	self.Value = v
}

func (self *BsnTlvQosPriority) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint32(uint32(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvQosPriority(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvQosPriority, error) {
	_bsntlvqospriority := &BsnTlvQosPriority{BsnTlv: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("BsnTlvQosPriority packet too short: %d < 4", decoder.Length())
	}
	_bsntlvqospriority.Value = uint32(decoder.ReadUint32())
	return _bsntlvqospriority, nil
}

func NewBsnTlvQosPriority() *BsnTlvQosPriority {
	obj := &BsnTlvQosPriority{
		BsnTlv: NewBsnTlv(108),
	}
	return obj
}

type BsnTlvQueueId struct {
	*BsnTlv
	Value uint32
}

type IBsnTlvQueueId interface {
	IBsnTlv
	GetValue() uint32
}

func (self *BsnTlvQueueId) GetValue() uint32 {
	return self.Value
}

func (self *BsnTlvQueueId) SetValue(v uint32) {
	self.Value = v
}

func (self *BsnTlvQueueId) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint32(uint32(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvQueueId(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvQueueId, error) {
	_bsntlvqueueid := &BsnTlvQueueId{BsnTlv: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("BsnTlvQueueId packet too short: %d < 4", decoder.Length())
	}
	_bsntlvqueueid.Value = uint32(decoder.ReadUint32())
	return _bsntlvqueueid, nil
}

func NewBsnTlvQueueId() *BsnTlvQueueId {
	obj := &BsnTlvQueueId{
		BsnTlv: NewBsnTlv(20),
	}
	return obj
}

type BsnTlvQueueWeight struct {
	*BsnTlv
	Value uint32
}

type IBsnTlvQueueWeight interface {
	IBsnTlv
	GetValue() uint32
}

func (self *BsnTlvQueueWeight) GetValue() uint32 {
	return self.Value
}

func (self *BsnTlvQueueWeight) SetValue(v uint32) {
	self.Value = v
}

func (self *BsnTlvQueueWeight) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint32(uint32(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvQueueWeight(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvQueueWeight, error) {
	_bsntlvqueueweight := &BsnTlvQueueWeight{BsnTlv: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("BsnTlvQueueWeight packet too short: %d < 4", decoder.Length())
	}
	_bsntlvqueueweight.Value = uint32(decoder.ReadUint32())
	return _bsntlvqueueweight, nil
}

func NewBsnTlvQueueWeight() *BsnTlvQueueWeight {
	obj := &BsnTlvQueueWeight{
		BsnTlv: NewBsnTlv(21),
	}
	return obj
}

type BsnTlvRateLimit struct {
	*BsnTlv
	Value uint32
}

type IBsnTlvRateLimit interface {
	IBsnTlv
	GetValue() uint32
}

func (self *BsnTlvRateLimit) GetValue() uint32 {
	return self.Value
}

func (self *BsnTlvRateLimit) SetValue(v uint32) {
	self.Value = v
}

func (self *BsnTlvRateLimit) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint32(uint32(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvRateLimit(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvRateLimit, error) {
	_bsntlvratelimit := &BsnTlvRateLimit{BsnTlv: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("BsnTlvRateLimit packet too short: %d < 4", decoder.Length())
	}
	_bsntlvratelimit.Value = uint32(decoder.ReadUint32())
	return _bsntlvratelimit, nil
}

func NewBsnTlvRateLimit() *BsnTlvRateLimit {
	obj := &BsnTlvRateLimit{
		BsnTlv: NewBsnTlv(116),
	}
	return obj
}

type BsnTlvRateUnit struct {
	*BsnTlv
	Value BsnRateUnit
}

type IBsnTlvRateUnit interface {
	IBsnTlv
	GetValue() BsnRateUnit
}

func (self *BsnTlvRateUnit) GetValue() BsnRateUnit {
	return self.Value
}

func (self *BsnTlvRateUnit) SetValue(v BsnRateUnit) {
	self.Value = v
}

func (self *BsnTlvRateUnit) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint8(uint8(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvRateUnit(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvRateUnit, error) {
	_bsntlvrateunit := &BsnTlvRateUnit{BsnTlv: parent}
	if decoder.Length() < 1 {
		return nil, fmt.Errorf("BsnTlvRateUnit packet too short: %d < 1", decoder.Length())
	}
	_bsntlvrateunit.Value = BsnRateUnit(decoder.ReadByte())
	return _bsntlvrateunit, nil
}

func NewBsnTlvRateUnit() *BsnTlvRateUnit {
	obj := &BsnTlvRateUnit{
		BsnTlv: NewBsnTlv(89),
	}
	return obj
}

type BsnTlvRecordPackets struct {
	*BsnTlv
	Value uint32
}

type IBsnTlvRecordPackets interface {
	IBsnTlv
	GetValue() uint32
}

func (self *BsnTlvRecordPackets) GetValue() uint32 {
	return self.Value
}

func (self *BsnTlvRecordPackets) SetValue(v uint32) {
	self.Value = v
}

func (self *BsnTlvRecordPackets) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint32(uint32(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvRecordPackets(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvRecordPackets, error) {
	_bsntlvrecordpackets := &BsnTlvRecordPackets{BsnTlv: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("BsnTlvRecordPackets packet too short: %d < 4", decoder.Length())
	}
	_bsntlvrecordpackets.Value = uint32(decoder.ReadUint32())
	return _bsntlvrecordpackets, nil
}

func NewBsnTlvRecordPackets() *BsnTlvRecordPackets {
	obj := &BsnTlvRecordPackets{
		BsnTlv: NewBsnTlv(155),
	}
	return obj
}

type BsnTlvRedundantMgmt struct {
	*BsnTlv
}

type IBsnTlvRedundantMgmt interface {
	IBsnTlv
}

func (self *BsnTlvRedundantMgmt) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvRedundantMgmt(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvRedundantMgmt, error) {
	_bsntlvredundantmgmt := &BsnTlvRedundantMgmt{BsnTlv: parent}
	return _bsntlvredundantmgmt, nil
}

func NewBsnTlvRedundantMgmt() *BsnTlvRedundantMgmt {
	obj := &BsnTlvRedundantMgmt{
		BsnTlv: NewBsnTlv(189),
	}
	return obj
}

type BsnTlvReference struct {
	*BsnTlv
	TableId uint16
	Key     []IBsnTlv
}

type IBsnTlvReference interface {
	IBsnTlv
	GetTableId() uint16
	GetKey() []IBsnTlv
}

func (self *BsnTlvReference) GetTableId() uint16 {
	return self.TableId
}

func (self *BsnTlvReference) SetTableId(v uint16) {
	self.TableId = v
}

func (self *BsnTlvReference) GetKey() []IBsnTlv {
	return self.Key
}

func (self *BsnTlvReference) SetKey(v []IBsnTlv) {
	self.Key = v
}

func (self *BsnTlvReference) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint16(uint16(self.TableId))
	for _, obj := range self.Key {
		if err := obj.Serialize(encoder); err != nil {
			return err
		}
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvReference(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvReference, error) {
	_bsntlvreference := &BsnTlvReference{BsnTlv: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("BsnTlvReference packet too short: %d < 2", decoder.Length())
	}
	_bsntlvreference.TableId = uint16(decoder.ReadUint16())

	for decoder.Length() >= 4 {
		item, err := DecodeBsnTlv(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_bsntlvreference.Key = append(_bsntlvreference.Key, item)
		}
	}
	return _bsntlvreference, nil
}

func NewBsnTlvReference() *BsnTlvReference {
	obj := &BsnTlvReference{
		BsnTlv: NewBsnTlv(59),
	}
	return obj
}

type BsnTlvReplyPackets struct {
	*BsnTlv
	Value uint64
}

type IBsnTlvReplyPackets interface {
	IBsnTlv
	GetValue() uint64
}

func (self *BsnTlvReplyPackets) GetValue() uint64 {
	return self.Value
}

func (self *BsnTlvReplyPackets) SetValue(v uint64) {
	self.Value = v
}

func (self *BsnTlvReplyPackets) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint64(uint64(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvReplyPackets(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvReplyPackets, error) {
	_bsntlvreplypackets := &BsnTlvReplyPackets{BsnTlv: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("BsnTlvReplyPackets packet too short: %d < 8", decoder.Length())
	}
	_bsntlvreplypackets.Value = uint64(decoder.ReadUint64())
	return _bsntlvreplypackets, nil
}

func NewBsnTlvReplyPackets() *BsnTlvReplyPackets {
	obj := &BsnTlvReplyPackets{
		BsnTlv: NewBsnTlv(12),
	}
	return obj
}

type BsnTlvRequestPackets struct {
	*BsnTlv
	Value uint64
}

type IBsnTlvRequestPackets interface {
	IBsnTlv
	GetValue() uint64
}

func (self *BsnTlvRequestPackets) GetValue() uint64 {
	return self.Value
}

func (self *BsnTlvRequestPackets) SetValue(v uint64) {
	self.Value = v
}

func (self *BsnTlvRequestPackets) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint64(uint64(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvRequestPackets(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvRequestPackets, error) {
	_bsntlvrequestpackets := &BsnTlvRequestPackets{BsnTlv: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("BsnTlvRequestPackets packet too short: %d < 8", decoder.Length())
	}
	_bsntlvrequestpackets.Value = uint64(decoder.ReadUint64())
	return _bsntlvrequestpackets, nil
}

func NewBsnTlvRequestPackets() *BsnTlvRequestPackets {
	obj := &BsnTlvRequestPackets{
		BsnTlv: NewBsnTlv(11),
	}
	return obj
}

type BsnTlvRestServer struct {
	*BsnTlv
}

type IBsnTlvRestServer interface {
	IBsnTlv
}

func (self *BsnTlvRestServer) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvRestServer(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvRestServer, error) {
	_bsntlvrestserver := &BsnTlvRestServer{BsnTlv: parent}
	return _bsntlvrestserver, nil
}

func NewBsnTlvRestServer() *BsnTlvRestServer {
	obj := &BsnTlvRestServer{
		BsnTlv: NewBsnTlv(152),
	}
	return obj
}

type BsnTlvRoutingParam struct {
	*BsnTlv
	Value BsnRoutingParam
}

type IBsnTlvRoutingParam interface {
	IBsnTlv
	GetValue() BsnRoutingParam
}

func (self *BsnTlvRoutingParam) GetValue() BsnRoutingParam {
	return self.Value
}

func (self *BsnTlvRoutingParam) SetValue(v BsnRoutingParam) {
	self.Value = v
}

func (self *BsnTlvRoutingParam) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint16(uint16(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvRoutingParam(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvRoutingParam, error) {
	_bsntlvroutingparam := &BsnTlvRoutingParam{BsnTlv: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("BsnTlvRoutingParam packet too short: %d < 2", decoder.Length())
	}
	_bsntlvroutingparam.Value = BsnRoutingParam(decoder.ReadUint16())
	return _bsntlvroutingparam, nil
}

func NewBsnTlvRoutingParam() *BsnTlvRoutingParam {
	obj := &BsnTlvRoutingParam{
		BsnTlv: NewBsnTlv(161),
	}
	return obj
}

type BsnTlvRxBytes struct {
	*BsnTlv
	Value uint64
}

type IBsnTlvRxBytes interface {
	IBsnTlv
	GetValue() uint64
}

func (self *BsnTlvRxBytes) GetValue() uint64 {
	return self.Value
}

func (self *BsnTlvRxBytes) SetValue(v uint64) {
	self.Value = v
}

func (self *BsnTlvRxBytes) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint64(uint64(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvRxBytes(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvRxBytes, error) {
	_bsntlvrxbytes := &BsnTlvRxBytes{BsnTlv: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("BsnTlvRxBytes packet too short: %d < 8", decoder.Length())
	}
	_bsntlvrxbytes.Value = uint64(decoder.ReadUint64())
	return _bsntlvrxbytes, nil
}

func NewBsnTlvRxBytes() *BsnTlvRxBytes {
	obj := &BsnTlvRxBytes{
		BsnTlv: NewBsnTlv(71),
	}
	return obj
}

type BsnTlvRxPackets struct {
	*BsnTlv
	Value uint64
}

type IBsnTlvRxPackets interface {
	IBsnTlv
	GetValue() uint64
}

func (self *BsnTlvRxPackets) GetValue() uint64 {
	return self.Value
}

func (self *BsnTlvRxPackets) SetValue(v uint64) {
	self.Value = v
}

func (self *BsnTlvRxPackets) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint64(uint64(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvRxPackets(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvRxPackets, error) {
	_bsntlvrxpackets := &BsnTlvRxPackets{BsnTlv: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("BsnTlvRxPackets packet too short: %d < 8", decoder.Length())
	}
	_bsntlvrxpackets.Value = uint64(decoder.ReadUint64())
	return _bsntlvrxpackets, nil
}

func NewBsnTlvRxPackets() *BsnTlvRxPackets {
	obj := &BsnTlvRxPackets{
		BsnTlv: NewBsnTlv(2),
	}
	return obj
}

type BsnTlvSamplingRate struct {
	*BsnTlv
	Value uint32
}

type IBsnTlvSamplingRate interface {
	IBsnTlv
	GetValue() uint32
}

func (self *BsnTlvSamplingRate) GetValue() uint32 {
	return self.Value
}

func (self *BsnTlvSamplingRate) SetValue(v uint32) {
	self.Value = v
}

func (self *BsnTlvSamplingRate) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint32(uint32(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvSamplingRate(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvSamplingRate, error) {
	_bsntlvsamplingrate := &BsnTlvSamplingRate{BsnTlv: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("BsnTlvSamplingRate packet too short: %d < 4", decoder.Length())
	}
	_bsntlvsamplingrate.Value = uint32(decoder.ReadUint32())
	return _bsntlvsamplingrate, nil
}

func NewBsnTlvSamplingRate() *BsnTlvSamplingRate {
	obj := &BsnTlvSamplingRate{
		BsnTlv: NewBsnTlv(30),
	}
	return obj
}

type BsnTlvSetLoopbackMode struct {
	*BsnTlv
}

type IBsnTlvSetLoopbackMode interface {
	IBsnTlv
}

func (self *BsnTlvSetLoopbackMode) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvSetLoopbackMode(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvSetLoopbackMode, error) {
	_bsntlvsetloopbackmode := &BsnTlvSetLoopbackMode{BsnTlv: parent}
	return _bsntlvsetloopbackmode, nil
}

func NewBsnTlvSetLoopbackMode() *BsnTlvSetLoopbackMode {
	obj := &BsnTlvSetLoopbackMode{
		BsnTlv: NewBsnTlv(74),
	}
	return obj
}

type BsnTlvSrcMacCml struct {
	*BsnTlv
	Value BsnCml
}

type IBsnTlvSrcMacCml interface {
	IBsnTlv
	GetValue() BsnCml
}

func (self *BsnTlvSrcMacCml) GetValue() BsnCml {
	return self.Value
}

func (self *BsnTlvSrcMacCml) SetValue(v BsnCml) {
	self.Value = v
}

func (self *BsnTlvSrcMacCml) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint16(uint16(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvSrcMacCml(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvSrcMacCml, error) {
	_bsntlvsrcmaccml := &BsnTlvSrcMacCml{BsnTlv: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("BsnTlvSrcMacCml packet too short: %d < 2", decoder.Length())
	}
	_bsntlvsrcmaccml.Value = BsnCml(decoder.ReadUint16())
	return _bsntlvsrcmaccml, nil
}

func NewBsnTlvSrcMacCml() *BsnTlvSrcMacCml {
	obj := &BsnTlvSrcMacCml{
		BsnTlv: NewBsnTlv(191),
	}
	return obj
}

type BsnTlvStatus struct {
	*BsnTlv
	Value BsnStatus
}

type IBsnTlvStatus interface {
	IBsnTlv
	GetValue() BsnStatus
}

func (self *BsnTlvStatus) GetValue() BsnStatus {
	return self.Value
}

func (self *BsnTlvStatus) SetValue(v BsnStatus) {
	self.Value = v
}

func (self *BsnTlvStatus) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint8(uint8(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvStatus(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvStatus, error) {
	_bsntlvstatus := &BsnTlvStatus{BsnTlv: parent}
	if decoder.Length() < 1 {
		return nil, fmt.Errorf("BsnTlvStatus packet too short: %d < 1", decoder.Length())
	}
	_bsntlvstatus.Value = BsnStatus(decoder.ReadByte())
	return _bsntlvstatus, nil
}

func NewBsnTlvStatus() *BsnTlvStatus {
	obj := &BsnTlvStatus{
		BsnTlv: NewBsnTlv(97),
	}
	return obj
}

type BsnTlvStripMplsL2OnIngress struct {
	*BsnTlv
}

type IBsnTlvStripMplsL2OnIngress interface {
	IBsnTlv
}

func (self *BsnTlvStripMplsL2OnIngress) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvStripMplsL2OnIngress(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvStripMplsL2OnIngress, error) {
	_bsntlvstripmplsl2oningress := &BsnTlvStripMplsL2OnIngress{BsnTlv: parent}
	return _bsntlvstripmplsl2oningress, nil
}

func NewBsnTlvStripMplsL2OnIngress() *BsnTlvStripMplsL2OnIngress {
	obj := &BsnTlvStripMplsL2OnIngress{
		BsnTlv: NewBsnTlv(75),
	}
	return obj
}

type BsnTlvStripMplsL3OnIngress struct {
	*BsnTlv
}

type IBsnTlvStripMplsL3OnIngress interface {
	IBsnTlv
}

func (self *BsnTlvStripMplsL3OnIngress) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvStripMplsL3OnIngress(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvStripMplsL3OnIngress, error) {
	_bsntlvstripmplsl3oningress := &BsnTlvStripMplsL3OnIngress{BsnTlv: parent}
	return _bsntlvstripmplsl3oningress, nil
}

func NewBsnTlvStripMplsL3OnIngress() *BsnTlvStripMplsL3OnIngress {
	obj := &BsnTlvStripMplsL3OnIngress{
		BsnTlv: NewBsnTlv(76),
	}
	return obj
}

type BsnTlvStripVlanOnEgress struct {
	*BsnTlv
	Flags BsnStripVlan
}

type IBsnTlvStripVlanOnEgress interface {
	IBsnTlv
	GetFlags() BsnStripVlan
}

func (self *BsnTlvStripVlanOnEgress) GetFlags() BsnStripVlan {
	return self.Flags
}

func (self *BsnTlvStripVlanOnEgress) SetFlags(v BsnStripVlan) {
	self.Flags = v
}

func (self *BsnTlvStripVlanOnEgress) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint8(uint8(self.Flags))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvStripVlanOnEgress(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvStripVlanOnEgress, error) {
	_bsntlvstripvlanonegress := &BsnTlvStripVlanOnEgress{BsnTlv: parent}
	if decoder.Length() < 1 {
		return nil, fmt.Errorf("BsnTlvStripVlanOnEgress packet too short: %d < 1", decoder.Length())
	}
	_bsntlvstripvlanonegress.Flags = BsnStripVlan(decoder.ReadByte())
	return _bsntlvstripvlanonegress, nil
}

func NewBsnTlvStripVlanOnEgress() *BsnTlvStripVlanOnEgress {
	obj := &BsnTlvStripVlanOnEgress{
		BsnTlv: NewBsnTlv(73),
	}
	return obj
}

type BsnTlvSubAgentId struct {
	*BsnTlv
	Value uint32
}

type IBsnTlvSubAgentId interface {
	IBsnTlv
	GetValue() uint32
}

func (self *BsnTlvSubAgentId) GetValue() uint32 {
	return self.Value
}

func (self *BsnTlvSubAgentId) SetValue(v uint32) {
	self.Value = v
}

func (self *BsnTlvSubAgentId) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint32(uint32(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvSubAgentId(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvSubAgentId, error) {
	_bsntlvsubagentid := &BsnTlvSubAgentId{BsnTlv: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("BsnTlvSubAgentId packet too short: %d < 4", decoder.Length())
	}
	_bsntlvsubagentid.Value = uint32(decoder.ReadUint32())
	return _bsntlvsubagentid, nil
}

func NewBsnTlvSubAgentId() *BsnTlvSubAgentId {
	obj := &BsnTlvSubAgentId{
		BsnTlv: NewBsnTlv(38),
	}
	return obj
}

type BsnTlvTcpDst struct {
	*BsnTlv
	Value uint16
}

type IBsnTlvTcpDst interface {
	IBsnTlv
	GetValue() uint16
}

func (self *BsnTlvTcpDst) GetValue() uint16 {
	return self.Value
}

func (self *BsnTlvTcpDst) SetValue(v uint16) {
	self.Value = v
}

func (self *BsnTlvTcpDst) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint16(uint16(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvTcpDst(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvTcpDst, error) {
	_bsntlvtcpdst := &BsnTlvTcpDst{BsnTlv: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("BsnTlvTcpDst packet too short: %d < 2", decoder.Length())
	}
	_bsntlvtcpdst.Value = uint16(decoder.ReadUint16())
	return _bsntlvtcpdst, nil
}

func NewBsnTlvTcpDst() *BsnTlvTcpDst {
	obj := &BsnTlvTcpDst{
		BsnTlv: NewBsnTlv(66),
	}
	return obj
}

type BsnTlvTcpFlags struct {
	*BsnTlv
	Value uint16
}

type IBsnTlvTcpFlags interface {
	IBsnTlv
	GetValue() uint16
}

func (self *BsnTlvTcpFlags) GetValue() uint16 {
	return self.Value
}

func (self *BsnTlvTcpFlags) SetValue(v uint16) {
	self.Value = v
}

func (self *BsnTlvTcpFlags) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint16(uint16(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvTcpFlags(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvTcpFlags, error) {
	_bsntlvtcpflags := &BsnTlvTcpFlags{BsnTlv: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("BsnTlvTcpFlags packet too short: %d < 2", decoder.Length())
	}
	_bsntlvtcpflags.Value = uint16(decoder.ReadUint16())
	return _bsntlvtcpflags, nil
}

func NewBsnTlvTcpFlags() *BsnTlvTcpFlags {
	obj := &BsnTlvTcpFlags{
		BsnTlv: NewBsnTlv(133),
	}
	return obj
}

type BsnTlvTcpSrc struct {
	*BsnTlv
	Value uint16
}

type IBsnTlvTcpSrc interface {
	IBsnTlv
	GetValue() uint16
}

func (self *BsnTlvTcpSrc) GetValue() uint16 {
	return self.Value
}

func (self *BsnTlvTcpSrc) SetValue(v uint16) {
	self.Value = v
}

func (self *BsnTlvTcpSrc) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint16(uint16(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvTcpSrc(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvTcpSrc, error) {
	_bsntlvtcpsrc := &BsnTlvTcpSrc{BsnTlv: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("BsnTlvTcpSrc packet too short: %d < 2", decoder.Length())
	}
	_bsntlvtcpsrc.Value = uint16(decoder.ReadUint16())
	return _bsntlvtcpsrc, nil
}

func NewBsnTlvTcpSrc() *BsnTlvTcpSrc {
	obj := &BsnTlvTcpSrc{
		BsnTlv: NewBsnTlv(65),
	}
	return obj
}

type BsnTlvTimestamp struct {
	*BsnTlv
	Value uint64
}

type IBsnTlvTimestamp interface {
	IBsnTlv
	GetValue() uint64
}

func (self *BsnTlvTimestamp) GetValue() uint64 {
	return self.Value
}

func (self *BsnTlvTimestamp) SetValue(v uint64) {
	self.Value = v
}

func (self *BsnTlvTimestamp) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint64(uint64(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvTimestamp(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvTimestamp, error) {
	_bsntlvtimestamp := &BsnTlvTimestamp{BsnTlv: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("BsnTlvTimestamp packet too short: %d < 8", decoder.Length())
	}
	_bsntlvtimestamp.Value = uint64(decoder.ReadUint64())
	return _bsntlvtimestamp, nil
}

func NewBsnTlvTimestamp() *BsnTlvTimestamp {
	obj := &BsnTlvTimestamp{
		BsnTlv: NewBsnTlv(154),
	}
	return obj
}

type BsnTlvTtl struct {
	*BsnTlv
	Value uint16
}

type IBsnTlvTtl interface {
	IBsnTlv
	GetValue() uint16
}

func (self *BsnTlvTtl) GetValue() uint16 {
	return self.Value
}

func (self *BsnTlvTtl) SetValue(v uint16) {
	self.Value = v
}

func (self *BsnTlvTtl) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint16(uint16(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvTtl(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvTtl, error) {
	_bsntlvttl := &BsnTlvTtl{BsnTlv: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("BsnTlvTtl packet too short: %d < 2", decoder.Length())
	}
	_bsntlvttl.Value = uint16(decoder.ReadUint16())
	return _bsntlvttl, nil
}

func NewBsnTlvTtl() *BsnTlvTtl {
	obj := &BsnTlvTtl{
		BsnTlv: NewBsnTlv(113),
	}
	return obj
}

type BsnTlvTunnelCapability struct {
	*BsnTlv
	Value BsnTunnelType
}

type IBsnTlvTunnelCapability interface {
	IBsnTlv
	GetValue() BsnTunnelType
}

func (self *BsnTlvTunnelCapability) GetValue() BsnTunnelType {
	return self.Value
}

func (self *BsnTlvTunnelCapability) SetValue(v BsnTunnelType) {
	self.Value = v
}

func (self *BsnTlvTunnelCapability) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint64(uint64(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvTunnelCapability(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvTunnelCapability, error) {
	_bsntlvtunnelcapability := &BsnTlvTunnelCapability{BsnTlv: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("BsnTlvTunnelCapability packet too short: %d < 8", decoder.Length())
	}
	_bsntlvtunnelcapability.Value = BsnTunnelType(decoder.ReadUint64())
	return _bsntlvtunnelcapability, nil
}

func NewBsnTlvTunnelCapability() *BsnTlvTunnelCapability {
	obj := &BsnTlvTunnelCapability{
		BsnTlv: NewBsnTlv(142),
	}
	return obj
}

type BsnTlvTxBytes struct {
	*BsnTlv
	Value uint64
}

type IBsnTlvTxBytes interface {
	IBsnTlv
	GetValue() uint64
}

func (self *BsnTlvTxBytes) GetValue() uint64 {
	return self.Value
}

func (self *BsnTlvTxBytes) SetValue(v uint64) {
	self.Value = v
}

func (self *BsnTlvTxBytes) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint64(uint64(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvTxBytes(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvTxBytes, error) {
	_bsntlvtxbytes := &BsnTlvTxBytes{BsnTlv: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("BsnTlvTxBytes packet too short: %d < 8", decoder.Length())
	}
	_bsntlvtxbytes.Value = uint64(decoder.ReadUint64())
	return _bsntlvtxbytes, nil
}

func NewBsnTlvTxBytes() *BsnTlvTxBytes {
	obj := &BsnTlvTxBytes{
		BsnTlv: NewBsnTlv(39),
	}
	return obj
}

type BsnTlvTxPackets struct {
	*BsnTlv
	Value uint64
}

type IBsnTlvTxPackets interface {
	IBsnTlv
	GetValue() uint64
}

func (self *BsnTlvTxPackets) GetValue() uint64 {
	return self.Value
}

func (self *BsnTlvTxPackets) SetValue(v uint64) {
	self.Value = v
}

func (self *BsnTlvTxPackets) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint64(uint64(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvTxPackets(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvTxPackets, error) {
	_bsntlvtxpackets := &BsnTlvTxPackets{BsnTlv: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("BsnTlvTxPackets packet too short: %d < 8", decoder.Length())
	}
	_bsntlvtxpackets.Value = uint64(decoder.ReadUint64())
	return _bsntlvtxpackets, nil
}

func NewBsnTlvTxPackets() *BsnTlvTxPackets {
	obj := &BsnTlvTxPackets{
		BsnTlv: NewBsnTlv(3),
	}
	return obj
}

type BsnTlvUdfAnchor struct {
	*BsnTlv
	Value BsnUdfAnchor
}

type IBsnTlvUdfAnchor interface {
	IBsnTlv
	GetValue() BsnUdfAnchor
}

func (self *BsnTlvUdfAnchor) GetValue() BsnUdfAnchor {
	return self.Value
}

func (self *BsnTlvUdfAnchor) SetValue(v BsnUdfAnchor) {
	self.Value = v
}

func (self *BsnTlvUdfAnchor) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint16(uint16(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvUdfAnchor(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUdfAnchor, error) {
	_bsntlvudfanchor := &BsnTlvUdfAnchor{BsnTlv: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("BsnTlvUdfAnchor packet too short: %d < 2", decoder.Length())
	}
	_bsntlvudfanchor.Value = BsnUdfAnchor(decoder.ReadUint16())
	return _bsntlvudfanchor, nil
}

func NewBsnTlvUdfAnchor() *BsnTlvUdfAnchor {
	obj := &BsnTlvUdfAnchor{
		BsnTlv: NewBsnTlv(16),
	}
	return obj
}

type BsnTlvUdfCapability struct {
	*BsnTlv
	Value BsnUdfMode
}

type IBsnTlvUdfCapability interface {
	IBsnTlv
	GetValue() BsnUdfMode
}

func (self *BsnTlvUdfCapability) GetValue() BsnUdfMode {
	return self.Value
}

func (self *BsnTlvUdfCapability) SetValue(v BsnUdfMode) {
	self.Value = v
}

func (self *BsnTlvUdfCapability) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint8(uint8(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvUdfCapability(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUdfCapability, error) {
	_bsntlvudfcapability := &BsnTlvUdfCapability{BsnTlv: parent}
	if decoder.Length() < 1 {
		return nil, fmt.Errorf("BsnTlvUdfCapability packet too short: %d < 1", decoder.Length())
	}
	_bsntlvudfcapability.Value = BsnUdfMode(decoder.ReadByte())
	return _bsntlvudfcapability, nil
}

func NewBsnTlvUdfCapability() *BsnTlvUdfCapability {
	obj := &BsnTlvUdfCapability{
		BsnTlv: NewBsnTlv(180),
	}
	return obj
}

type BsnTlvUdfId struct {
	*BsnTlv
	Value uint16
}

type IBsnTlvUdfId interface {
	IBsnTlv
	GetValue() uint16
}

func (self *BsnTlvUdfId) GetValue() uint16 {
	return self.Value
}

func (self *BsnTlvUdfId) SetValue(v uint16) {
	self.Value = v
}

func (self *BsnTlvUdfId) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint16(uint16(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvUdfId(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUdfId, error) {
	_bsntlvudfid := &BsnTlvUdfId{BsnTlv: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("BsnTlvUdfId packet too short: %d < 2", decoder.Length())
	}
	_bsntlvudfid.Value = uint16(decoder.ReadUint16())
	return _bsntlvudfid, nil
}

func NewBsnTlvUdfId() *BsnTlvUdfId {
	obj := &BsnTlvUdfId{
		BsnTlv: NewBsnTlv(15),
	}
	return obj
}

type BsnTlvUdfLength struct {
	*BsnTlv
	Value uint16
}

type IBsnTlvUdfLength interface {
	IBsnTlv
	GetValue() uint16
}

func (self *BsnTlvUdfLength) GetValue() uint16 {
	return self.Value
}

func (self *BsnTlvUdfLength) SetValue(v uint16) {
	self.Value = v
}

func (self *BsnTlvUdfLength) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint16(uint16(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvUdfLength(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUdfLength, error) {
	_bsntlvudflength := &BsnTlvUdfLength{BsnTlv: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("BsnTlvUdfLength packet too short: %d < 2", decoder.Length())
	}
	_bsntlvudflength.Value = uint16(decoder.ReadUint16())
	return _bsntlvudflength, nil
}

func NewBsnTlvUdfLength() *BsnTlvUdfLength {
	obj := &BsnTlvUdfLength{
		BsnTlv: NewBsnTlv(18),
	}
	return obj
}

type BsnTlvUdfOffset struct {
	*BsnTlv
	Value uint16
}

type IBsnTlvUdfOffset interface {
	IBsnTlv
	GetValue() uint16
}

func (self *BsnTlvUdfOffset) GetValue() uint16 {
	return self.Value
}

func (self *BsnTlvUdfOffset) SetValue(v uint16) {
	self.Value = v
}

func (self *BsnTlvUdfOffset) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint16(uint16(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvUdfOffset(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUdfOffset, error) {
	_bsntlvudfoffset := &BsnTlvUdfOffset{BsnTlv: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("BsnTlvUdfOffset packet too short: %d < 2", decoder.Length())
	}
	_bsntlvudfoffset.Value = uint16(decoder.ReadUint16())
	return _bsntlvudfoffset, nil
}

func NewBsnTlvUdfOffset() *BsnTlvUdfOffset {
	obj := &BsnTlvUdfOffset{
		BsnTlv: NewBsnTlv(17),
	}
	return obj
}

type BsnTlvUdpDst struct {
	*BsnTlv
	Value uint16
}

type IBsnTlvUdpDst interface {
	IBsnTlv
	GetValue() uint16
}

func (self *BsnTlvUdpDst) GetValue() uint16 {
	return self.Value
}

func (self *BsnTlvUdpDst) SetValue(v uint16) {
	self.Value = v
}

func (self *BsnTlvUdpDst) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint16(uint16(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvUdpDst(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUdpDst, error) {
	_bsntlvudpdst := &BsnTlvUdpDst{BsnTlv: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("BsnTlvUdpDst packet too short: %d < 2", decoder.Length())
	}
	_bsntlvudpdst.Value = uint16(decoder.ReadUint16())
	return _bsntlvudpdst, nil
}

func NewBsnTlvUdpDst() *BsnTlvUdpDst {
	obj := &BsnTlvUdpDst{
		BsnTlv: NewBsnTlv(37),
	}
	return obj
}

type BsnTlvUdpSrc struct {
	*BsnTlv
	Value uint16
}

type IBsnTlvUdpSrc interface {
	IBsnTlv
	GetValue() uint16
}

func (self *BsnTlvUdpSrc) GetValue() uint16 {
	return self.Value
}

func (self *BsnTlvUdpSrc) SetValue(v uint16) {
	self.Value = v
}

func (self *BsnTlvUdpSrc) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint16(uint16(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvUdpSrc(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUdpSrc, error) {
	_bsntlvudpsrc := &BsnTlvUdpSrc{BsnTlv: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("BsnTlvUdpSrc packet too short: %d < 2", decoder.Length())
	}
	_bsntlvudpsrc.Value = uint16(decoder.ReadUint16())
	return _bsntlvudpsrc, nil
}

func NewBsnTlvUdpSrc() *BsnTlvUdpSrc {
	obj := &BsnTlvUdpSrc{
		BsnTlv: NewBsnTlv(36),
	}
	return obj
}

type BsnTlvUint32 struct {
	*BsnTlv
	Value uint32
}

type IBsnTlvUint32 interface {
	IBsnTlv
	GetValue() uint32
}

func (self *BsnTlvUint32) GetValue() uint32 {
	return self.Value
}

func (self *BsnTlvUint32) SetValue(v uint32) {
	self.Value = v
}

func (self *BsnTlvUint32) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint32(uint32(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvUint32(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUint32, error) {
	_bsntlvuint32 := &BsnTlvUint32{BsnTlv: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("BsnTlvUint32 packet too short: %d < 4", decoder.Length())
	}
	_bsntlvuint32.Value = uint32(decoder.ReadUint32())
	return _bsntlvuint32, nil
}

func NewBsnTlvUint32() *BsnTlvUint32 {
	obj := &BsnTlvUint32{
		BsnTlv: NewBsnTlv(167),
	}
	return obj
}

type BsnTlvUint64List struct {
	*BsnTlv
	Value []*Uint64
}

type IBsnTlvUint64List interface {
	IBsnTlv
	GetValue() []*Uint64
}

func (self *BsnTlvUint64List) GetValue() []*Uint64 {
	return self.Value
}

func (self *BsnTlvUint64List) SetValue(v []*Uint64) {
	self.Value = v
}

func (self *BsnTlvUint64List) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	for _, obj := range self.Value {
		if err := obj.Serialize(encoder); err != nil {
			return err
		}
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvUint64List(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUint64List, error) {
	_bsntlvuint64list := &BsnTlvUint64List{BsnTlv: parent}

	for decoder.Length() >= 8 {
		item, err := DecodeUint64(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_bsntlvuint64list.Value = append(_bsntlvuint64list.Value, item)
		}
	}
	return _bsntlvuint64list, nil
}

func NewBsnTlvUint64List() *BsnTlvUint64List {
	obj := &BsnTlvUint64List{
		BsnTlv: NewBsnTlv(119),
	}
	return obj
}

type BsnTlvUnicastQueryTimeout struct {
	*BsnTlv
	Value uint32
}

type IBsnTlvUnicastQueryTimeout interface {
	IBsnTlv
	GetValue() uint32
}

func (self *BsnTlvUnicastQueryTimeout) GetValue() uint32 {
	return self.Value
}

func (self *BsnTlvUnicastQueryTimeout) SetValue(v uint32) {
	self.Value = v
}

func (self *BsnTlvUnicastQueryTimeout) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint32(uint32(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvUnicastQueryTimeout(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUnicastQueryTimeout, error) {
	_bsntlvunicastquerytimeout := &BsnTlvUnicastQueryTimeout{BsnTlv: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("BsnTlvUnicastQueryTimeout packet too short: %d < 4", decoder.Length())
	}
	_bsntlvunicastquerytimeout.Value = uint32(decoder.ReadUint32())
	return _bsntlvunicastquerytimeout, nil
}

func NewBsnTlvUnicastQueryTimeout() *BsnTlvUnicastQueryTimeout {
	obj := &BsnTlvUnicastQueryTimeout{
		BsnTlv: NewBsnTlv(9),
	}
	return obj
}

type BsnTlvUnicastRate struct {
	*BsnTlv
	Value uint32
}

type IBsnTlvUnicastRate interface {
	IBsnTlv
	GetValue() uint32
}

func (self *BsnTlvUnicastRate) GetValue() uint32 {
	return self.Value
}

func (self *BsnTlvUnicastRate) SetValue(v uint32) {
	self.Value = v
}

func (self *BsnTlvUnicastRate) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint32(uint32(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvUnicastRate(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUnicastRate, error) {
	_bsntlvunicastrate := &BsnTlvUnicastRate{BsnTlv: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("BsnTlvUnicastRate packet too short: %d < 4", decoder.Length())
	}
	_bsntlvunicastrate.Value = uint32(decoder.ReadUint32())
	return _bsntlvunicastrate, nil
}

func NewBsnTlvUnicastRate() *BsnTlvUnicastRate {
	obj := &BsnTlvUnicastRate{
		BsnTlv: NewBsnTlv(93),
	}
	return obj
}

type BsnTlvUnknownMulticastRate struct {
	*BsnTlv
	Value uint32
}

type IBsnTlvUnknownMulticastRate interface {
	IBsnTlv
	GetValue() uint32
}

func (self *BsnTlvUnknownMulticastRate) GetValue() uint32 {
	return self.Value
}

func (self *BsnTlvUnknownMulticastRate) SetValue(v uint32) {
	self.Value = v
}

func (self *BsnTlvUnknownMulticastRate) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint32(uint32(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvUnknownMulticastRate(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUnknownMulticastRate, error) {
	_bsntlvunknownmulticastrate := &BsnTlvUnknownMulticastRate{BsnTlv: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("BsnTlvUnknownMulticastRate packet too short: %d < 4", decoder.Length())
	}
	_bsntlvunknownmulticastrate.Value = uint32(decoder.ReadUint32())
	return _bsntlvunknownmulticastrate, nil
}

func NewBsnTlvUnknownMulticastRate() *BsnTlvUnknownMulticastRate {
	obj := &BsnTlvUnknownMulticastRate{
		BsnTlv: NewBsnTlv(92),
	}
	return obj
}

type BsnTlvUntagged struct {
	*BsnTlv
}

type IBsnTlvUntagged interface {
	IBsnTlv
}

func (self *BsnTlvUntagged) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvUntagged(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUntagged, error) {
	_bsntlvuntagged := &BsnTlvUntagged{BsnTlv: parent}
	return _bsntlvuntagged, nil
}

func NewBsnTlvUntagged() *BsnTlvUntagged {
	obj := &BsnTlvUntagged{
		BsnTlv: NewBsnTlv(106),
	}
	return obj
}

type BsnTlvUpgrade struct {
	*BsnTlv
	Value BsnUpgrade
}

type IBsnTlvUpgrade interface {
	IBsnTlv
	GetValue() BsnUpgrade
}

func (self *BsnTlvUpgrade) GetValue() BsnUpgrade {
	return self.Value
}

func (self *BsnTlvUpgrade) SetValue(v BsnUpgrade) {
	self.Value = v
}

func (self *BsnTlvUpgrade) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint16(uint16(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvUpgrade(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUpgrade, error) {
	_bsntlvupgrade := &BsnTlvUpgrade{BsnTlv: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("BsnTlvUpgrade packet too short: %d < 2", decoder.Length())
	}
	_bsntlvupgrade.Value = BsnUpgrade(decoder.ReadUint16())
	return _bsntlvupgrade, nil
}

func NewBsnTlvUpgrade() *BsnTlvUpgrade {
	obj := &BsnTlvUpgrade{
		BsnTlv: NewBsnTlv(164),
	}
	return obj
}

type BsnTlvUriScheme struct {
	*BsnTlv
	Value []byte
}

type IBsnTlvUriScheme interface {
	IBsnTlv
	GetValue() []byte
}

func (self *BsnTlvUriScheme) GetValue() []byte {
	return self.Value
}

func (self *BsnTlvUriScheme) SetValue(v []byte) {
	self.Value = v
}

func (self *BsnTlvUriScheme) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.Write(self.Value)
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvUriScheme(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUriScheme, error) {
	_bsntlvurischeme := &BsnTlvUriScheme{BsnTlv: parent}
	_bsntlvurischeme.Value = decoder.Read(int(decoder.Length()))
	return _bsntlvurischeme, nil
}

func NewBsnTlvUriScheme() *BsnTlvUriScheme {
	obj := &BsnTlvUriScheme{
		BsnTlv: NewBsnTlv(153),
	}
	return obj
}

type BsnTlvUsePacketState struct {
	*BsnTlv
	Value uint8
}

type IBsnTlvUsePacketState interface {
	IBsnTlv
	GetValue() uint8
}

func (self *BsnTlvUsePacketState) GetValue() uint8 {
	return self.Value
}

func (self *BsnTlvUsePacketState) SetValue(v uint8) {
	self.Value = v
}

func (self *BsnTlvUsePacketState) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint8(uint8(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvUsePacketState(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUsePacketState, error) {
	_bsntlvusepacketstate := &BsnTlvUsePacketState{BsnTlv: parent}
	if decoder.Length() < 1 {
		return nil, fmt.Errorf("BsnTlvUsePacketState packet too short: %d < 1", decoder.Length())
	}
	_bsntlvusepacketstate.Value = uint8(decoder.ReadByte())
	return _bsntlvusepacketstate, nil
}

func NewBsnTlvUsePacketState() *BsnTlvUsePacketState {
	obj := &BsnTlvUsePacketState{
		BsnTlv: NewBsnTlv(96),
	}
	return obj
}

type BsnTlvUserConfigured struct {
	*BsnTlv
}

type IBsnTlvUserConfigured interface {
	IBsnTlv
}

func (self *BsnTlvUserConfigured) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvUserConfigured(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUserConfigured, error) {
	_bsntlvuserconfigured := &BsnTlvUserConfigured{BsnTlv: parent}
	return _bsntlvuserconfigured, nil
}

func NewBsnTlvUserConfigured() *BsnTlvUserConfigured {
	obj := &BsnTlvUserConfigured{
		BsnTlv: NewBsnTlv(166),
	}
	return obj
}

type BsnTlvVfi struct {
	*BsnTlv
	Value uint16
}

type IBsnTlvVfi interface {
	IBsnTlv
	GetValue() uint16
}

func (self *BsnTlvVfi) GetValue() uint16 {
	return self.Value
}

func (self *BsnTlvVfi) SetValue(v uint16) {
	self.Value = v
}

func (self *BsnTlvVfi) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint16(uint16(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvVfi(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvVfi, error) {
	_bsntlvvfi := &BsnTlvVfi{BsnTlv: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("BsnTlvVfi packet too short: %d < 2", decoder.Length())
	}
	_bsntlvvfi.Value = uint16(decoder.ReadUint16())
	return _bsntlvvfi, nil
}

func NewBsnTlvVfi() *BsnTlvVfi {
	obj := &BsnTlvVfi{
		BsnTlv: NewBsnTlv(99),
	}
	return obj
}

type BsnTlvVfpClassId struct {
	*BsnTlv
	Value uint32
}

type IBsnTlvVfpClassId interface {
	IBsnTlv
	GetValue() uint32
}

func (self *BsnTlvVfpClassId) GetValue() uint32 {
	return self.Value
}

func (self *BsnTlvVfpClassId) SetValue(v uint32) {
	self.Value = v
}

func (self *BsnTlvVfpClassId) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint32(uint32(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvVfpClassId(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvVfpClassId, error) {
	_bsntlvvfpclassid := &BsnTlvVfpClassId{BsnTlv: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("BsnTlvVfpClassId packet too short: %d < 4", decoder.Length())
	}
	_bsntlvvfpclassid.Value = uint32(decoder.ReadUint32())
	return _bsntlvvfpclassid, nil
}

func NewBsnTlvVfpClassId() *BsnTlvVfpClassId {
	obj := &BsnTlvVfpClassId{
		BsnTlv: NewBsnTlv(107),
	}
	return obj
}

type BsnTlvVirtual struct {
	*BsnTlv
}

type IBsnTlvVirtual interface {
	IBsnTlv
}

func (self *BsnTlvVirtual) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvVirtual(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvVirtual, error) {
	_bsntlvvirtual := &BsnTlvVirtual{BsnTlv: parent}
	return _bsntlvvirtual, nil
}

func NewBsnTlvVirtual() *BsnTlvVirtual {
	obj := &BsnTlvVirtual{
		BsnTlv: NewBsnTlv(158),
	}
	return obj
}

type BsnTlvVlanMacList struct {
	*BsnTlv
	Key []*BsnVlanMac
}

type IBsnTlvVlanMacList interface {
	IBsnTlv
	GetKey() []*BsnVlanMac
}

func (self *BsnTlvVlanMacList) GetKey() []*BsnVlanMac {
	return self.Key
}

func (self *BsnTlvVlanMacList) SetKey(v []*BsnVlanMac) {
	self.Key = v
}

func (self *BsnTlvVlanMacList) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	for _, obj := range self.Key {
		if err := obj.Serialize(encoder); err != nil {
			return err
		}
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvVlanMacList(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvVlanMacList, error) {
	_bsntlvvlanmaclist := &BsnTlvVlanMacList{BsnTlv: parent}

	for decoder.Length() >= 8 {
		item, err := DecodeBsnVlanMac(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_bsntlvvlanmaclist.Key = append(_bsntlvvlanmaclist.Key, item)
		}
	}
	return _bsntlvvlanmaclist, nil
}

func NewBsnTlvVlanMacList() *BsnTlvVlanMacList {
	obj := &BsnTlvVlanMacList{
		BsnTlv: NewBsnTlv(98),
	}
	return obj
}

type BsnTlvVlanPcp struct {
	*BsnTlv
	Value uint8
}

type IBsnTlvVlanPcp interface {
	IBsnTlv
	GetValue() uint8
}

func (self *BsnTlvVlanPcp) GetValue() uint8 {
	return self.Value
}

func (self *BsnTlvVlanPcp) SetValue(v uint8) {
	self.Value = v
}

func (self *BsnTlvVlanPcp) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint8(uint8(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvVlanPcp(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvVlanPcp, error) {
	_bsntlvvlanpcp := &BsnTlvVlanPcp{BsnTlv: parent}
	if decoder.Length() < 1 {
		return nil, fmt.Errorf("BsnTlvVlanPcp packet too short: %d < 1", decoder.Length())
	}
	_bsntlvvlanpcp.Value = uint8(decoder.ReadByte())
	return _bsntlvvlanpcp, nil
}

func NewBsnTlvVlanPcp() *BsnTlvVlanPcp {
	obj := &BsnTlvVlanPcp{
		BsnTlv: NewBsnTlv(72),
	}
	return obj
}

type BsnTlvVlanVid struct {
	*BsnTlv
	Value uint16
}

type IBsnTlvVlanVid interface {
	IBsnTlv
	GetValue() uint16
}

func (self *BsnTlvVlanVid) GetValue() uint16 {
	return self.Value
}

func (self *BsnTlvVlanVid) SetValue(v uint16) {
	self.Value = v
}

func (self *BsnTlvVlanVid) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint16(uint16(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvVlanVid(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvVlanVid, error) {
	_bsntlvvlanvid := &BsnTlvVlanVid{BsnTlv: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("BsnTlvVlanVid packet too short: %d < 2", decoder.Length())
	}
	_bsntlvvlanvid.Value = uint16(decoder.ReadUint16())
	return _bsntlvvlanvid, nil
}

func NewBsnTlvVlanVid() *BsnTlvVlanVid {
	obj := &BsnTlvVlanVid{
		BsnTlv: NewBsnTlv(6),
	}
	return obj
}

type BsnTlvVlanVidMask struct {
	*BsnTlv
	Value uint16
}

type IBsnTlvVlanVidMask interface {
	IBsnTlv
	GetValue() uint16
}

func (self *BsnTlvVlanVidMask) GetValue() uint16 {
	return self.Value
}

func (self *BsnTlvVlanVidMask) SetValue(v uint16) {
	self.Value = v
}

func (self *BsnTlvVlanVidMask) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint16(uint16(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvVlanVidMask(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvVlanVidMask, error) {
	_bsntlvvlanvidmask := &BsnTlvVlanVidMask{BsnTlv: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("BsnTlvVlanVidMask packet too short: %d < 2", decoder.Length())
	}
	_bsntlvvlanvidmask.Value = uint16(decoder.ReadUint16())
	return _bsntlvvlanvidmask, nil
}

func NewBsnTlvVlanVidMask() *BsnTlvVlanVidMask {
	obj := &BsnTlvVlanVidMask{
		BsnTlv: NewBsnTlv(77),
	}
	return obj
}

type BsnTlvVni struct {
	*BsnTlv
	Value uint32
}

type IBsnTlvVni interface {
	IBsnTlv
	GetValue() uint32
}

func (self *BsnTlvVni) GetValue() uint32 {
	return self.Value
}

func (self *BsnTlvVni) SetValue(v uint32) {
	self.Value = v
}

func (self *BsnTlvVni) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint32(uint32(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvVni(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvVni, error) {
	_bsntlvvni := &BsnTlvVni{BsnTlv: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("BsnTlvVni packet too short: %d < 4", decoder.Length())
	}
	_bsntlvvni.Value = uint32(decoder.ReadUint32())
	return _bsntlvvni, nil
}

func NewBsnTlvVni() *BsnTlvVni {
	obj := &BsnTlvVni{
		BsnTlv: NewBsnTlv(86),
	}
	return obj
}

type BsnTlvVpnKey struct {
	*BsnTlv
	Value uint32
}

type IBsnTlvVpnKey interface {
	IBsnTlv
	GetValue() uint32
}

func (self *BsnTlvVpnKey) GetValue() uint32 {
	return self.Value
}

func (self *BsnTlvVpnKey) SetValue(v uint32) {
	self.Value = v
}

func (self *BsnTlvVpnKey) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint32(uint32(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvVpnKey(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvVpnKey, error) {
	_bsntlvvpnkey := &BsnTlvVpnKey{BsnTlv: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("BsnTlvVpnKey packet too short: %d < 4", decoder.Length())
	}
	_bsntlvvpnkey.Value = uint32(decoder.ReadUint32())
	return _bsntlvvpnkey, nil
}

func NewBsnTlvVpnKey() *BsnTlvVpnKey {
	obj := &BsnTlvVpnKey{
		BsnTlv: NewBsnTlv(111),
	}
	return obj
}

type BsnTlvVrf struct {
	*BsnTlv
	Value uint32
}

type IBsnTlvVrf interface {
	IBsnTlv
	GetValue() uint32
}

func (self *BsnTlvVrf) GetValue() uint32 {
	return self.Value
}

func (self *BsnTlvVrf) SetValue(v uint32) {
	self.Value = v
}

func (self *BsnTlvVrf) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint32(uint32(self.Value))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvVrf(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvVrf, error) {
	_bsntlvvrf := &BsnTlvVrf{BsnTlv: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("BsnTlvVrf packet too short: %d < 4", decoder.Length())
	}
	_bsntlvvrf.Value = uint32(decoder.ReadUint32())
	return _bsntlvvrf, nil
}

func NewBsnTlvVrf() *BsnTlvVrf {
	obj := &BsnTlvVrf{
		BsnTlv: NewBsnTlv(19),
	}
	return obj
}

type BsnTlvVxlanEgressLag struct {
	*BsnTlv
}

type IBsnTlvVxlanEgressLag interface {
	IBsnTlv
}

func (self *BsnTlvVxlanEgressLag) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnTlv.Serialize(encoder); err != nil {
		return err
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnTlvVxlanEgressLag(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvVxlanEgressLag, error) {
	_bsntlvvxlanegresslag := &BsnTlvVxlanEgressLag{BsnTlv: parent}
	return _bsntlvvxlanegresslag, nil
}

func NewBsnTlvVxlanEgressLag() *BsnTlvVxlanEgressLag {
	obj := &BsnTlvVxlanEgressLag{
		BsnTlv: NewBsnTlv(117),
	}
	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 BsnVlanCounterStatsEntry struct {
	Length  uint16
	VlanVid uint16
	Values  []*Uint64
}

type IBsnVlanCounterStatsEntry interface {
	goloxi.Serializable
	GetLength() uint16
	GetVlanVid() uint16
	GetValues() []*Uint64
}

func (self *BsnVlanCounterStatsEntry) GetLength() uint16 {
	return self.Length
}

func (self *BsnVlanCounterStatsEntry) SetLength(v uint16) {
	self.Length = v
}

func (self *BsnVlanCounterStatsEntry) GetVlanVid() uint16 {
	return self.VlanVid
}

func (self *BsnVlanCounterStatsEntry) SetVlanVid(v uint16) {
	self.VlanVid = v
}

func (self *BsnVlanCounterStatsEntry) GetValues() []*Uint64 {
	return self.Values
}

func (self *BsnVlanCounterStatsEntry) SetValues(v []*Uint64) {
	self.Values = v
}

func (self *BsnVlanCounterStatsEntry) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())

	encoder.PutUint16(uint16(self.Length))
	encoder.PutUint16(uint16(self.VlanVid))
	encoder.Write(bytes.Repeat([]byte{0}, 4))
	for _, obj := range self.Values {
		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 DecodeBsnVlanCounterStatsEntry(decoder *goloxi.Decoder) (*BsnVlanCounterStatsEntry, error) {
	_bsnvlancounterstatsentry := &BsnVlanCounterStatsEntry{}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("BsnVlanCounterStatsEntry packet too short: %d < 8", decoder.Length())
	}
	_bsnvlancounterstatsentry.Length = uint16(decoder.ReadUint16())
	oldDecoder := decoder
	defer func() { decoder = oldDecoder }()
	decoder = decoder.SliceDecoder(int(_bsnvlancounterstatsentry.Length), 2+0)
	_bsnvlancounterstatsentry.VlanVid = uint16(decoder.ReadUint16())
	decoder.Skip(4)

	for decoder.Length() >= 8 {
		item, err := DecodeUint64(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_bsnvlancounterstatsentry.Values = append(_bsnvlancounterstatsentry.Values, item)
		}
	}
	return _bsnvlancounterstatsentry, nil
}

func NewBsnVlanCounterStatsEntry() *BsnVlanCounterStatsEntry {
	obj := &BsnVlanCounterStatsEntry{}
	return obj
}

type BsnVlanMac struct {
	VlanVid uint16
	Mac     net.HardwareAddr
}

type IBsnVlanMac interface {
	goloxi.Serializable
	GetVlanVid() uint16
	GetMac() net.HardwareAddr
}

func (self *BsnVlanMac) GetVlanVid() uint16 {
	return self.VlanVid
}

func (self *BsnVlanMac) SetVlanVid(v uint16) {
	self.VlanVid = v
}

func (self *BsnVlanMac) GetMac() net.HardwareAddr {
	return self.Mac
}

func (self *BsnVlanMac) SetMac(v net.HardwareAddr) {
	self.Mac = v
}

func (self *BsnVlanMac) Serialize(encoder *goloxi.Encoder) error {

	encoder.PutUint16(uint16(self.VlanVid))
	encoder.Write(self.Mac)

	return nil
}

func DecodeBsnVlanMac(decoder *goloxi.Decoder) (*BsnVlanMac, error) {
	_bsnvlanmac := &BsnVlanMac{}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("BsnVlanMac packet too short: %d < 8", decoder.Length())
	}
	_bsnvlanmac.VlanVid = uint16(decoder.ReadUint16())
	_bsnvlanmac.Mac = net.HardwareAddr(decoder.Read(6))
	return _bsnvlanmac, nil
}

func NewBsnVlanMac() *BsnVlanMac {
	obj := &BsnVlanMac{}
	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() < 60 {
		return nil, fmt.Errorf("BsnVportL2Gre packet too short: %d < 60", 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 BsnVrfCounterStatsEntry struct {
	Length uint16
	Vrf    uint32
	Values []*Uint64
}

type IBsnVrfCounterStatsEntry interface {
	goloxi.Serializable
	GetLength() uint16
	GetVrf() uint32
	GetValues() []*Uint64
}

func (self *BsnVrfCounterStatsEntry) GetLength() uint16 {
	return self.Length
}

func (self *BsnVrfCounterStatsEntry) SetLength(v uint16) {
	self.Length = v
}

func (self *BsnVrfCounterStatsEntry) GetVrf() uint32 {
	return self.Vrf
}

func (self *BsnVrfCounterStatsEntry) SetVrf(v uint32) {
	self.Vrf = v
}

func (self *BsnVrfCounterStatsEntry) GetValues() []*Uint64 {
	return self.Values
}

func (self *BsnVrfCounterStatsEntry) SetValues(v []*Uint64) {
	self.Values = v
}

func (self *BsnVrfCounterStatsEntry) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())

	encoder.PutUint16(uint16(self.Length))
	encoder.Write(bytes.Repeat([]byte{0}, 2))
	encoder.PutUint32(uint32(self.Vrf))
	for _, obj := range self.Values {
		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 DecodeBsnVrfCounterStatsEntry(decoder *goloxi.Decoder) (*BsnVrfCounterStatsEntry, error) {
	_bsnvrfcounterstatsentry := &BsnVrfCounterStatsEntry{}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("BsnVrfCounterStatsEntry packet too short: %d < 8", decoder.Length())
	}
	_bsnvrfcounterstatsentry.Length = uint16(decoder.ReadUint16())
	oldDecoder := decoder
	defer func() { decoder = oldDecoder }()
	decoder = decoder.SliceDecoder(int(_bsnvrfcounterstatsentry.Length), 2+0)
	decoder.Skip(2)
	_bsnvrfcounterstatsentry.Vrf = uint32(decoder.ReadUint32())

	for decoder.Length() >= 8 {
		item, err := DecodeUint64(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_bsnvrfcounterstatsentry.Values = append(_bsnvrfcounterstatsentry.Values, item)
		}
	}
	return _bsnvrfcounterstatsentry, nil
}

func NewBsnVrfCounterStatsEntry() *BsnVrfCounterStatsEntry {
	obj := &BsnVrfCounterStatsEntry{}
	return obj
}

type Bucket struct {
	Len        uint16
	Weight     uint16
	WatchPort  Port
	WatchGroup uint32
	Actions    []goloxi.IAction
}

type IBucket interface {
	goloxi.Serializable
	GetLen() uint16
	GetWeight() uint16
	GetWatchPort() Port
	GetWatchGroup() uint32
	GetActions() []goloxi.IAction
}

func (self *Bucket) GetLen() uint16 {
	return self.Len
}

func (self *Bucket) SetLen(v uint16) {
	self.Len = v
}

func (self *Bucket) GetWeight() uint16 {
	return self.Weight
}

func (self *Bucket) SetWeight(v uint16) {
	self.Weight = v
}

func (self *Bucket) GetWatchPort() Port {
	return self.WatchPort
}

func (self *Bucket) SetWatchPort(v Port) {
	self.WatchPort = v
}

func (self *Bucket) GetWatchGroup() uint32 {
	return self.WatchGroup
}

func (self *Bucket) SetWatchGroup(v uint32) {
	self.WatchGroup = v
}

func (self *Bucket) GetActions() []goloxi.IAction {
	return self.Actions
}

func (self *Bucket) SetActions(v []goloxi.IAction) {
	self.Actions = v
}

func (self *Bucket) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())

	encoder.PutUint16(uint16(self.Len))
	encoder.PutUint16(uint16(self.Weight))
	self.WatchPort.Serialize(encoder)
	encoder.PutUint32(uint32(self.WatchGroup))
	encoder.Write(bytes.Repeat([]byte{0}, 4))
	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 DecodeBucket(decoder *goloxi.Decoder) (*Bucket, error) {
	_bucket := &Bucket{}
	if decoder.Length() < 16 {
		return nil, fmt.Errorf("Bucket packet too short: %d < 16", decoder.Length())
	}
	_bucket.Len = uint16(decoder.ReadUint16())
	oldDecoder := decoder
	defer func() { decoder = oldDecoder }()
	decoder = decoder.SliceDecoder(int(_bucket.Len), 2+0)
	_bucket.Weight = uint16(decoder.ReadUint16())
	_bucket.WatchPort.Decode(decoder)
	_bucket.WatchGroup = uint32(decoder.ReadUint32())
	decoder.Skip(4)

	for decoder.Length() >= 8 {
		item, err := DecodeAction(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_bucket.Actions = append(_bucket.Actions, item)
		}
	}
	return _bucket, nil
}

func NewBucket() *Bucket {
	obj := &Bucket{}
	return obj
}

type BucketCounter struct {
	PacketCount uint64
	ByteCount   uint64
}

type IBucketCounter interface {
	goloxi.Serializable
	GetPacketCount() uint64
	GetByteCount() uint64
}

func (self *BucketCounter) GetPacketCount() uint64 {
	return self.PacketCount
}

func (self *BucketCounter) SetPacketCount(v uint64) {
	self.PacketCount = v
}

func (self *BucketCounter) GetByteCount() uint64 {
	return self.ByteCount
}

func (self *BucketCounter) SetByteCount(v uint64) {
	self.ByteCount = v
}

func (self *BucketCounter) Serialize(encoder *goloxi.Encoder) error {

	encoder.PutUint64(uint64(self.PacketCount))
	encoder.PutUint64(uint64(self.ByteCount))

	return nil
}

func DecodeBucketCounter(decoder *goloxi.Decoder) (*BucketCounter, error) {
	_bucketcounter := &BucketCounter{}
	if decoder.Length() < 16 {
		return nil, fmt.Errorf("BucketCounter packet too short: %d < 16", decoder.Length())
	}
	_bucketcounter.PacketCount = uint64(decoder.ReadUint64())
	_bucketcounter.ByteCount = uint64(decoder.ReadUint64())
	return _bucketcounter, nil
}

func NewBucketCounter() *BucketCounter {
	obj := &BucketCounter{}
	return obj
}

type BundleProp struct {
	Type   uint16
	Length uint16
}

type IBundleProp interface {
	goloxi.Serializable
	GetType() uint16
	GetLength() uint16
}

func (self *BundleProp) GetType() uint16 {
	return self.Type
}

func (self *BundleProp) SetType(v uint16) {
	self.Type = v
}

func (self *BundleProp) GetLength() uint16 {
	return self.Length
}

func (self *BundleProp) SetLength(v uint16) {
	self.Length = v
}

func (self *BundleProp) Serialize(encoder *goloxi.Encoder) error {

	encoder.PutUint16(uint16(self.Type))
	encoder.PutUint16(uint16(self.Length))

	return nil
}

func DecodeBundleProp(decoder *goloxi.Decoder) (IBundleProp, error) {
	_bundleprop := &BundleProp{}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("BundleProp packet too short: %d < 4", decoder.Length())
	}
	_bundleprop.Type = uint16(decoder.ReadUint16())
	_bundleprop.Length = uint16(decoder.ReadUint16())
	oldDecoder := decoder
	defer func() { decoder = oldDecoder }()
	decoder = decoder.SliceDecoder(int(_bundleprop.Length), 2+2)

	switch _bundleprop.Type {
	case 65535:
		return DecodeBundlePropExperimenter(_bundleprop, decoder)
	default:
		return nil, fmt.Errorf("Invalid type '%d' for 'BundleProp'", _bundleprop.Type)
	}
}

func NewBundleProp(_type uint16) *BundleProp {
	obj := &BundleProp{}
	obj.Type = _type
	return obj
}

type BundlePropExperimenter struct {
	*BundleProp
	Experimenter uint32
	ExpType      uint32
}

type IBundlePropExperimenter interface {
	IBundleProp
	GetExperimenter() uint32
	GetExpType() uint32
}

func (self *BundlePropExperimenter) GetExperimenter() uint32 {
	return self.Experimenter
}

func (self *BundlePropExperimenter) SetExperimenter(v uint32) {
	self.Experimenter = v
}

func (self *BundlePropExperimenter) GetExpType() uint32 {
	return self.ExpType
}

func (self *BundlePropExperimenter) SetExpType(v uint32) {
	self.ExpType = v
}

func (self *BundlePropExperimenter) Serialize(encoder *goloxi.Encoder) error {
	if err := self.BundleProp.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint32(uint32(self.Experimenter))
	encoder.PutUint32(uint32(self.ExpType))

	return nil
}

func DecodeBundlePropExperimenter(parent *BundleProp, decoder *goloxi.Decoder) (IBundlePropExperimenter, error) {
	_bundlepropexperimenter := &BundlePropExperimenter{BundleProp: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("BundlePropExperimenter packet too short: %d < 8", decoder.Length())
	}
	_bundlepropexperimenter.Experimenter = uint32(decoder.ReadUint32())
	_bundlepropexperimenter.ExpType = uint32(decoder.ReadUint32())
	return _bundlepropexperimenter, nil
}

func NewBundlePropExperimenter(_experimenter uint32) *BundlePropExperimenter {
	obj := &BundlePropExperimenter{
		BundleProp: NewBundleProp(65535),
	}
	obj.Experimenter = _experimenter
	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 FlowMonitorEntry struct {
	MonitorId uint32
	OutPort   uint32
	OutGroup  uint32
	Flags     FlowMonitorFlags
	TableId   uint8
	Command   FlowMonitorCommand
	Match     Match
}

type IFlowMonitorEntry interface {
	goloxi.Serializable
	GetMonitorId() uint32
	GetOutPort() uint32
	GetOutGroup() uint32
	GetFlags() FlowMonitorFlags
	GetTableId() uint8
	GetCommand() FlowMonitorCommand
	GetMatch() Match
}

func (self *FlowMonitorEntry) GetMonitorId() uint32 {
	return self.MonitorId
}

func (self *FlowMonitorEntry) SetMonitorId(v uint32) {
	self.MonitorId = v
}

func (self *FlowMonitorEntry) GetOutPort() uint32 {
	return self.OutPort
}

func (self *FlowMonitorEntry) SetOutPort(v uint32) {
	self.OutPort = v
}

func (self *FlowMonitorEntry) GetOutGroup() uint32 {
	return self.OutGroup
}

func (self *FlowMonitorEntry) SetOutGroup(v uint32) {
	self.OutGroup = v
}

func (self *FlowMonitorEntry) GetFlags() FlowMonitorFlags {
	return self.Flags
}

func (self *FlowMonitorEntry) SetFlags(v FlowMonitorFlags) {
	self.Flags = v
}

func (self *FlowMonitorEntry) GetTableId() uint8 {
	return self.TableId
}

func (self *FlowMonitorEntry) SetTableId(v uint8) {
	self.TableId = v
}

func (self *FlowMonitorEntry) GetCommand() FlowMonitorCommand {
	return self.Command
}

func (self *FlowMonitorEntry) SetCommand(v FlowMonitorCommand) {
	self.Command = v
}

func (self *FlowMonitorEntry) GetMatch() Match {
	return self.Match
}

func (self *FlowMonitorEntry) SetMatch(v Match) {
	self.Match = v
}

func (self *FlowMonitorEntry) Serialize(encoder *goloxi.Encoder) error {

	encoder.PutUint32(uint32(self.MonitorId))
	encoder.PutUint32(uint32(self.OutPort))
	encoder.PutUint32(uint32(self.OutGroup))
	encoder.PutUint16(uint16(self.Flags))
	encoder.PutUint8(uint8(self.TableId))
	encoder.PutUint8(uint8(self.Command))
	if err := self.Match.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeFlowMonitorEntry(decoder *goloxi.Decoder) (*FlowMonitorEntry, error) {
	_flowmonitorentry := &FlowMonitorEntry{}
	if decoder.Length() < 24 {
		return nil, fmt.Errorf("FlowMonitorEntry packet too short: %d < 24", decoder.Length())
	}
	_flowmonitorentry.MonitorId = uint32(decoder.ReadUint32())
	_flowmonitorentry.OutPort = uint32(decoder.ReadUint32())
	_flowmonitorentry.OutGroup = uint32(decoder.ReadUint32())
	_flowmonitorentry.Flags = FlowMonitorFlags(decoder.ReadUint16())
	_flowmonitorentry.TableId = uint8(decoder.ReadByte())
	_flowmonitorentry.Command = FlowMonitorCommand(decoder.ReadByte())
	if err := _flowmonitorentry.Match.Decode(decoder); err != nil {
		return nil, err
	}

	decoder.SkipAlign()
	return _flowmonitorentry, nil
}

func NewFlowMonitorEntry() *FlowMonitorEntry {
	obj := &FlowMonitorEntry{}
	return obj
}

type FlowMonitorReplyEntry struct {
	Length uint16
	Event  FlowUpdateEvent
}

type IFlowMonitorReplyEntry interface {
	goloxi.Serializable
	GetLength() uint16
	GetEvent() FlowUpdateEvent
}

func (self *FlowMonitorReplyEntry) GetLength() uint16 {
	return self.Length
}

func (self *FlowMonitorReplyEntry) SetLength(v uint16) {
	self.Length = v
}

func (self *FlowMonitorReplyEntry) GetEvent() FlowUpdateEvent {
	return self.Event
}

func (self *FlowMonitorReplyEntry) SetEvent(v FlowUpdateEvent) {
	self.Event = v
}

func (self *FlowMonitorReplyEntry) Serialize(encoder *goloxi.Encoder) error {

	encoder.PutUint16(uint16(self.Length))
	encoder.PutUint16(uint16(self.Event))

	return nil
}

func DecodeFlowMonitorReplyEntry(decoder *goloxi.Decoder) (IFlowMonitorReplyEntry, error) {
	_flowmonitorreplyentry := &FlowMonitorReplyEntry{}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("FlowMonitorReplyEntry packet too short: %d < 4", decoder.Length())
	}
	_flowmonitorreplyentry.Length = uint16(decoder.ReadUint16())
	oldDecoder := decoder
	defer func() { decoder = oldDecoder }()
	decoder = decoder.SliceDecoder(int(_flowmonitorreplyentry.Length), 2+0)
	_flowmonitorreplyentry.Event = FlowUpdateEvent(decoder.ReadUint16())

	switch _flowmonitorreplyentry.Event {
	case 0:
		return DecodeFlowUpdateFullInitial(_flowmonitorreplyentry, decoder)
	case 1:
		return DecodeFlowUpdateFullAdded(_flowmonitorreplyentry, decoder)
	case 2:
		return DecodeFlowUpdateFullRemoved(_flowmonitorreplyentry, decoder)
	case 3:
		return DecodeFlowUpdateFullModified(_flowmonitorreplyentry, decoder)
	default:
		return nil, fmt.Errorf("Invalid type '%d' for 'FlowMonitorReplyEntry'", _flowmonitorreplyentry.Event)
	}
}

func NewFlowMonitorReplyEntry(_event FlowUpdateEvent) *FlowMonitorReplyEntry {
	obj := &FlowMonitorReplyEntry{}
	obj.Event = _event
	return obj
}

type FlowStatsEntry struct {
	Length       uint16
	TableId      uint8
	DurationSec  uint32
	DurationNsec uint32
	Priority     uint16
	IdleTimeout  uint16
	HardTimeout  uint16
	Flags        FlowModFlags
	Importance   uint16
	Cookie       uint64
	PacketCount  uint64
	ByteCount    uint64
	Match        Match
	Instructions []IInstruction
}

type IFlowStatsEntry interface {
	goloxi.Serializable
	GetLength() uint16
	GetTableId() uint8
	GetDurationSec() uint32
	GetDurationNsec() uint32
	GetPriority() uint16
	GetIdleTimeout() uint16
	GetHardTimeout() uint16
	GetFlags() FlowModFlags
	GetImportance() uint16
	GetCookie() uint64
	GetPacketCount() uint64
	GetByteCount() uint64
	GetMatch() Match
	GetInstructions() []IInstruction
}

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) 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) GetFlags() FlowModFlags {
	return self.Flags
}

func (self *FlowStatsEntry) SetFlags(v FlowModFlags) {
	self.Flags = v
}

func (self *FlowStatsEntry) GetImportance() uint16 {
	return self.Importance
}

func (self *FlowStatsEntry) SetImportance(v uint16) {
	self.Importance = 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) GetMatch() Match {
	return self.Match
}

func (self *FlowStatsEntry) SetMatch(v Match) {
	self.Match = v
}

func (self *FlowStatsEntry) GetInstructions() []IInstruction {
	return self.Instructions
}

func (self *FlowStatsEntry) SetInstructions(v []IInstruction) {
	self.Instructions = 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))
	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.Flags))
	encoder.PutUint16(uint16(self.Importance))
	encoder.Write(bytes.Repeat([]byte{0}, 2))
	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.Instructions {
		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() < 56 {
		return nil, fmt.Errorf("FlowStatsEntry packet too short: %d < 56", 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)
	_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())
	_flowstatsentry.Flags = FlowModFlags(decoder.ReadUint16())
	_flowstatsentry.Importance = uint16(decoder.ReadUint16())
	decoder.Skip(2)
	_flowstatsentry.Cookie = uint64(decoder.ReadUint64())
	_flowstatsentry.PacketCount = uint64(decoder.ReadUint64())
	_flowstatsentry.ByteCount = uint64(decoder.ReadUint64())
	if err := _flowstatsentry.Match.Decode(decoder); err != nil {
		return nil, err
	}

	decoder.SkipAlign()

	for decoder.Length() >= 4 {
		item, err := DecodeInstruction(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_flowstatsentry.Instructions = append(_flowstatsentry.Instructions, item)
		}
	}
	return _flowstatsentry, nil
}

func NewFlowStatsEntry() *FlowStatsEntry {
	obj := &FlowStatsEntry{}
	return obj
}

type FlowUpdateFullAdded struct {
	*FlowMonitorReplyEntry
	TableId      uint8
	Reason       uint8
	IdleTimeout  uint16
	HardTimeout  uint16
	Priority     uint16
	Cookie       uint64
	Match        Match
	Instructions []IInstruction
}

type IFlowUpdateFullAdded interface {
	IFlowMonitorReplyEntry
	GetTableId() uint8
	GetReason() uint8
	GetIdleTimeout() uint16
	GetHardTimeout() uint16
	GetPriority() uint16
	GetCookie() uint64
	GetMatch() Match
	GetInstructions() []IInstruction
}

func (self *FlowUpdateFullAdded) GetTableId() uint8 {
	return self.TableId
}

func (self *FlowUpdateFullAdded) SetTableId(v uint8) {
	self.TableId = v
}

func (self *FlowUpdateFullAdded) GetReason() uint8 {
	return self.Reason
}

func (self *FlowUpdateFullAdded) SetReason(v uint8) {
	self.Reason = v
}

func (self *FlowUpdateFullAdded) GetIdleTimeout() uint16 {
	return self.IdleTimeout
}

func (self *FlowUpdateFullAdded) SetIdleTimeout(v uint16) {
	self.IdleTimeout = v
}

func (self *FlowUpdateFullAdded) GetHardTimeout() uint16 {
	return self.HardTimeout
}

func (self *FlowUpdateFullAdded) SetHardTimeout(v uint16) {
	self.HardTimeout = v
}

func (self *FlowUpdateFullAdded) GetPriority() uint16 {
	return self.Priority
}

func (self *FlowUpdateFullAdded) SetPriority(v uint16) {
	self.Priority = v
}

func (self *FlowUpdateFullAdded) GetCookie() uint64 {
	return self.Cookie
}

func (self *FlowUpdateFullAdded) SetCookie(v uint64) {
	self.Cookie = v
}

func (self *FlowUpdateFullAdded) GetMatch() Match {
	return self.Match
}

func (self *FlowUpdateFullAdded) SetMatch(v Match) {
	self.Match = v
}

func (self *FlowUpdateFullAdded) GetInstructions() []IInstruction {
	return self.Instructions
}

func (self *FlowUpdateFullAdded) SetInstructions(v []IInstruction) {
	self.Instructions = v
}

func (self *FlowUpdateFullAdded) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.FlowMonitorReplyEntry.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint8(uint8(self.TableId))
	encoder.PutUint8(uint8(self.Reason))
	encoder.PutUint16(uint16(self.IdleTimeout))
	encoder.PutUint16(uint16(self.HardTimeout))
	encoder.PutUint16(uint16(self.Priority))
	encoder.Write(bytes.Repeat([]byte{0}, 4))
	encoder.PutUint64(uint64(self.Cookie))
	if err := self.Match.Serialize(encoder); err != nil {
		return err
	}

	for _, obj := range self.Instructions {
		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 DecodeFlowUpdateFullAdded(parent *FlowMonitorReplyEntry, decoder *goloxi.Decoder) (*FlowUpdateFullAdded, error) {
	_flowupdatefulladded := &FlowUpdateFullAdded{FlowMonitorReplyEntry: parent}
	if decoder.Length() < 28 {
		return nil, fmt.Errorf("FlowUpdateFullAdded packet too short: %d < 28", decoder.Length())
	}
	_flowupdatefulladded.TableId = uint8(decoder.ReadByte())
	_flowupdatefulladded.Reason = uint8(decoder.ReadByte())
	_flowupdatefulladded.IdleTimeout = uint16(decoder.ReadUint16())
	_flowupdatefulladded.HardTimeout = uint16(decoder.ReadUint16())
	_flowupdatefulladded.Priority = uint16(decoder.ReadUint16())
	decoder.Skip(4)
	_flowupdatefulladded.Cookie = uint64(decoder.ReadUint64())
	if err := _flowupdatefulladded.Match.Decode(decoder); err != nil {
		return nil, err
	}

	decoder.SkipAlign()

	for decoder.Length() >= 4 {
		item, err := DecodeInstruction(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_flowupdatefulladded.Instructions = append(_flowupdatefulladded.Instructions, item)
		}
	}
	return _flowupdatefulladded, nil
}

func NewFlowUpdateFullAdded() *FlowUpdateFullAdded {
	obj := &FlowUpdateFullAdded{
		FlowMonitorReplyEntry: NewFlowMonitorReplyEntry(1),
	}
	return obj
}

type FlowUpdateFullInitial struct {
	*FlowMonitorReplyEntry
	TableId      uint8
	Reason       uint8
	IdleTimeout  uint16
	HardTimeout  uint16
	Priority     uint16
	Cookie       uint64
	Match        Match
	Instructions []IInstruction
}

type IFlowUpdateFullInitial interface {
	IFlowMonitorReplyEntry
	GetTableId() uint8
	GetReason() uint8
	GetIdleTimeout() uint16
	GetHardTimeout() uint16
	GetPriority() uint16
	GetCookie() uint64
	GetMatch() Match
	GetInstructions() []IInstruction
}

func (self *FlowUpdateFullInitial) GetTableId() uint8 {
	return self.TableId
}

func (self *FlowUpdateFullInitial) SetTableId(v uint8) {
	self.TableId = v
}

func (self *FlowUpdateFullInitial) GetReason() uint8 {
	return self.Reason
}

func (self *FlowUpdateFullInitial) SetReason(v uint8) {
	self.Reason = v
}

func (self *FlowUpdateFullInitial) GetIdleTimeout() uint16 {
	return self.IdleTimeout
}

func (self *FlowUpdateFullInitial) SetIdleTimeout(v uint16) {
	self.IdleTimeout = v
}

func (self *FlowUpdateFullInitial) GetHardTimeout() uint16 {
	return self.HardTimeout
}

func (self *FlowUpdateFullInitial) SetHardTimeout(v uint16) {
	self.HardTimeout = v
}

func (self *FlowUpdateFullInitial) GetPriority() uint16 {
	return self.Priority
}

func (self *FlowUpdateFullInitial) SetPriority(v uint16) {
	self.Priority = v
}

func (self *FlowUpdateFullInitial) GetCookie() uint64 {
	return self.Cookie
}

func (self *FlowUpdateFullInitial) SetCookie(v uint64) {
	self.Cookie = v
}

func (self *FlowUpdateFullInitial) GetMatch() Match {
	return self.Match
}

func (self *FlowUpdateFullInitial) SetMatch(v Match) {
	self.Match = v
}

func (self *FlowUpdateFullInitial) GetInstructions() []IInstruction {
	return self.Instructions
}

func (self *FlowUpdateFullInitial) SetInstructions(v []IInstruction) {
	self.Instructions = v
}

func (self *FlowUpdateFullInitial) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.FlowMonitorReplyEntry.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint8(uint8(self.TableId))
	encoder.PutUint8(uint8(self.Reason))
	encoder.PutUint16(uint16(self.IdleTimeout))
	encoder.PutUint16(uint16(self.HardTimeout))
	encoder.PutUint16(uint16(self.Priority))
	encoder.Write(bytes.Repeat([]byte{0}, 4))
	encoder.PutUint64(uint64(self.Cookie))
	if err := self.Match.Serialize(encoder); err != nil {
		return err
	}

	for _, obj := range self.Instructions {
		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 DecodeFlowUpdateFullInitial(parent *FlowMonitorReplyEntry, decoder *goloxi.Decoder) (*FlowUpdateFullInitial, error) {
	_flowupdatefullinitial := &FlowUpdateFullInitial{FlowMonitorReplyEntry: parent}
	if decoder.Length() < 28 {
		return nil, fmt.Errorf("FlowUpdateFullInitial packet too short: %d < 28", decoder.Length())
	}
	_flowupdatefullinitial.TableId = uint8(decoder.ReadByte())
	_flowupdatefullinitial.Reason = uint8(decoder.ReadByte())
	_flowupdatefullinitial.IdleTimeout = uint16(decoder.ReadUint16())
	_flowupdatefullinitial.HardTimeout = uint16(decoder.ReadUint16())
	_flowupdatefullinitial.Priority = uint16(decoder.ReadUint16())
	decoder.Skip(4)
	_flowupdatefullinitial.Cookie = uint64(decoder.ReadUint64())
	if err := _flowupdatefullinitial.Match.Decode(decoder); err != nil {
		return nil, err
	}

	decoder.SkipAlign()

	for decoder.Length() >= 4 {
		item, err := DecodeInstruction(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_flowupdatefullinitial.Instructions = append(_flowupdatefullinitial.Instructions, item)
		}
	}
	return _flowupdatefullinitial, nil
}

func NewFlowUpdateFullInitial() *FlowUpdateFullInitial {
	obj := &FlowUpdateFullInitial{
		FlowMonitorReplyEntry: NewFlowMonitorReplyEntry(0),
	}
	return obj
}

type FlowUpdateFullModified struct {
	*FlowMonitorReplyEntry
	TableId      uint8
	Reason       uint8
	IdleTimeout  uint16
	HardTimeout  uint16
	Priority     uint16
	Cookie       uint64
	Match        Match
	Instructions []IInstruction
}

type IFlowUpdateFullModified interface {
	IFlowMonitorReplyEntry
	GetTableId() uint8
	GetReason() uint8
	GetIdleTimeout() uint16
	GetHardTimeout() uint16
	GetPriority() uint16
	GetCookie() uint64
	GetMatch() Match
	GetInstructions() []IInstruction
}

func (self *FlowUpdateFullModified) GetTableId() uint8 {
	return self.TableId
}

func (self *FlowUpdateFullModified) SetTableId(v uint8) {
	self.TableId = v
}

func (self *FlowUpdateFullModified) GetReason() uint8 {
	return self.Reason
}

func (self *FlowUpdateFullModified) SetReason(v uint8) {
	self.Reason = v
}

func (self *FlowUpdateFullModified) GetIdleTimeout() uint16 {
	return self.IdleTimeout
}

func (self *FlowUpdateFullModified) SetIdleTimeout(v uint16) {
	self.IdleTimeout = v
}

func (self *FlowUpdateFullModified) GetHardTimeout() uint16 {
	return self.HardTimeout
}

func (self *FlowUpdateFullModified) SetHardTimeout(v uint16) {
	self.HardTimeout = v
}

func (self *FlowUpdateFullModified) GetPriority() uint16 {
	return self.Priority
}

func (self *FlowUpdateFullModified) SetPriority(v uint16) {
	self.Priority = v
}

func (self *FlowUpdateFullModified) GetCookie() uint64 {
	return self.Cookie
}

func (self *FlowUpdateFullModified) SetCookie(v uint64) {
	self.Cookie = v
}

func (self *FlowUpdateFullModified) GetMatch() Match {
	return self.Match
}

func (self *FlowUpdateFullModified) SetMatch(v Match) {
	self.Match = v
}

func (self *FlowUpdateFullModified) GetInstructions() []IInstruction {
	return self.Instructions
}

func (self *FlowUpdateFullModified) SetInstructions(v []IInstruction) {
	self.Instructions = v
}

func (self *FlowUpdateFullModified) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.FlowMonitorReplyEntry.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint8(uint8(self.TableId))
	encoder.PutUint8(uint8(self.Reason))
	encoder.PutUint16(uint16(self.IdleTimeout))
	encoder.PutUint16(uint16(self.HardTimeout))
	encoder.PutUint16(uint16(self.Priority))
	encoder.Write(bytes.Repeat([]byte{0}, 4))
	encoder.PutUint64(uint64(self.Cookie))
	if err := self.Match.Serialize(encoder); err != nil {
		return err
	}

	for _, obj := range self.Instructions {
		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 DecodeFlowUpdateFullModified(parent *FlowMonitorReplyEntry, decoder *goloxi.Decoder) (*FlowUpdateFullModified, error) {
	_flowupdatefullmodified := &FlowUpdateFullModified{FlowMonitorReplyEntry: parent}
	if decoder.Length() < 28 {
		return nil, fmt.Errorf("FlowUpdateFullModified packet too short: %d < 28", decoder.Length())
	}
	_flowupdatefullmodified.TableId = uint8(decoder.ReadByte())
	_flowupdatefullmodified.Reason = uint8(decoder.ReadByte())
	_flowupdatefullmodified.IdleTimeout = uint16(decoder.ReadUint16())
	_flowupdatefullmodified.HardTimeout = uint16(decoder.ReadUint16())
	_flowupdatefullmodified.Priority = uint16(decoder.ReadUint16())
	decoder.Skip(4)
	_flowupdatefullmodified.Cookie = uint64(decoder.ReadUint64())
	if err := _flowupdatefullmodified.Match.Decode(decoder); err != nil {
		return nil, err
	}

	decoder.SkipAlign()

	for decoder.Length() >= 4 {
		item, err := DecodeInstruction(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_flowupdatefullmodified.Instructions = append(_flowupdatefullmodified.Instructions, item)
		}
	}
	return _flowupdatefullmodified, nil
}

func NewFlowUpdateFullModified() *FlowUpdateFullModified {
	obj := &FlowUpdateFullModified{
		FlowMonitorReplyEntry: NewFlowMonitorReplyEntry(3),
	}
	return obj
}

type FlowUpdateFullRemoved struct {
	*FlowMonitorReplyEntry
	TableId      uint8
	Reason       uint8
	IdleTimeout  uint16
	HardTimeout  uint16
	Priority     uint16
	Cookie       uint64
	Match        Match
	Instructions []IInstruction
}

type IFlowUpdateFullRemoved interface {
	IFlowMonitorReplyEntry
	GetTableId() uint8
	GetReason() uint8
	GetIdleTimeout() uint16
	GetHardTimeout() uint16
	GetPriority() uint16
	GetCookie() uint64
	GetMatch() Match
	GetInstructions() []IInstruction
}

func (self *FlowUpdateFullRemoved) GetTableId() uint8 {
	return self.TableId
}

func (self *FlowUpdateFullRemoved) SetTableId(v uint8) {
	self.TableId = v
}

func (self *FlowUpdateFullRemoved) GetReason() uint8 {
	return self.Reason
}

func (self *FlowUpdateFullRemoved) SetReason(v uint8) {
	self.Reason = v
}

func (self *FlowUpdateFullRemoved) GetIdleTimeout() uint16 {
	return self.IdleTimeout
}

func (self *FlowUpdateFullRemoved) SetIdleTimeout(v uint16) {
	self.IdleTimeout = v
}

func (self *FlowUpdateFullRemoved) GetHardTimeout() uint16 {
	return self.HardTimeout
}

func (self *FlowUpdateFullRemoved) SetHardTimeout(v uint16) {
	self.HardTimeout = v
}

func (self *FlowUpdateFullRemoved) GetPriority() uint16 {
	return self.Priority
}

func (self *FlowUpdateFullRemoved) SetPriority(v uint16) {
	self.Priority = v
}

func (self *FlowUpdateFullRemoved) GetCookie() uint64 {
	return self.Cookie
}

func (self *FlowUpdateFullRemoved) SetCookie(v uint64) {
	self.Cookie = v
}

func (self *FlowUpdateFullRemoved) GetMatch() Match {
	return self.Match
}

func (self *FlowUpdateFullRemoved) SetMatch(v Match) {
	self.Match = v
}

func (self *FlowUpdateFullRemoved) GetInstructions() []IInstruction {
	return self.Instructions
}

func (self *FlowUpdateFullRemoved) SetInstructions(v []IInstruction) {
	self.Instructions = v
}

func (self *FlowUpdateFullRemoved) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.FlowMonitorReplyEntry.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint8(uint8(self.TableId))
	encoder.PutUint8(uint8(self.Reason))
	encoder.PutUint16(uint16(self.IdleTimeout))
	encoder.PutUint16(uint16(self.HardTimeout))
	encoder.PutUint16(uint16(self.Priority))
	encoder.Write(bytes.Repeat([]byte{0}, 4))
	encoder.PutUint64(uint64(self.Cookie))
	if err := self.Match.Serialize(encoder); err != nil {
		return err
	}

	for _, obj := range self.Instructions {
		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 DecodeFlowUpdateFullRemoved(parent *FlowMonitorReplyEntry, decoder *goloxi.Decoder) (*FlowUpdateFullRemoved, error) {
	_flowupdatefullremoved := &FlowUpdateFullRemoved{FlowMonitorReplyEntry: parent}
	if decoder.Length() < 28 {
		return nil, fmt.Errorf("FlowUpdateFullRemoved packet too short: %d < 28", decoder.Length())
	}
	_flowupdatefullremoved.TableId = uint8(decoder.ReadByte())
	_flowupdatefullremoved.Reason = uint8(decoder.ReadByte())
	_flowupdatefullremoved.IdleTimeout = uint16(decoder.ReadUint16())
	_flowupdatefullremoved.HardTimeout = uint16(decoder.ReadUint16())
	_flowupdatefullremoved.Priority = uint16(decoder.ReadUint16())
	decoder.Skip(4)
	_flowupdatefullremoved.Cookie = uint64(decoder.ReadUint64())
	if err := _flowupdatefullremoved.Match.Decode(decoder); err != nil {
		return nil, err
	}

	decoder.SkipAlign()

	for decoder.Length() >= 4 {
		item, err := DecodeInstruction(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_flowupdatefullremoved.Instructions = append(_flowupdatefullremoved.Instructions, item)
		}
	}
	return _flowupdatefullremoved, nil
}

func NewFlowUpdateFullRemoved() *FlowUpdateFullRemoved {
	obj := &FlowUpdateFullRemoved{
		FlowMonitorReplyEntry: NewFlowMonitorReplyEntry(2),
	}
	return obj
}

type GroupDescStatsEntry struct {
	Length    uint16
	GroupType GroupType
	GroupId   uint32
	Buckets   []*Bucket
}

type IGroupDescStatsEntry interface {
	goloxi.Serializable
	GetLength() uint16
	GetGroupType() GroupType
	GetGroupId() uint32
	GetBuckets() []*Bucket
}

func (self *GroupDescStatsEntry) GetLength() uint16 {
	return self.Length
}

func (self *GroupDescStatsEntry) SetLength(v uint16) {
	self.Length = v
}

func (self *GroupDescStatsEntry) GetGroupType() GroupType {
	return self.GroupType
}

func (self *GroupDescStatsEntry) SetGroupType(v GroupType) {
	self.GroupType = v
}

func (self *GroupDescStatsEntry) GetGroupId() uint32 {
	return self.GroupId
}

func (self *GroupDescStatsEntry) SetGroupId(v uint32) {
	self.GroupId = v
}

func (self *GroupDescStatsEntry) GetBuckets() []*Bucket {
	return self.Buckets
}

func (self *GroupDescStatsEntry) SetBuckets(v []*Bucket) {
	self.Buckets = v
}

func (self *GroupDescStatsEntry) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())

	encoder.PutUint16(uint16(self.Length))
	encoder.PutUint8(uint8(self.GroupType))
	encoder.Write(bytes.Repeat([]byte{0}, 1))
	encoder.PutUint32(uint32(self.GroupId))
	for _, obj := range self.Buckets {
		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 DecodeGroupDescStatsEntry(decoder *goloxi.Decoder) (*GroupDescStatsEntry, error) {
	_groupdescstatsentry := &GroupDescStatsEntry{}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("GroupDescStatsEntry packet too short: %d < 8", decoder.Length())
	}
	_groupdescstatsentry.Length = uint16(decoder.ReadUint16())
	oldDecoder := decoder
	defer func() { decoder = oldDecoder }()
	decoder = decoder.SliceDecoder(int(_groupdescstatsentry.Length), 2+0)
	_groupdescstatsentry.GroupType = GroupType(decoder.ReadByte())
	decoder.Skip(1)
	_groupdescstatsentry.GroupId = uint32(decoder.ReadUint32())

	for decoder.Length() >= 16 {
		item, err := DecodeBucket(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_groupdescstatsentry.Buckets = append(_groupdescstatsentry.Buckets, item)
		}
	}
	return _groupdescstatsentry, nil
}

func NewGroupDescStatsEntry() *GroupDescStatsEntry {
	obj := &GroupDescStatsEntry{}
	return obj
}

type GroupStatsEntry struct {
	Length       uint16
	GroupId      uint32
	RefCount     uint32
	PacketCount  uint64
	ByteCount    uint64
	DurationSec  uint32
	DurationNsec uint32
	BucketStats  []*BucketCounter
}

type IGroupStatsEntry interface {
	goloxi.Serializable
	GetLength() uint16
	GetGroupId() uint32
	GetRefCount() uint32
	GetPacketCount() uint64
	GetByteCount() uint64
	GetDurationSec() uint32
	GetDurationNsec() uint32
	GetBucketStats() []*BucketCounter
}

func (self *GroupStatsEntry) GetLength() uint16 {
	return self.Length
}

func (self *GroupStatsEntry) SetLength(v uint16) {
	self.Length = v
}

func (self *GroupStatsEntry) GetGroupId() uint32 {
	return self.GroupId
}

func (self *GroupStatsEntry) SetGroupId(v uint32) {
	self.GroupId = v
}

func (self *GroupStatsEntry) GetRefCount() uint32 {
	return self.RefCount
}

func (self *GroupStatsEntry) SetRefCount(v uint32) {
	self.RefCount = v
}

func (self *GroupStatsEntry) GetPacketCount() uint64 {
	return self.PacketCount
}

func (self *GroupStatsEntry) SetPacketCount(v uint64) {
	self.PacketCount = v
}

func (self *GroupStatsEntry) GetByteCount() uint64 {
	return self.ByteCount
}

func (self *GroupStatsEntry) SetByteCount(v uint64) {
	self.ByteCount = v
}

func (self *GroupStatsEntry) GetDurationSec() uint32 {
	return self.DurationSec
}

func (self *GroupStatsEntry) SetDurationSec(v uint32) {
	self.DurationSec = v
}

func (self *GroupStatsEntry) GetDurationNsec() uint32 {
	return self.DurationNsec
}

func (self *GroupStatsEntry) SetDurationNsec(v uint32) {
	self.DurationNsec = v
}

func (self *GroupStatsEntry) GetBucketStats() []*BucketCounter {
	return self.BucketStats
}

func (self *GroupStatsEntry) SetBucketStats(v []*BucketCounter) {
	self.BucketStats = v
}

func (self *GroupStatsEntry) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())

	encoder.PutUint16(uint16(self.Length))
	encoder.Write(bytes.Repeat([]byte{0}, 2))
	encoder.PutUint32(uint32(self.GroupId))
	encoder.PutUint32(uint32(self.RefCount))
	encoder.Write(bytes.Repeat([]byte{0}, 4))
	encoder.PutUint64(uint64(self.PacketCount))
	encoder.PutUint64(uint64(self.ByteCount))
	encoder.PutUint32(uint32(self.DurationSec))
	encoder.PutUint32(uint32(self.DurationNsec))
	for _, obj := range self.BucketStats {
		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 DecodeGroupStatsEntry(decoder *goloxi.Decoder) (*GroupStatsEntry, error) {
	_groupstatsentry := &GroupStatsEntry{}
	if decoder.Length() < 40 {
		return nil, fmt.Errorf("GroupStatsEntry packet too short: %d < 40", decoder.Length())
	}
	_groupstatsentry.Length = uint16(decoder.ReadUint16())
	oldDecoder := decoder
	defer func() { decoder = oldDecoder }()
	decoder = decoder.SliceDecoder(int(_groupstatsentry.Length), 2+0)
	decoder.Skip(2)
	_groupstatsentry.GroupId = uint32(decoder.ReadUint32())
	_groupstatsentry.RefCount = uint32(decoder.ReadUint32())
	decoder.Skip(4)
	_groupstatsentry.PacketCount = uint64(decoder.ReadUint64())
	_groupstatsentry.ByteCount = uint64(decoder.ReadUint64())
	_groupstatsentry.DurationSec = uint32(decoder.ReadUint32())
	_groupstatsentry.DurationNsec = uint32(decoder.ReadUint32())

	for decoder.Length() >= 16 {
		item, err := DecodeBucketCounter(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_groupstatsentry.BucketStats = append(_groupstatsentry.BucketStats, item)
		}
	}
	return _groupstatsentry, nil
}

func NewGroupStatsEntry() *GroupStatsEntry {
	obj := &GroupStatsEntry{}
	return obj
}

type HelloElem struct {
	Type   uint16
	Length uint16
}

type IHelloElem interface {
	goloxi.Serializable
	GetType() uint16
	GetLength() uint16
}

func (self *HelloElem) GetType() uint16 {
	return self.Type
}

func (self *HelloElem) SetType(v uint16) {
	self.Type = v
}

func (self *HelloElem) GetLength() uint16 {
	return self.Length
}

func (self *HelloElem) SetLength(v uint16) {
	self.Length = v
}

func (self *HelloElem) Serialize(encoder *goloxi.Encoder) error {

	encoder.PutUint16(uint16(self.Type))
	encoder.PutUint16(uint16(self.Length))

	return nil
}

func DecodeHelloElem(decoder *goloxi.Decoder) (IHelloElem, error) {
	_helloelem := &HelloElem{}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("HelloElem packet too short: %d < 4", decoder.Length())
	}
	_helloelem.Type = uint16(decoder.ReadUint16())
	_helloelem.Length = uint16(decoder.ReadUint16())
	oldDecoder := decoder
	defer func() { decoder = oldDecoder }()
	decoder = decoder.SliceDecoder(int(_helloelem.Length), 2+2)

	switch _helloelem.Type {
	case 1:
		return DecodeHelloElemVersionbitmap(_helloelem, decoder)
	default:
		return nil, fmt.Errorf("Invalid type '%d' for 'HelloElem'", _helloelem.Type)
	}
}

func NewHelloElem(_type uint16) *HelloElem {
	obj := &HelloElem{}
	obj.Type = _type
	return obj
}

type HelloElemVersionbitmap struct {
	*HelloElem
	Bitmaps []*Uint32
}

type IHelloElemVersionbitmap interface {
	IHelloElem
	GetBitmaps() []*Uint32
}

func (self *HelloElemVersionbitmap) GetBitmaps() []*Uint32 {
	return self.Bitmaps
}

func (self *HelloElemVersionbitmap) SetBitmaps(v []*Uint32) {
	self.Bitmaps = v
}

func (self *HelloElemVersionbitmap) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.HelloElem.Serialize(encoder); err != nil {
		return err
	}

	for _, obj := range self.Bitmaps {
		if err := obj.Serialize(encoder); err != nil {
			return err
		}
	}
	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 DecodeHelloElemVersionbitmap(parent *HelloElem, decoder *goloxi.Decoder) (*HelloElemVersionbitmap, error) {
	_helloelemversionbitmap := &HelloElemVersionbitmap{HelloElem: parent}

	for decoder.Length() >= 4 {
		item, err := DecodeUint32(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_helloelemversionbitmap.Bitmaps = append(_helloelemversionbitmap.Bitmaps, item)
		}
	}
	return _helloelemversionbitmap, nil
}

func NewHelloElemVersionbitmap() *HelloElemVersionbitmap {
	obj := &HelloElemVersionbitmap{
		HelloElem: NewHelloElem(1),
	}
	return obj
}

type InstructionId struct {
	Type uint16
	Len  uint16
}

type IInstructionId interface {
	goloxi.Serializable
	GetType() uint16
	GetLen() uint16
}

func (self *InstructionId) GetType() uint16 {
	return self.Type
}

func (self *InstructionId) SetType(v uint16) {
	self.Type = v
}

func (self *InstructionId) GetLen() uint16 {
	return self.Len
}

func (self *InstructionId) SetLen(v uint16) {
	self.Len = v
}

func (self *InstructionId) Serialize(encoder *goloxi.Encoder) error {

	encoder.PutUint16(uint16(self.Type))
	encoder.PutUint16(uint16(self.Len))

	return nil
}

func DecodeInstructionId(decoder *goloxi.Decoder) (IInstructionId, error) {
	_instructionid := &InstructionId{}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("InstructionId packet too short: %d < 4", decoder.Length())
	}
	_instructionid.Type = uint16(decoder.ReadUint16())
	_instructionid.Len = uint16(decoder.ReadUint16())
	oldDecoder := decoder
	defer func() { decoder = oldDecoder }()
	decoder = decoder.SliceDecoder(int(_instructionid.Len), 2+2)

	switch _instructionid.Type {
	case 1:
		return DecodeInstructionIdGotoTable(_instructionid, decoder)
	case 2:
		return DecodeInstructionIdWriteMetadata(_instructionid, decoder)
	case 3:
		return DecodeInstructionIdWriteActions(_instructionid, decoder)
	case 4:
		return DecodeInstructionIdApplyActions(_instructionid, decoder)
	case 5:
		return DecodeInstructionIdClearActions(_instructionid, decoder)
	case 6:
		return DecodeInstructionIdMeter(_instructionid, decoder)
	case 65535:
		return DecodeInstructionIdExperimenter(_instructionid, decoder)
	default:
		return nil, fmt.Errorf("Invalid type '%d' for 'InstructionId'", _instructionid.Type)
	}
}

func NewInstructionId(_type uint16) *InstructionId {
	obj := &InstructionId{}
	obj.Type = _type
	return obj
}

type InstructionIdApplyActions struct {
	*InstructionId
}

type IInstructionIdApplyActions interface {
	IInstructionId
}

func (self *InstructionIdApplyActions) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.InstructionId.Serialize(encoder); err != nil {
		return err
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeInstructionIdApplyActions(parent *InstructionId, decoder *goloxi.Decoder) (*InstructionIdApplyActions, error) {
	_instructionidapplyactions := &InstructionIdApplyActions{InstructionId: parent}
	return _instructionidapplyactions, nil
}

func NewInstructionIdApplyActions() *InstructionIdApplyActions {
	obj := &InstructionIdApplyActions{
		InstructionId: NewInstructionId(4),
	}
	return obj
}

type InstructionIdExperimenter struct {
	*InstructionId
	Experimenter uint32
}

type IInstructionIdExperimenter interface {
	IInstructionId
	GetExperimenter() uint32
}

func (self *InstructionIdExperimenter) GetExperimenter() uint32 {
	return self.Experimenter
}

func (self *InstructionIdExperimenter) SetExperimenter(v uint32) {
	self.Experimenter = v
}

func (self *InstructionIdExperimenter) Serialize(encoder *goloxi.Encoder) error {
	if err := self.InstructionId.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint32(uint32(self.Experimenter))

	return nil
}

func DecodeInstructionIdExperimenter(parent *InstructionId, decoder *goloxi.Decoder) (IInstructionIdExperimenter, error) {
	_instructionidexperimenter := &InstructionIdExperimenter{InstructionId: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("InstructionIdExperimenter packet too short: %d < 4", decoder.Length())
	}
	_instructionidexperimenter.Experimenter = uint32(decoder.ReadUint32())

	switch _instructionidexperimenter.Experimenter {
	case 6035143:
		return DecodeInstructionIdBsn(_instructionidexperimenter, decoder)
	default:
		return nil, fmt.Errorf("Invalid type '%d' for 'InstructionIdExperimenter'", _instructionidexperimenter.Experimenter)
	}
}

func NewInstructionIdExperimenter(_experimenter uint32) *InstructionIdExperimenter {
	obj := &InstructionIdExperimenter{
		InstructionId: NewInstructionId(65535),
	}
	obj.Experimenter = _experimenter
	return obj
}

type InstructionIdBsn struct {
	*InstructionIdExperimenter
	Subtype uint32
}

type IInstructionIdBsn interface {
	IInstructionIdExperimenter
	GetSubtype() uint32
}

func (self *InstructionIdBsn) GetSubtype() uint32 {
	return self.Subtype
}

func (self *InstructionIdBsn) SetSubtype(v uint32) {
	self.Subtype = v
}

func (self *InstructionIdBsn) Serialize(encoder *goloxi.Encoder) error {
	if err := self.InstructionIdExperimenter.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint32(uint32(self.Subtype))

	return nil
}

func DecodeInstructionIdBsn(parent *InstructionIdExperimenter, decoder *goloxi.Decoder) (IInstructionIdBsn, error) {
	_instructionidbsn := &InstructionIdBsn{InstructionIdExperimenter: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("InstructionIdBsn packet too short: %d < 4", decoder.Length())
	}
	_instructionidbsn.Subtype = uint32(decoder.ReadUint32())

	switch _instructionidbsn.Subtype {
	case 0:
		return DecodeInstructionIdBsnDisableSrcMacCheck(_instructionidbsn, decoder)
	case 1:
		return DecodeInstructionIdBsnArpOffload(_instructionidbsn, decoder)
	case 2:
		return DecodeInstructionIdBsnDhcpOffload(_instructionidbsn, decoder)
	case 4:
		return DecodeInstructionIdBsnPermit(_instructionidbsn, decoder)
	case 5:
		return DecodeInstructionIdBsnDeny(_instructionidbsn, decoder)
	case 6:
		return DecodeInstructionIdBsnPacketOfDeath(_instructionidbsn, decoder)
	case 7:
		return DecodeInstructionIdBsnPrioritizePdus(_instructionidbsn, decoder)
	case 8:
		return DecodeInstructionIdBsnRequireVlanXlate(_instructionidbsn, decoder)
	case 9:
		return DecodeInstructionIdBsnDisableVlanCounters(_instructionidbsn, decoder)
	case 10:
		return DecodeInstructionIdBsnSpanDestination(_instructionidbsn, decoder)
	case 11:
		return DecodeInstructionIdBsnAutoNegotiation(_instructionidbsn, decoder)
	case 12:
		return DecodeInstructionIdBsnInternalPriority(_instructionidbsn, decoder)
	case 13:
		return DecodeInstructionIdBsnDisableL3(_instructionidbsn, decoder)
	case 14:
		return DecodeInstructionIdBsnNdpOffload(_instructionidbsn, decoder)
	case 15:
		return DecodeInstructionIdBsnHashSelect(_instructionidbsn, decoder)
	case 16:
		return DecodeInstructionIdBsnDirectedBroadcast(_instructionidbsn, decoder)
	default:
		return nil, fmt.Errorf("Invalid type '%d' for 'InstructionIdBsn'", _instructionidbsn.Subtype)
	}
}

func NewInstructionIdBsn(_subtype uint32) *InstructionIdBsn {
	obj := &InstructionIdBsn{
		InstructionIdExperimenter: NewInstructionIdExperimenter(6035143),
	}
	obj.Subtype = _subtype
	return obj
}

type InstructionIdBsnArpOffload struct {
	*InstructionIdBsn
}

type IInstructionIdBsnArpOffload interface {
	IInstructionIdBsn
}

func (self *InstructionIdBsnArpOffload) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
		return err
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeInstructionIdBsnArpOffload(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnArpOffload, error) {
	_instructionidbsnarpoffload := &InstructionIdBsnArpOffload{InstructionIdBsn: parent}
	return _instructionidbsnarpoffload, nil
}

func NewInstructionIdBsnArpOffload() *InstructionIdBsnArpOffload {
	obj := &InstructionIdBsnArpOffload{
		InstructionIdBsn: NewInstructionIdBsn(1),
	}
	return obj
}

type InstructionIdBsnAutoNegotiation struct {
	*InstructionIdBsn
}

type IInstructionIdBsnAutoNegotiation interface {
	IInstructionIdBsn
}

func (self *InstructionIdBsnAutoNegotiation) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
		return err
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeInstructionIdBsnAutoNegotiation(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnAutoNegotiation, error) {
	_instructionidbsnautonegotiation := &InstructionIdBsnAutoNegotiation{InstructionIdBsn: parent}
	return _instructionidbsnautonegotiation, nil
}

func NewInstructionIdBsnAutoNegotiation() *InstructionIdBsnAutoNegotiation {
	obj := &InstructionIdBsnAutoNegotiation{
		InstructionIdBsn: NewInstructionIdBsn(11),
	}
	return obj
}

type InstructionIdBsnDeny struct {
	*InstructionIdBsn
}

type IInstructionIdBsnDeny interface {
	IInstructionIdBsn
}

func (self *InstructionIdBsnDeny) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
		return err
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeInstructionIdBsnDeny(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnDeny, error) {
	_instructionidbsndeny := &InstructionIdBsnDeny{InstructionIdBsn: parent}
	return _instructionidbsndeny, nil
}

func NewInstructionIdBsnDeny() *InstructionIdBsnDeny {
	obj := &InstructionIdBsnDeny{
		InstructionIdBsn: NewInstructionIdBsn(5),
	}
	return obj
}

type InstructionIdBsnDhcpOffload struct {
	*InstructionIdBsn
}

type IInstructionIdBsnDhcpOffload interface {
	IInstructionIdBsn
}

func (self *InstructionIdBsnDhcpOffload) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
		return err
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeInstructionIdBsnDhcpOffload(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnDhcpOffload, error) {
	_instructionidbsndhcpoffload := &InstructionIdBsnDhcpOffload{InstructionIdBsn: parent}
	return _instructionidbsndhcpoffload, nil
}

func NewInstructionIdBsnDhcpOffload() *InstructionIdBsnDhcpOffload {
	obj := &InstructionIdBsnDhcpOffload{
		InstructionIdBsn: NewInstructionIdBsn(2),
	}
	return obj
}

type InstructionIdBsnDirectedBroadcast struct {
	*InstructionIdBsn
}

type IInstructionIdBsnDirectedBroadcast interface {
	IInstructionIdBsn
}

func (self *InstructionIdBsnDirectedBroadcast) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
		return err
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeInstructionIdBsnDirectedBroadcast(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnDirectedBroadcast, error) {
	_instructionidbsndirectedbroadcast := &InstructionIdBsnDirectedBroadcast{InstructionIdBsn: parent}
	return _instructionidbsndirectedbroadcast, nil
}

func NewInstructionIdBsnDirectedBroadcast() *InstructionIdBsnDirectedBroadcast {
	obj := &InstructionIdBsnDirectedBroadcast{
		InstructionIdBsn: NewInstructionIdBsn(16),
	}
	return obj
}

type InstructionIdBsnDisableL3 struct {
	*InstructionIdBsn
}

type IInstructionIdBsnDisableL3 interface {
	IInstructionIdBsn
}

func (self *InstructionIdBsnDisableL3) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
		return err
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeInstructionIdBsnDisableL3(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnDisableL3, error) {
	_instructionidbsndisablel3 := &InstructionIdBsnDisableL3{InstructionIdBsn: parent}
	return _instructionidbsndisablel3, nil
}

func NewInstructionIdBsnDisableL3() *InstructionIdBsnDisableL3 {
	obj := &InstructionIdBsnDisableL3{
		InstructionIdBsn: NewInstructionIdBsn(13),
	}
	return obj
}

type InstructionIdBsnDisableSrcMacCheck struct {
	*InstructionIdBsn
}

type IInstructionIdBsnDisableSrcMacCheck interface {
	IInstructionIdBsn
}

func (self *InstructionIdBsnDisableSrcMacCheck) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
		return err
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeInstructionIdBsnDisableSrcMacCheck(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnDisableSrcMacCheck, error) {
	_instructionidbsndisablesrcmaccheck := &InstructionIdBsnDisableSrcMacCheck{InstructionIdBsn: parent}
	return _instructionidbsndisablesrcmaccheck, nil
}

func NewInstructionIdBsnDisableSrcMacCheck() *InstructionIdBsnDisableSrcMacCheck {
	obj := &InstructionIdBsnDisableSrcMacCheck{
		InstructionIdBsn: NewInstructionIdBsn(0),
	}
	return obj
}

type InstructionIdBsnDisableVlanCounters struct {
	*InstructionIdBsn
}

type IInstructionIdBsnDisableVlanCounters interface {
	IInstructionIdBsn
}

func (self *InstructionIdBsnDisableVlanCounters) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
		return err
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeInstructionIdBsnDisableVlanCounters(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnDisableVlanCounters, error) {
	_instructionidbsndisablevlancounters := &InstructionIdBsnDisableVlanCounters{InstructionIdBsn: parent}
	return _instructionidbsndisablevlancounters, nil
}

func NewInstructionIdBsnDisableVlanCounters() *InstructionIdBsnDisableVlanCounters {
	obj := &InstructionIdBsnDisableVlanCounters{
		InstructionIdBsn: NewInstructionIdBsn(9),
	}
	return obj
}

type InstructionIdBsnHashSelect struct {
	*InstructionIdBsn
}

type IInstructionIdBsnHashSelect interface {
	IInstructionIdBsn
}

func (self *InstructionIdBsnHashSelect) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
		return err
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeInstructionIdBsnHashSelect(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnHashSelect, error) {
	_instructionidbsnhashselect := &InstructionIdBsnHashSelect{InstructionIdBsn: parent}
	return _instructionidbsnhashselect, nil
}

func NewInstructionIdBsnHashSelect() *InstructionIdBsnHashSelect {
	obj := &InstructionIdBsnHashSelect{
		InstructionIdBsn: NewInstructionIdBsn(15),
	}
	return obj
}

type InstructionIdBsnInternalPriority struct {
	*InstructionIdBsn
}

type IInstructionIdBsnInternalPriority interface {
	IInstructionIdBsn
}

func (self *InstructionIdBsnInternalPriority) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
		return err
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeInstructionIdBsnInternalPriority(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnInternalPriority, error) {
	_instructionidbsninternalpriority := &InstructionIdBsnInternalPriority{InstructionIdBsn: parent}
	return _instructionidbsninternalpriority, nil
}

func NewInstructionIdBsnInternalPriority() *InstructionIdBsnInternalPriority {
	obj := &InstructionIdBsnInternalPriority{
		InstructionIdBsn: NewInstructionIdBsn(12),
	}
	return obj
}

type InstructionIdBsnNdpOffload struct {
	*InstructionIdBsn
}

type IInstructionIdBsnNdpOffload interface {
	IInstructionIdBsn
}

func (self *InstructionIdBsnNdpOffload) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
		return err
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeInstructionIdBsnNdpOffload(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnNdpOffload, error) {
	_instructionidbsnndpoffload := &InstructionIdBsnNdpOffload{InstructionIdBsn: parent}
	return _instructionidbsnndpoffload, nil
}

func NewInstructionIdBsnNdpOffload() *InstructionIdBsnNdpOffload {
	obj := &InstructionIdBsnNdpOffload{
		InstructionIdBsn: NewInstructionIdBsn(14),
	}
	return obj
}

type InstructionIdBsnPacketOfDeath struct {
	*InstructionIdBsn
}

type IInstructionIdBsnPacketOfDeath interface {
	IInstructionIdBsn
}

func (self *InstructionIdBsnPacketOfDeath) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
		return err
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeInstructionIdBsnPacketOfDeath(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnPacketOfDeath, error) {
	_instructionidbsnpacketofdeath := &InstructionIdBsnPacketOfDeath{InstructionIdBsn: parent}
	return _instructionidbsnpacketofdeath, nil
}

func NewInstructionIdBsnPacketOfDeath() *InstructionIdBsnPacketOfDeath {
	obj := &InstructionIdBsnPacketOfDeath{
		InstructionIdBsn: NewInstructionIdBsn(6),
	}
	return obj
}

type InstructionIdBsnPermit struct {
	*InstructionIdBsn
}

type IInstructionIdBsnPermit interface {
	IInstructionIdBsn
}

func (self *InstructionIdBsnPermit) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
		return err
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeInstructionIdBsnPermit(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnPermit, error) {
	_instructionidbsnpermit := &InstructionIdBsnPermit{InstructionIdBsn: parent}
	return _instructionidbsnpermit, nil
}

func NewInstructionIdBsnPermit() *InstructionIdBsnPermit {
	obj := &InstructionIdBsnPermit{
		InstructionIdBsn: NewInstructionIdBsn(4),
	}
	return obj
}

type InstructionIdBsnPrioritizePdus struct {
	*InstructionIdBsn
}

type IInstructionIdBsnPrioritizePdus interface {
	IInstructionIdBsn
}

func (self *InstructionIdBsnPrioritizePdus) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
		return err
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeInstructionIdBsnPrioritizePdus(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnPrioritizePdus, error) {
	_instructionidbsnprioritizepdus := &InstructionIdBsnPrioritizePdus{InstructionIdBsn: parent}
	return _instructionidbsnprioritizepdus, nil
}

func NewInstructionIdBsnPrioritizePdus() *InstructionIdBsnPrioritizePdus {
	obj := &InstructionIdBsnPrioritizePdus{
		InstructionIdBsn: NewInstructionIdBsn(7),
	}
	return obj
}

type InstructionIdBsnRequireVlanXlate struct {
	*InstructionIdBsn
}

type IInstructionIdBsnRequireVlanXlate interface {
	IInstructionIdBsn
}

func (self *InstructionIdBsnRequireVlanXlate) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
		return err
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeInstructionIdBsnRequireVlanXlate(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnRequireVlanXlate, error) {
	_instructionidbsnrequirevlanxlate := &InstructionIdBsnRequireVlanXlate{InstructionIdBsn: parent}
	return _instructionidbsnrequirevlanxlate, nil
}

func NewInstructionIdBsnRequireVlanXlate() *InstructionIdBsnRequireVlanXlate {
	obj := &InstructionIdBsnRequireVlanXlate{
		InstructionIdBsn: NewInstructionIdBsn(8),
	}
	return obj
}

type InstructionIdBsnSpanDestination struct {
	*InstructionIdBsn
}

type IInstructionIdBsnSpanDestination interface {
	IInstructionIdBsn
}

func (self *InstructionIdBsnSpanDestination) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
		return err
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeInstructionIdBsnSpanDestination(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnSpanDestination, error) {
	_instructionidbsnspandestination := &InstructionIdBsnSpanDestination{InstructionIdBsn: parent}
	return _instructionidbsnspandestination, nil
}

func NewInstructionIdBsnSpanDestination() *InstructionIdBsnSpanDestination {
	obj := &InstructionIdBsnSpanDestination{
		InstructionIdBsn: NewInstructionIdBsn(10),
	}
	return obj
}

type InstructionIdClearActions struct {
	*InstructionId
}

type IInstructionIdClearActions interface {
	IInstructionId
}

func (self *InstructionIdClearActions) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.InstructionId.Serialize(encoder); err != nil {
		return err
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeInstructionIdClearActions(parent *InstructionId, decoder *goloxi.Decoder) (*InstructionIdClearActions, error) {
	_instructionidclearactions := &InstructionIdClearActions{InstructionId: parent}
	return _instructionidclearactions, nil
}

func NewInstructionIdClearActions() *InstructionIdClearActions {
	obj := &InstructionIdClearActions{
		InstructionId: NewInstructionId(5),
	}
	return obj
}

type InstructionIdGotoTable struct {
	*InstructionId
}

type IInstructionIdGotoTable interface {
	IInstructionId
}

func (self *InstructionIdGotoTable) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.InstructionId.Serialize(encoder); err != nil {
		return err
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeInstructionIdGotoTable(parent *InstructionId, decoder *goloxi.Decoder) (*InstructionIdGotoTable, error) {
	_instructionidgototable := &InstructionIdGotoTable{InstructionId: parent}
	return _instructionidgototable, nil
}

func NewInstructionIdGotoTable() *InstructionIdGotoTable {
	obj := &InstructionIdGotoTable{
		InstructionId: NewInstructionId(1),
	}
	return obj
}

type InstructionIdMeter struct {
	*InstructionId
}

type IInstructionIdMeter interface {
	IInstructionId
}

func (self *InstructionIdMeter) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.InstructionId.Serialize(encoder); err != nil {
		return err
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeInstructionIdMeter(parent *InstructionId, decoder *goloxi.Decoder) (*InstructionIdMeter, error) {
	_instructionidmeter := &InstructionIdMeter{InstructionId: parent}
	return _instructionidmeter, nil
}

func NewInstructionIdMeter() *InstructionIdMeter {
	obj := &InstructionIdMeter{
		InstructionId: NewInstructionId(6),
	}
	return obj
}

type InstructionIdWriteActions struct {
	*InstructionId
}

type IInstructionIdWriteActions interface {
	IInstructionId
}

func (self *InstructionIdWriteActions) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.InstructionId.Serialize(encoder); err != nil {
		return err
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeInstructionIdWriteActions(parent *InstructionId, decoder *goloxi.Decoder) (*InstructionIdWriteActions, error) {
	_instructionidwriteactions := &InstructionIdWriteActions{InstructionId: parent}
	return _instructionidwriteactions, nil
}

func NewInstructionIdWriteActions() *InstructionIdWriteActions {
	obj := &InstructionIdWriteActions{
		InstructionId: NewInstructionId(3),
	}
	return obj
}

type InstructionIdWriteMetadata struct {
	*InstructionId
}

type IInstructionIdWriteMetadata interface {
	IInstructionId
}

func (self *InstructionIdWriteMetadata) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.InstructionId.Serialize(encoder); err != nil {
		return err
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeInstructionIdWriteMetadata(parent *InstructionId, decoder *goloxi.Decoder) (*InstructionIdWriteMetadata, error) {
	_instructionidwritemetadata := &InstructionIdWriteMetadata{InstructionId: parent}
	return _instructionidwritemetadata, nil
}

func NewInstructionIdWriteMetadata() *InstructionIdWriteMetadata {
	obj := &InstructionIdWriteMetadata{
		InstructionId: NewInstructionId(2),
	}
	return obj
}

type MatchV3 struct {
	Type    uint16
	Length  uint16
	OxmList []goloxi.IOxm
}

type IMatchV3 interface {
	goloxi.Serializable
	GetType() uint16
	GetLength() uint16
	GetOxmList() []goloxi.IOxm
}

func (self *MatchV3) GetType() uint16 {
	return self.Type
}

func (self *MatchV3) SetType(v uint16) {
	self.Type = v
}

func (self *MatchV3) GetLength() uint16 {
	return self.Length
}

func (self *MatchV3) SetLength(v uint16) {
	self.Length = v
}

func (self *MatchV3) GetOxmList() []goloxi.IOxm {
	return self.OxmList
}

func (self *MatchV3) SetOxmList(v []goloxi.IOxm) {
	self.OxmList = v
}

func (self *MatchV3) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())

	encoder.PutUint16(uint16(self.Type))
	encoder.PutUint16(uint16(self.Length))
	for _, obj := range self.OxmList {
		if err := obj.Serialize(encoder); err != nil {
			return err
		}
	}
	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 (self *MatchV3) Decode(decoder *goloxi.Decoder) error {
	if decoder.Length() < 4 {
		return fmt.Errorf("MatchV3 packet too short: %d < 4", decoder.Length())
	}

	defer decoder.SkipAlign()

	self.Type = uint16(decoder.ReadUint16())
	self.Length = uint16(decoder.ReadUint16())
	oldDecoder := decoder
	defer func() { decoder = oldDecoder }()
	decoder = decoder.SliceDecoder(int(((self.Length)+7)/8*8), 2+2)

	for decoder.Length() >= 4 {
		item, err := DecodeOxm(decoder)
		if err != nil {
			return err
		}
		if item != nil {
			self.OxmList = append(self.OxmList, item)
		}
	}

	return nil
}

func NewMatchV3() *MatchV3 {
	obj := &MatchV3{}
	return obj
}

type MeterBand struct {
	Type uint16
	Len  uint16
}

type IMeterBand interface {
	goloxi.Serializable
	GetType() uint16
	GetLen() uint16
}

func (self *MeterBand) GetType() uint16 {
	return self.Type
}

func (self *MeterBand) SetType(v uint16) {
	self.Type = v
}

func (self *MeterBand) GetLen() uint16 {
	return self.Len
}

func (self *MeterBand) SetLen(v uint16) {
	self.Len = v
}

func (self *MeterBand) Serialize(encoder *goloxi.Encoder) error {

	encoder.PutUint16(uint16(self.Type))
	encoder.PutUint16(uint16(self.Len))

	return nil
}

func DecodeMeterBand(decoder *goloxi.Decoder) (IMeterBand, error) {
	_meterband := &MeterBand{}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("MeterBand packet too short: %d < 4", decoder.Length())
	}
	_meterband.Type = uint16(decoder.ReadUint16())
	_meterband.Len = uint16(decoder.ReadUint16())
	oldDecoder := decoder
	defer func() { decoder = oldDecoder }()
	decoder = decoder.SliceDecoder(int(_meterband.Len), 2+2)

	switch _meterband.Type {
	case 1:
		return DecodeMeterBandDrop(_meterband, decoder)
	case 2:
		return DecodeMeterBandDscpRemark(_meterband, decoder)
	case 65535:
		return DecodeMeterBandExperimenter(_meterband, decoder)
	default:
		return nil, fmt.Errorf("Invalid type '%d' for 'MeterBand'", _meterband.Type)
	}
}

func NewMeterBand(_type uint16) *MeterBand {
	obj := &MeterBand{}
	obj.Type = _type
	return obj
}

type MeterBandDrop struct {
	*MeterBand
	Rate      uint32
	BurstSize uint32
}

type IMeterBandDrop interface {
	IMeterBand
	GetRate() uint32
	GetBurstSize() uint32
}

func (self *MeterBandDrop) GetRate() uint32 {
	return self.Rate
}

func (self *MeterBandDrop) SetRate(v uint32) {
	self.Rate = v
}

func (self *MeterBandDrop) GetBurstSize() uint32 {
	return self.BurstSize
}

func (self *MeterBandDrop) SetBurstSize(v uint32) {
	self.BurstSize = v
}

func (self *MeterBandDrop) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.MeterBand.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint32(uint32(self.Rate))
	encoder.PutUint32(uint32(self.BurstSize))
	encoder.Write(bytes.Repeat([]byte{0}, 4))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeMeterBandDrop(parent *MeterBand, decoder *goloxi.Decoder) (*MeterBandDrop, error) {
	_meterbanddrop := &MeterBandDrop{MeterBand: parent}
	if decoder.Length() < 12 {
		return nil, fmt.Errorf("MeterBandDrop packet too short: %d < 12", decoder.Length())
	}
	_meterbanddrop.Rate = uint32(decoder.ReadUint32())
	_meterbanddrop.BurstSize = uint32(decoder.ReadUint32())
	decoder.Skip(4)
	return _meterbanddrop, nil
}

func NewMeterBandDrop() *MeterBandDrop {
	obj := &MeterBandDrop{
		MeterBand: NewMeterBand(1),
	}
	return obj
}

type MeterBandDscpRemark struct {
	*MeterBand
	Rate      uint32
	BurstSize uint32
	PrecLevel uint8
}

type IMeterBandDscpRemark interface {
	IMeterBand
	GetRate() uint32
	GetBurstSize() uint32
	GetPrecLevel() uint8
}

func (self *MeterBandDscpRemark) GetRate() uint32 {
	return self.Rate
}

func (self *MeterBandDscpRemark) SetRate(v uint32) {
	self.Rate = v
}

func (self *MeterBandDscpRemark) GetBurstSize() uint32 {
	return self.BurstSize
}

func (self *MeterBandDscpRemark) SetBurstSize(v uint32) {
	self.BurstSize = v
}

func (self *MeterBandDscpRemark) GetPrecLevel() uint8 {
	return self.PrecLevel
}

func (self *MeterBandDscpRemark) SetPrecLevel(v uint8) {
	self.PrecLevel = v
}

func (self *MeterBandDscpRemark) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.MeterBand.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint32(uint32(self.Rate))
	encoder.PutUint32(uint32(self.BurstSize))
	encoder.PutUint8(uint8(self.PrecLevel))
	encoder.Write(bytes.Repeat([]byte{0}, 3))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeMeterBandDscpRemark(parent *MeterBand, decoder *goloxi.Decoder) (*MeterBandDscpRemark, error) {
	_meterbanddscpremark := &MeterBandDscpRemark{MeterBand: parent}
	if decoder.Length() < 12 {
		return nil, fmt.Errorf("MeterBandDscpRemark packet too short: %d < 12", decoder.Length())
	}
	_meterbanddscpremark.Rate = uint32(decoder.ReadUint32())
	_meterbanddscpremark.BurstSize = uint32(decoder.ReadUint32())
	_meterbanddscpremark.PrecLevel = uint8(decoder.ReadByte())
	decoder.Skip(3)
	return _meterbanddscpremark, nil
}

func NewMeterBandDscpRemark() *MeterBandDscpRemark {
	obj := &MeterBandDscpRemark{
		MeterBand: NewMeterBand(2),
	}
	return obj
}

type MeterBandExperimenter struct {
	*MeterBand
	Rate         uint32
	BurstSize    uint32
	Experimenter uint32
}

type IMeterBandExperimenter interface {
	IMeterBand
	GetRate() uint32
	GetBurstSize() uint32
	GetExperimenter() uint32
}

func (self *MeterBandExperimenter) GetRate() uint32 {
	return self.Rate
}

func (self *MeterBandExperimenter) SetRate(v uint32) {
	self.Rate = v
}

func (self *MeterBandExperimenter) GetBurstSize() uint32 {
	return self.BurstSize
}

func (self *MeterBandExperimenter) SetBurstSize(v uint32) {
	self.BurstSize = v
}

func (self *MeterBandExperimenter) GetExperimenter() uint32 {
	return self.Experimenter
}

func (self *MeterBandExperimenter) SetExperimenter(v uint32) {
	self.Experimenter = v
}

func (self *MeterBandExperimenter) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.MeterBand.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint32(uint32(self.Rate))
	encoder.PutUint32(uint32(self.BurstSize))
	encoder.PutUint32(uint32(self.Experimenter))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeMeterBandExperimenter(parent *MeterBand, decoder *goloxi.Decoder) (*MeterBandExperimenter, error) {
	_meterbandexperimenter := &MeterBandExperimenter{MeterBand: parent}
	if decoder.Length() < 12 {
		return nil, fmt.Errorf("MeterBandExperimenter packet too short: %d < 12", decoder.Length())
	}
	_meterbandexperimenter.Rate = uint32(decoder.ReadUint32())
	_meterbandexperimenter.BurstSize = uint32(decoder.ReadUint32())
	_meterbandexperimenter.Experimenter = uint32(decoder.ReadUint32())
	return _meterbandexperimenter, nil
}

func NewMeterBandExperimenter() *MeterBandExperimenter {
	obj := &MeterBandExperimenter{
		MeterBand: NewMeterBand(65535),
	}
	return obj
}

type MeterBandStats struct {
	PacketBandCount uint64
	ByteBandCount   uint64
}

type IMeterBandStats interface {
	goloxi.Serializable
	GetPacketBandCount() uint64
	GetByteBandCount() uint64
}

func (self *MeterBandStats) GetPacketBandCount() uint64 {
	return self.PacketBandCount
}

func (self *MeterBandStats) SetPacketBandCount(v uint64) {
	self.PacketBandCount = v
}

func (self *MeterBandStats) GetByteBandCount() uint64 {
	return self.ByteBandCount
}

func (self *MeterBandStats) SetByteBandCount(v uint64) {
	self.ByteBandCount = v
}

func (self *MeterBandStats) Serialize(encoder *goloxi.Encoder) error {

	encoder.PutUint64(uint64(self.PacketBandCount))
	encoder.PutUint64(uint64(self.ByteBandCount))

	return nil
}

func DecodeMeterBandStats(decoder *goloxi.Decoder) (*MeterBandStats, error) {
	_meterbandstats := &MeterBandStats{}
	if decoder.Length() < 16 {
		return nil, fmt.Errorf("MeterBandStats packet too short: %d < 16", decoder.Length())
	}
	_meterbandstats.PacketBandCount = uint64(decoder.ReadUint64())
	_meterbandstats.ByteBandCount = uint64(decoder.ReadUint64())
	return _meterbandstats, nil
}

func NewMeterBandStats() *MeterBandStats {
	obj := &MeterBandStats{}
	return obj
}

type MeterConfig struct {
	Length  uint16
	Flags   MeterFlags
	MeterId uint32
	Entries []IMeterBand
}

type IMeterConfig interface {
	goloxi.Serializable
	GetLength() uint16
	GetFlags() MeterFlags
	GetMeterId() uint32
	GetEntries() []IMeterBand
}

func (self *MeterConfig) GetLength() uint16 {
	return self.Length
}

func (self *MeterConfig) SetLength(v uint16) {
	self.Length = v
}

func (self *MeterConfig) GetFlags() MeterFlags {
	return self.Flags
}

func (self *MeterConfig) SetFlags(v MeterFlags) {
	self.Flags = v
}

func (self *MeterConfig) GetMeterId() uint32 {
	return self.MeterId
}

func (self *MeterConfig) SetMeterId(v uint32) {
	self.MeterId = v
}

func (self *MeterConfig) GetEntries() []IMeterBand {
	return self.Entries
}

func (self *MeterConfig) SetEntries(v []IMeterBand) {
	self.Entries = v
}

func (self *MeterConfig) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())

	encoder.PutUint16(uint16(self.Length))
	encoder.PutUint16(uint16(self.Flags))
	encoder.PutUint32(uint32(self.MeterId))
	for _, obj := range self.Entries {
		if err := obj.Serialize(encoder); err != nil {
			return err
		}
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))

	return nil
}

func DecodeMeterConfig(decoder *goloxi.Decoder) (*MeterConfig, error) {
	_meterconfig := &MeterConfig{}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("MeterConfig packet too short: %d < 8", decoder.Length())
	}
	_meterconfig.Length = uint16(decoder.ReadUint16())
	oldDecoder := decoder
	defer func() { decoder = oldDecoder }()
	decoder = decoder.SliceDecoder(int(_meterconfig.Length), 2+0)
	_meterconfig.Flags = MeterFlags(decoder.ReadUint16())
	_meterconfig.MeterId = uint32(decoder.ReadUint32())

	for decoder.Length() >= 4 {
		item, err := DecodeMeterBand(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_meterconfig.Entries = append(_meterconfig.Entries, item)
		}
	}
	return _meterconfig, nil
}

func NewMeterConfig() *MeterConfig {
	obj := &MeterConfig{}
	return obj
}

type MeterFeatures struct {
	MaxMeter     uint32
	BandTypes    uint32
	Capabilities uint32
	MaxBands     uint8
	MaxColor     uint8
}

type IMeterFeatures interface {
	goloxi.Serializable
	GetMaxMeter() uint32
	GetBandTypes() uint32
	GetCapabilities() uint32
	GetMaxBands() uint8
	GetMaxColor() uint8
}

func (self *MeterFeatures) GetMaxMeter() uint32 {
	return self.MaxMeter
}

func (self *MeterFeatures) SetMaxMeter(v uint32) {
	self.MaxMeter = v
}

func (self *MeterFeatures) GetBandTypes() uint32 {
	return self.BandTypes
}

func (self *MeterFeatures) SetBandTypes(v uint32) {
	self.BandTypes = v
}

func (self *MeterFeatures) GetCapabilities() uint32 {
	return self.Capabilities
}

func (self *MeterFeatures) SetCapabilities(v uint32) {
	self.Capabilities = v
}

func (self *MeterFeatures) GetMaxBands() uint8 {
	return self.MaxBands
}

func (self *MeterFeatures) SetMaxBands(v uint8) {
	self.MaxBands = v
}

func (self *MeterFeatures) GetMaxColor() uint8 {
	return self.MaxColor
}

func (self *MeterFeatures) SetMaxColor(v uint8) {
	self.MaxColor = v
}

func (self *MeterFeatures) Serialize(encoder *goloxi.Encoder) error {

	encoder.PutUint32(uint32(self.MaxMeter))
	encoder.PutUint32(uint32(self.BandTypes))
	encoder.PutUint32(uint32(self.Capabilities))
	encoder.PutUint8(uint8(self.MaxBands))
	encoder.PutUint8(uint8(self.MaxColor))
	encoder.Write(bytes.Repeat([]byte{0}, 2))

	return nil
}
func (self *MeterFeatures) Decode(decoder *goloxi.Decoder) error {
	if decoder.Length() < 16 {
		return fmt.Errorf("MeterFeatures packet too short: %d < 16", decoder.Length())
	}

	self.MaxMeter = uint32(decoder.ReadUint32())
	self.BandTypes = uint32(decoder.ReadUint32())
	self.Capabilities = uint32(decoder.ReadUint32())
	self.MaxBands = uint8(decoder.ReadByte())
	self.MaxColor = uint8(decoder.ReadByte())
	decoder.Skip(2)

	return nil
}

func NewMeterFeatures() *MeterFeatures {
	obj := &MeterFeatures{}
	return obj
}

type MeterStats struct {
	MeterId       uint32
	Len           uint16
	FlowCount     uint32
	PacketInCount uint64
	ByteInCount   uint64
	DurationSec   uint32
	DurationNsec  uint32
	BandStats     []*MeterBandStats
}

type IMeterStats interface {
	goloxi.Serializable
	GetMeterId() uint32
	GetLen() uint16
	GetFlowCount() uint32
	GetPacketInCount() uint64
	GetByteInCount() uint64
	GetDurationSec() uint32
	GetDurationNsec() uint32
	GetBandStats() []*MeterBandStats
}

func (self *MeterStats) GetMeterId() uint32 {
	return self.MeterId
}

func (self *MeterStats) SetMeterId(v uint32) {
	self.MeterId = v
}

func (self *MeterStats) GetLen() uint16 {
	return self.Len
}

func (self *MeterStats) SetLen(v uint16) {
	self.Len = v
}

func (self *MeterStats) GetFlowCount() uint32 {
	return self.FlowCount
}

func (self *MeterStats) SetFlowCount(v uint32) {
	self.FlowCount = v
}

func (self *MeterStats) GetPacketInCount() uint64 {
	return self.PacketInCount
}

func (self *MeterStats) SetPacketInCount(v uint64) {
	self.PacketInCount = v
}

func (self *MeterStats) GetByteInCount() uint64 {
	return self.ByteInCount
}

func (self *MeterStats) SetByteInCount(v uint64) {
	self.ByteInCount = v
}

func (self *MeterStats) GetDurationSec() uint32 {
	return self.DurationSec
}

func (self *MeterStats) SetDurationSec(v uint32) {
	self.DurationSec = v
}

func (self *MeterStats) GetDurationNsec() uint32 {
	return self.DurationNsec
}

func (self *MeterStats) SetDurationNsec(v uint32) {
	self.DurationNsec = v
}

func (self *MeterStats) GetBandStats() []*MeterBandStats {
	return self.BandStats
}

func (self *MeterStats) SetBandStats(v []*MeterBandStats) {
	self.BandStats = v
}

func (self *MeterStats) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())

	encoder.PutUint32(uint32(self.MeterId))
	encoder.PutUint16(uint16(self.Len))
	encoder.Write(bytes.Repeat([]byte{0}, 6))
	encoder.PutUint32(uint32(self.FlowCount))
	encoder.PutUint64(uint64(self.PacketInCount))
	encoder.PutUint64(uint64(self.ByteInCount))
	encoder.PutUint32(uint32(self.DurationSec))
	encoder.PutUint32(uint32(self.DurationNsec))
	for _, obj := range self.BandStats {
		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 DecodeMeterStats(decoder *goloxi.Decoder) (*MeterStats, error) {
	_meterstats := &MeterStats{}
	if decoder.Length() < 40 {
		return nil, fmt.Errorf("MeterStats packet too short: %d < 40", decoder.Length())
	}
	_meterstats.MeterId = uint32(decoder.ReadUint32())
	_meterstats.Len = uint16(decoder.ReadUint16())
	oldDecoder := decoder
	defer func() { decoder = oldDecoder }()
	decoder = decoder.SliceDecoder(int(_meterstats.Len), 2+4)
	decoder.Skip(6)
	_meterstats.FlowCount = uint32(decoder.ReadUint32())
	_meterstats.PacketInCount = uint64(decoder.ReadUint64())
	_meterstats.ByteInCount = uint64(decoder.ReadUint64())
	_meterstats.DurationSec = uint32(decoder.ReadUint32())
	_meterstats.DurationNsec = uint32(decoder.ReadUint32())

	for decoder.Length() >= 16 {
		item, err := DecodeMeterBandStats(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_meterstats.BandStats = append(_meterstats.BandStats, item)
		}
	}
	return _meterstats, nil
}

func NewMeterStats() *MeterStats {
	obj := &MeterStats{}
	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 OxmIdActsetOutput struct {
	*OxmId
}

type IOxmIdActsetOutput interface {
	IOxmId
}

func (self *OxmIdActsetOutput) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdActsetOutput(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdActsetOutput, error) {
	_oxmidactsetoutput := &OxmIdActsetOutput{OxmId: parent}
	return _oxmidactsetoutput, nil
}

func NewOxmIdActsetOutput() *OxmIdActsetOutput {
	obj := &OxmIdActsetOutput{
		OxmId: NewOxmId(2147505668),
	}
	return obj
}
func (self *OxmIdActsetOutput) GetOXMName() string {
	return "actset_output"
}

func (self *OxmIdActsetOutput) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdActsetOutputMasked struct {
	*OxmId
}

type IOxmIdActsetOutputMasked interface {
	IOxmId
}

func (self *OxmIdActsetOutputMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdActsetOutputMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdActsetOutputMasked, error) {
	_oxmidactsetoutputmasked := &OxmIdActsetOutputMasked{OxmId: parent}
	return _oxmidactsetoutputmasked, nil
}

func NewOxmIdActsetOutputMasked() *OxmIdActsetOutputMasked {
	obj := &OxmIdActsetOutputMasked{
		OxmId: NewOxmId(2147505928),
	}
	return obj
}
func (self *OxmIdActsetOutputMasked) GetOXMName() string {
	return "actset_output_masked"
}

func (self *OxmIdActsetOutputMasked) 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 OxmIdBsnEgrPortGroupId struct {
	*OxmId
}

type IOxmIdBsnEgrPortGroupId interface {
	IOxmId
}

func (self *OxmIdBsnEgrPortGroupId) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdBsnEgrPortGroupId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnEgrPortGroupId, error) {
	_oxmidbsnegrportgroupid := &OxmIdBsnEgrPortGroupId{OxmId: parent}
	return _oxmidbsnegrportgroupid, nil
}

func NewOxmIdBsnEgrPortGroupId() *OxmIdBsnEgrPortGroupId {
	obj := &OxmIdBsnEgrPortGroupId{
		OxmId: NewOxmId(200196),
	}
	return obj
}
func (self *OxmIdBsnEgrPortGroupId) GetOXMName() string {
	return "bsn_egr_port_group_id"
}

func (self *OxmIdBsnEgrPortGroupId) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdBsnEgrPortGroupIdMasked struct {
	*OxmId
}

type IOxmIdBsnEgrPortGroupIdMasked interface {
	IOxmId
}

func (self *OxmIdBsnEgrPortGroupIdMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdBsnEgrPortGroupIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnEgrPortGroupIdMasked, error) {
	_oxmidbsnegrportgroupidmasked := &OxmIdBsnEgrPortGroupIdMasked{OxmId: parent}
	return _oxmidbsnegrportgroupidmasked, nil
}

func NewOxmIdBsnEgrPortGroupIdMasked() *OxmIdBsnEgrPortGroupIdMasked {
	obj := &OxmIdBsnEgrPortGroupIdMasked{
		OxmId: NewOxmId(200456),
	}
	return obj
}
func (self *OxmIdBsnEgrPortGroupIdMasked) GetOXMName() string {
	return "bsn_egr_port_group_id_masked"
}

func (self *OxmIdBsnEgrPortGroupIdMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdBsnIfpClassId struct {
	*OxmId
}

type IOxmIdBsnIfpClassId interface {
	IOxmId
}

func (self *OxmIdBsnIfpClassId) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdBsnIfpClassId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnIfpClassId, error) {
	_oxmidbsnifpclassid := &OxmIdBsnIfpClassId{OxmId: parent}
	return _oxmidbsnifpclassid, nil
}

func NewOxmIdBsnIfpClassId() *OxmIdBsnIfpClassId {
	obj := &OxmIdBsnIfpClassId{
		OxmId: NewOxmId(210436),
	}
	return obj
}
func (self *OxmIdBsnIfpClassId) GetOXMName() string {
	return "bsn_ifp_class_id"
}

func (self *OxmIdBsnIfpClassId) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdBsnIfpClassIdMasked struct {
	*OxmId
}

type IOxmIdBsnIfpClassIdMasked interface {
	IOxmId
}

func (self *OxmIdBsnIfpClassIdMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdBsnIfpClassIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnIfpClassIdMasked, error) {
	_oxmidbsnifpclassidmasked := &OxmIdBsnIfpClassIdMasked{OxmId: parent}
	return _oxmidbsnifpclassidmasked, nil
}

func NewOxmIdBsnIfpClassIdMasked() *OxmIdBsnIfpClassIdMasked {
	obj := &OxmIdBsnIfpClassIdMasked{
		OxmId: NewOxmId(210696),
	}
	return obj
}
func (self *OxmIdBsnIfpClassIdMasked) GetOXMName() string {
	return "bsn_ifp_class_id_masked"
}

func (self *OxmIdBsnIfpClassIdMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdBsnInPorts128 struct {
	*OxmId
}

type IOxmIdBsnInPorts128 interface {
	IOxmId
}

func (self *OxmIdBsnInPorts128) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdBsnInPorts128(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnInPorts128, error) {
	_oxmidbsninports128 := &OxmIdBsnInPorts128{OxmId: parent}
	return _oxmidbsninports128, nil
}

func NewOxmIdBsnInPorts128() *OxmIdBsnInPorts128 {
	obj := &OxmIdBsnInPorts128{
		OxmId: NewOxmId(196624),
	}
	return obj
}
func (self *OxmIdBsnInPorts128) GetOXMName() string {
	return "bsn_in_ports_128"
}

func (self *OxmIdBsnInPorts128) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdBsnInPorts128Masked struct {
	*OxmId
}

type IOxmIdBsnInPorts128Masked interface {
	IOxmId
}

func (self *OxmIdBsnInPorts128Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdBsnInPorts128Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnInPorts128Masked, error) {
	_oxmidbsninports128masked := &OxmIdBsnInPorts128Masked{OxmId: parent}
	return _oxmidbsninports128masked, nil
}

func NewOxmIdBsnInPorts128Masked() *OxmIdBsnInPorts128Masked {
	obj := &OxmIdBsnInPorts128Masked{
		OxmId: NewOxmId(196896),
	}
	return obj
}
func (self *OxmIdBsnInPorts128Masked) GetOXMName() string {
	return "bsn_in_ports_128_masked"
}

func (self *OxmIdBsnInPorts128Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdBsnInPorts512 struct {
	*OxmId
}

type IOxmIdBsnInPorts512 interface {
	IOxmId
}

func (self *OxmIdBsnInPorts512) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdBsnInPorts512(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnInPorts512, error) {
	_oxmidbsninports512 := &OxmIdBsnInPorts512{OxmId: parent}
	return _oxmidbsninports512, nil
}

func NewOxmIdBsnInPorts512() *OxmIdBsnInPorts512 {
	obj := &OxmIdBsnInPorts512{
		OxmId: NewOxmId(206400),
	}
	return obj
}
func (self *OxmIdBsnInPorts512) GetOXMName() string {
	return "bsn_in_ports_512"
}

func (self *OxmIdBsnInPorts512) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdBsnInPorts512Masked struct {
	*OxmId
}

type IOxmIdBsnInPorts512Masked interface {
	IOxmId
}

func (self *OxmIdBsnInPorts512Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdBsnInPorts512Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnInPorts512Masked, error) {
	_oxmidbsninports512masked := &OxmIdBsnInPorts512Masked{OxmId: parent}
	return _oxmidbsninports512masked, nil
}

func NewOxmIdBsnInPorts512Masked() *OxmIdBsnInPorts512Masked {
	obj := &OxmIdBsnInPorts512Masked{
		OxmId: NewOxmId(206720),
	}
	return obj
}
func (self *OxmIdBsnInPorts512Masked) GetOXMName() string {
	return "bsn_in_ports_512_masked"
}

func (self *OxmIdBsnInPorts512Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdBsnIngressPortGroupId struct {
	*OxmId
}

type IOxmIdBsnIngressPortGroupId interface {
	IOxmId
}

func (self *OxmIdBsnIngressPortGroupId) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdBsnIngressPortGroupId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnIngressPortGroupId, error) {
	_oxmidbsningressportgroupid := &OxmIdBsnIngressPortGroupId{OxmId: parent}
	return _oxmidbsningressportgroupid, nil
}

func NewOxmIdBsnIngressPortGroupId() *OxmIdBsnIngressPortGroupId {
	obj := &OxmIdBsnIngressPortGroupId{
		OxmId: NewOxmId(206852),
	}
	return obj
}
func (self *OxmIdBsnIngressPortGroupId) GetOXMName() string {
	return "bsn_ingress_port_group_id"
}

func (self *OxmIdBsnIngressPortGroupId) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdBsnIngressPortGroupIdMasked struct {
	*OxmId
}

type IOxmIdBsnIngressPortGroupIdMasked interface {
	IOxmId
}

func (self *OxmIdBsnIngressPortGroupIdMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdBsnIngressPortGroupIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnIngressPortGroupIdMasked, error) {
	_oxmidbsningressportgroupidmasked := &OxmIdBsnIngressPortGroupIdMasked{OxmId: parent}
	return _oxmidbsningressportgroupidmasked, nil
}

func NewOxmIdBsnIngressPortGroupIdMasked() *OxmIdBsnIngressPortGroupIdMasked {
	obj := &OxmIdBsnIngressPortGroupIdMasked{
		OxmId: NewOxmId(207112),
	}
	return obj
}
func (self *OxmIdBsnIngressPortGroupIdMasked) GetOXMName() string {
	return "bsn_ingress_port_group_id_masked"
}

func (self *OxmIdBsnIngressPortGroupIdMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdBsnInnerEthDst struct {
	*OxmId
}

type IOxmIdBsnInnerEthDst interface {
	IOxmId
}

func (self *OxmIdBsnInnerEthDst) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdBsnInnerEthDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnInnerEthDst, error) {
	_oxmidbsninnerethdst := &OxmIdBsnInnerEthDst{OxmId: parent}
	return _oxmidbsninnerethdst, nil
}

func NewOxmIdBsnInnerEthDst() *OxmIdBsnInnerEthDst {
	obj := &OxmIdBsnInnerEthDst{
		OxmId: NewOxmId(207878),
	}
	return obj
}
func (self *OxmIdBsnInnerEthDst) GetOXMName() string {
	return "bsn_inner_eth_dst"
}

func (self *OxmIdBsnInnerEthDst) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdBsnInnerEthDstMasked struct {
	*OxmId
}

type IOxmIdBsnInnerEthDstMasked interface {
	IOxmId
}

func (self *OxmIdBsnInnerEthDstMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdBsnInnerEthDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnInnerEthDstMasked, error) {
	_oxmidbsninnerethdstmasked := &OxmIdBsnInnerEthDstMasked{OxmId: parent}
	return _oxmidbsninnerethdstmasked, nil
}

func NewOxmIdBsnInnerEthDstMasked() *OxmIdBsnInnerEthDstMasked {
	obj := &OxmIdBsnInnerEthDstMasked{
		OxmId: NewOxmId(208140),
	}
	return obj
}
func (self *OxmIdBsnInnerEthDstMasked) GetOXMName() string {
	return "bsn_inner_eth_dst_masked"
}

func (self *OxmIdBsnInnerEthDstMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdBsnInnerEthSrc struct {
	*OxmId
}

type IOxmIdBsnInnerEthSrc interface {
	IOxmId
}

func (self *OxmIdBsnInnerEthSrc) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdBsnInnerEthSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnInnerEthSrc, error) {
	_oxmidbsninnerethsrc := &OxmIdBsnInnerEthSrc{OxmId: parent}
	return _oxmidbsninnerethsrc, nil
}

func NewOxmIdBsnInnerEthSrc() *OxmIdBsnInnerEthSrc {
	obj := &OxmIdBsnInnerEthSrc{
		OxmId: NewOxmId(208390),
	}
	return obj
}
func (self *OxmIdBsnInnerEthSrc) GetOXMName() string {
	return "bsn_inner_eth_src"
}

func (self *OxmIdBsnInnerEthSrc) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdBsnInnerEthSrcMasked struct {
	*OxmId
}

type IOxmIdBsnInnerEthSrcMasked interface {
	IOxmId
}

func (self *OxmIdBsnInnerEthSrcMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdBsnInnerEthSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnInnerEthSrcMasked, error) {
	_oxmidbsninnerethsrcmasked := &OxmIdBsnInnerEthSrcMasked{OxmId: parent}
	return _oxmidbsninnerethsrcmasked, nil
}

func NewOxmIdBsnInnerEthSrcMasked() *OxmIdBsnInnerEthSrcMasked {
	obj := &OxmIdBsnInnerEthSrcMasked{
		OxmId: NewOxmId(208652),
	}
	return obj
}
func (self *OxmIdBsnInnerEthSrcMasked) GetOXMName() string {
	return "bsn_inner_eth_src_masked"
}

func (self *OxmIdBsnInnerEthSrcMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdBsnInnerVlanVid struct {
	*OxmId
}

type IOxmIdBsnInnerVlanVid interface {
	IOxmId
}

func (self *OxmIdBsnInnerVlanVid) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdBsnInnerVlanVid(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnInnerVlanVid, error) {
	_oxmidbsninnervlanvid := &OxmIdBsnInnerVlanVid{OxmId: parent}
	return _oxmidbsninnervlanvid, nil
}

func NewOxmIdBsnInnerVlanVid() *OxmIdBsnInnerVlanVid {
	obj := &OxmIdBsnInnerVlanVid{
		OxmId: NewOxmId(208898),
	}
	return obj
}
func (self *OxmIdBsnInnerVlanVid) GetOXMName() string {
	return "bsn_inner_vlan_vid"
}

func (self *OxmIdBsnInnerVlanVid) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdBsnInnerVlanVidMasked struct {
	*OxmId
}

type IOxmIdBsnInnerVlanVidMasked interface {
	IOxmId
}

func (self *OxmIdBsnInnerVlanVidMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdBsnInnerVlanVidMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnInnerVlanVidMasked, error) {
	_oxmidbsninnervlanvidmasked := &OxmIdBsnInnerVlanVidMasked{OxmId: parent}
	return _oxmidbsninnervlanvidmasked, nil
}

func NewOxmIdBsnInnerVlanVidMasked() *OxmIdBsnInnerVlanVidMasked {
	obj := &OxmIdBsnInnerVlanVidMasked{
		OxmId: NewOxmId(209156),
	}
	return obj
}
func (self *OxmIdBsnInnerVlanVidMasked) GetOXMName() string {
	return "bsn_inner_vlan_vid_masked"
}

func (self *OxmIdBsnInnerVlanVidMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdBsnIpFragmentation struct {
	*OxmId
}

type IOxmIdBsnIpFragmentation interface {
	IOxmId
}

func (self *OxmIdBsnIpFragmentation) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdBsnIpFragmentation(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnIpFragmentation, error) {
	_oxmidbsnipfragmentation := &OxmIdBsnIpFragmentation{OxmId: parent}
	return _oxmidbsnipfragmentation, nil
}

func NewOxmIdBsnIpFragmentation() *OxmIdBsnIpFragmentation {
	obj := &OxmIdBsnIpFragmentation{
		OxmId: NewOxmId(209921),
	}
	return obj
}
func (self *OxmIdBsnIpFragmentation) GetOXMName() string {
	return "bsn_ip_fragmentation"
}

func (self *OxmIdBsnIpFragmentation) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdBsnIpFragmentationMasked struct {
	*OxmId
}

type IOxmIdBsnIpFragmentationMasked interface {
	IOxmId
}

func (self *OxmIdBsnIpFragmentationMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdBsnIpFragmentationMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnIpFragmentationMasked, error) {
	_oxmidbsnipfragmentationmasked := &OxmIdBsnIpFragmentationMasked{OxmId: parent}
	return _oxmidbsnipfragmentationmasked, nil
}

func NewOxmIdBsnIpFragmentationMasked() *OxmIdBsnIpFragmentationMasked {
	obj := &OxmIdBsnIpFragmentationMasked{
		OxmId: NewOxmId(210178),
	}
	return obj
}
func (self *OxmIdBsnIpFragmentationMasked) GetOXMName() string {
	return "bsn_ip_fragmentation_masked"
}

func (self *OxmIdBsnIpFragmentationMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdBsnL2CacheHit struct {
	*OxmId
}

type IOxmIdBsnL2CacheHit interface {
	IOxmId
}

func (self *OxmIdBsnL2CacheHit) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdBsnL2CacheHit(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnL2CacheHit, error) {
	_oxmidbsnl2cachehit := &OxmIdBsnL2CacheHit{OxmId: parent}
	return _oxmidbsnl2cachehit, nil
}

func NewOxmIdBsnL2CacheHit() *OxmIdBsnL2CacheHit {
	obj := &OxmIdBsnL2CacheHit{
		OxmId: NewOxmId(205825),
	}
	return obj
}
func (self *OxmIdBsnL2CacheHit) GetOXMName() string {
	return "bsn_l2_cache_hit"
}

func (self *OxmIdBsnL2CacheHit) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdBsnL2CacheHitMasked struct {
	*OxmId
}

type IOxmIdBsnL2CacheHitMasked interface {
	IOxmId
}

func (self *OxmIdBsnL2CacheHitMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdBsnL2CacheHitMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnL2CacheHitMasked, error) {
	_oxmidbsnl2cachehitmasked := &OxmIdBsnL2CacheHitMasked{OxmId: parent}
	return _oxmidbsnl2cachehitmasked, nil
}

func NewOxmIdBsnL2CacheHitMasked() *OxmIdBsnL2CacheHitMasked {
	obj := &OxmIdBsnL2CacheHitMasked{
		OxmId: NewOxmId(206082),
	}
	return obj
}
func (self *OxmIdBsnL2CacheHitMasked) GetOXMName() string {
	return "bsn_l2_cache_hit_masked"
}

func (self *OxmIdBsnL2CacheHitMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdBsnL3InterfaceClassId struct {
	*OxmId
}

type IOxmIdBsnL3InterfaceClassId interface {
	IOxmId
}

func (self *OxmIdBsnL3InterfaceClassId) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdBsnL3InterfaceClassId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnL3InterfaceClassId, error) {
	_oxmidbsnl3interfaceclassid := &OxmIdBsnL3InterfaceClassId{OxmId: parent}
	return _oxmidbsnl3interfaceclassid, nil
}

func NewOxmIdBsnL3InterfaceClassId() *OxmIdBsnL3InterfaceClassId {
	obj := &OxmIdBsnL3InterfaceClassId{
		OxmId: NewOxmId(198660),
	}
	return obj
}
func (self *OxmIdBsnL3InterfaceClassId) GetOXMName() string {
	return "bsn_l3_interface_class_id"
}

func (self *OxmIdBsnL3InterfaceClassId) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdBsnL3InterfaceClassIdMasked struct {
	*OxmId
}

type IOxmIdBsnL3InterfaceClassIdMasked interface {
	IOxmId
}

func (self *OxmIdBsnL3InterfaceClassIdMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdBsnL3InterfaceClassIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnL3InterfaceClassIdMasked, error) {
	_oxmidbsnl3interfaceclassidmasked := &OxmIdBsnL3InterfaceClassIdMasked{OxmId: parent}
	return _oxmidbsnl3interfaceclassidmasked, nil
}

func NewOxmIdBsnL3InterfaceClassIdMasked() *OxmIdBsnL3InterfaceClassIdMasked {
	obj := &OxmIdBsnL3InterfaceClassIdMasked{
		OxmId: NewOxmId(198920),
	}
	return obj
}
func (self *OxmIdBsnL3InterfaceClassIdMasked) GetOXMName() string {
	return "bsn_l3_interface_class_id_masked"
}

func (self *OxmIdBsnL3InterfaceClassIdMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdBsnL3SrcClassId struct {
	*OxmId
}

type IOxmIdBsnL3SrcClassId interface {
	IOxmId
}

func (self *OxmIdBsnL3SrcClassId) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdBsnL3SrcClassId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnL3SrcClassId, error) {
	_oxmidbsnl3srcclassid := &OxmIdBsnL3SrcClassId{OxmId: parent}
	return _oxmidbsnl3srcclassid, nil
}

func NewOxmIdBsnL3SrcClassId() *OxmIdBsnL3SrcClassId {
	obj := &OxmIdBsnL3SrcClassId{
		OxmId: NewOxmId(199172),
	}
	return obj
}
func (self *OxmIdBsnL3SrcClassId) GetOXMName() string {
	return "bsn_l3_src_class_id"
}

func (self *OxmIdBsnL3SrcClassId) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdBsnL3SrcClassIdMasked struct {
	*OxmId
}

type IOxmIdBsnL3SrcClassIdMasked interface {
	IOxmId
}

func (self *OxmIdBsnL3SrcClassIdMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdBsnL3SrcClassIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnL3SrcClassIdMasked, error) {
	_oxmidbsnl3srcclassidmasked := &OxmIdBsnL3SrcClassIdMasked{OxmId: parent}
	return _oxmidbsnl3srcclassidmasked, nil
}

func NewOxmIdBsnL3SrcClassIdMasked() *OxmIdBsnL3SrcClassIdMasked {
	obj := &OxmIdBsnL3SrcClassIdMasked{
		OxmId: NewOxmId(199432),
	}
	return obj
}
func (self *OxmIdBsnL3SrcClassIdMasked) GetOXMName() string {
	return "bsn_l3_src_class_id_masked"
}

func (self *OxmIdBsnL3SrcClassIdMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdBsnLagId struct {
	*OxmId
}

type IOxmIdBsnLagId interface {
	IOxmId
}

func (self *OxmIdBsnLagId) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdBsnLagId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnLagId, error) {
	_oxmidbsnlagid := &OxmIdBsnLagId{OxmId: parent}
	return _oxmidbsnlagid, nil
}

func NewOxmIdBsnLagId() *OxmIdBsnLagId {
	obj := &OxmIdBsnLagId{
		OxmId: NewOxmId(197124),
	}
	return obj
}
func (self *OxmIdBsnLagId) GetOXMName() string {
	return "bsn_lag_id"
}

func (self *OxmIdBsnLagId) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdBsnLagIdMasked struct {
	*OxmId
}

type IOxmIdBsnLagIdMasked interface {
	IOxmId
}

func (self *OxmIdBsnLagIdMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdBsnLagIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnLagIdMasked, error) {
	_oxmidbsnlagidmasked := &OxmIdBsnLagIdMasked{OxmId: parent}
	return _oxmidbsnlagidmasked, nil
}

func NewOxmIdBsnLagIdMasked() *OxmIdBsnLagIdMasked {
	obj := &OxmIdBsnLagIdMasked{
		OxmId: NewOxmId(197384),
	}
	return obj
}
func (self *OxmIdBsnLagIdMasked) GetOXMName() string {
	return "bsn_lag_id_masked"
}

func (self *OxmIdBsnLagIdMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdBsnTcpFlags struct {
	*OxmId
}

type IOxmIdBsnTcpFlags interface {
	IOxmId
}

func (self *OxmIdBsnTcpFlags) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdBsnTcpFlags(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnTcpFlags, error) {
	_oxmidbsntcpflags := &OxmIdBsnTcpFlags{OxmId: parent}
	return _oxmidbsntcpflags, nil
}

func NewOxmIdBsnTcpFlags() *OxmIdBsnTcpFlags {
	obj := &OxmIdBsnTcpFlags{
		OxmId: NewOxmId(204802),
	}
	return obj
}
func (self *OxmIdBsnTcpFlags) GetOXMName() string {
	return "bsn_tcp_flags"
}

func (self *OxmIdBsnTcpFlags) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdBsnTcpFlagsMasked struct {
	*OxmId
}

type IOxmIdBsnTcpFlagsMasked interface {
	IOxmId
}

func (self *OxmIdBsnTcpFlagsMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdBsnTcpFlagsMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnTcpFlagsMasked, error) {
	_oxmidbsntcpflagsmasked := &OxmIdBsnTcpFlagsMasked{OxmId: parent}
	return _oxmidbsntcpflagsmasked, nil
}

func NewOxmIdBsnTcpFlagsMasked() *OxmIdBsnTcpFlagsMasked {
	obj := &OxmIdBsnTcpFlagsMasked{
		OxmId: NewOxmId(205060),
	}
	return obj
}
func (self *OxmIdBsnTcpFlagsMasked) GetOXMName() string {
	return "bsn_tcp_flags_masked"
}

func (self *OxmIdBsnTcpFlagsMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdBsnUdf0 struct {
	*OxmId
}

type IOxmIdBsnUdf0 interface {
	IOxmId
}

func (self *OxmIdBsnUdf0) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdBsnUdf0(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf0, error) {
	_oxmidbsnudf0 := &OxmIdBsnUdf0{OxmId: parent}
	return _oxmidbsnudf0, nil
}

func NewOxmIdBsnUdf0() *OxmIdBsnUdf0 {
	obj := &OxmIdBsnUdf0{
		OxmId: NewOxmId(200708),
	}
	return obj
}
func (self *OxmIdBsnUdf0) GetOXMName() string {
	return "bsn_udf0"
}

func (self *OxmIdBsnUdf0) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdBsnUdf0Masked struct {
	*OxmId
}

type IOxmIdBsnUdf0Masked interface {
	IOxmId
}

func (self *OxmIdBsnUdf0Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdBsnUdf0Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf0Masked, error) {
	_oxmidbsnudf0masked := &OxmIdBsnUdf0Masked{OxmId: parent}
	return _oxmidbsnudf0masked, nil
}

func NewOxmIdBsnUdf0Masked() *OxmIdBsnUdf0Masked {
	obj := &OxmIdBsnUdf0Masked{
		OxmId: NewOxmId(200968),
	}
	return obj
}
func (self *OxmIdBsnUdf0Masked) GetOXMName() string {
	return "bsn_udf0_masked"
}

func (self *OxmIdBsnUdf0Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdBsnUdf1 struct {
	*OxmId
}

type IOxmIdBsnUdf1 interface {
	IOxmId
}

func (self *OxmIdBsnUdf1) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdBsnUdf1(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf1, error) {
	_oxmidbsnudf1 := &OxmIdBsnUdf1{OxmId: parent}
	return _oxmidbsnudf1, nil
}

func NewOxmIdBsnUdf1() *OxmIdBsnUdf1 {
	obj := &OxmIdBsnUdf1{
		OxmId: NewOxmId(201220),
	}
	return obj
}
func (self *OxmIdBsnUdf1) GetOXMName() string {
	return "bsn_udf1"
}

func (self *OxmIdBsnUdf1) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdBsnUdf1Masked struct {
	*OxmId
}

type IOxmIdBsnUdf1Masked interface {
	IOxmId
}

func (self *OxmIdBsnUdf1Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdBsnUdf1Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf1Masked, error) {
	_oxmidbsnudf1masked := &OxmIdBsnUdf1Masked{OxmId: parent}
	return _oxmidbsnudf1masked, nil
}

func NewOxmIdBsnUdf1Masked() *OxmIdBsnUdf1Masked {
	obj := &OxmIdBsnUdf1Masked{
		OxmId: NewOxmId(201480),
	}
	return obj
}
func (self *OxmIdBsnUdf1Masked) GetOXMName() string {
	return "bsn_udf1_masked"
}

func (self *OxmIdBsnUdf1Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdBsnUdf2 struct {
	*OxmId
}

type IOxmIdBsnUdf2 interface {
	IOxmId
}

func (self *OxmIdBsnUdf2) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdBsnUdf2(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf2, error) {
	_oxmidbsnudf2 := &OxmIdBsnUdf2{OxmId: parent}
	return _oxmidbsnudf2, nil
}

func NewOxmIdBsnUdf2() *OxmIdBsnUdf2 {
	obj := &OxmIdBsnUdf2{
		OxmId: NewOxmId(201732),
	}
	return obj
}
func (self *OxmIdBsnUdf2) GetOXMName() string {
	return "bsn_udf2"
}

func (self *OxmIdBsnUdf2) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdBsnUdf2Masked struct {
	*OxmId
}

type IOxmIdBsnUdf2Masked interface {
	IOxmId
}

func (self *OxmIdBsnUdf2Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdBsnUdf2Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf2Masked, error) {
	_oxmidbsnudf2masked := &OxmIdBsnUdf2Masked{OxmId: parent}
	return _oxmidbsnudf2masked, nil
}

func NewOxmIdBsnUdf2Masked() *OxmIdBsnUdf2Masked {
	obj := &OxmIdBsnUdf2Masked{
		OxmId: NewOxmId(201992),
	}
	return obj
}
func (self *OxmIdBsnUdf2Masked) GetOXMName() string {
	return "bsn_udf2_masked"
}

func (self *OxmIdBsnUdf2Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdBsnUdf3 struct {
	*OxmId
}

type IOxmIdBsnUdf3 interface {
	IOxmId
}

func (self *OxmIdBsnUdf3) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdBsnUdf3(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf3, error) {
	_oxmidbsnudf3 := &OxmIdBsnUdf3{OxmId: parent}
	return _oxmidbsnudf3, nil
}

func NewOxmIdBsnUdf3() *OxmIdBsnUdf3 {
	obj := &OxmIdBsnUdf3{
		OxmId: NewOxmId(202244),
	}
	return obj
}
func (self *OxmIdBsnUdf3) GetOXMName() string {
	return "bsn_udf3"
}

func (self *OxmIdBsnUdf3) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdBsnUdf3Masked struct {
	*OxmId
}

type IOxmIdBsnUdf3Masked interface {
	IOxmId
}

func (self *OxmIdBsnUdf3Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdBsnUdf3Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf3Masked, error) {
	_oxmidbsnudf3masked := &OxmIdBsnUdf3Masked{OxmId: parent}
	return _oxmidbsnudf3masked, nil
}

func NewOxmIdBsnUdf3Masked() *OxmIdBsnUdf3Masked {
	obj := &OxmIdBsnUdf3Masked{
		OxmId: NewOxmId(202504),
	}
	return obj
}
func (self *OxmIdBsnUdf3Masked) GetOXMName() string {
	return "bsn_udf3_masked"
}

func (self *OxmIdBsnUdf3Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdBsnUdf4 struct {
	*OxmId
}

type IOxmIdBsnUdf4 interface {
	IOxmId
}

func (self *OxmIdBsnUdf4) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdBsnUdf4(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf4, error) {
	_oxmidbsnudf4 := &OxmIdBsnUdf4{OxmId: parent}
	return _oxmidbsnudf4, nil
}

func NewOxmIdBsnUdf4() *OxmIdBsnUdf4 {
	obj := &OxmIdBsnUdf4{
		OxmId: NewOxmId(202756),
	}
	return obj
}
func (self *OxmIdBsnUdf4) GetOXMName() string {
	return "bsn_udf4"
}

func (self *OxmIdBsnUdf4) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdBsnUdf4Masked struct {
	*OxmId
}

type IOxmIdBsnUdf4Masked interface {
	IOxmId
}

func (self *OxmIdBsnUdf4Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdBsnUdf4Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf4Masked, error) {
	_oxmidbsnudf4masked := &OxmIdBsnUdf4Masked{OxmId: parent}
	return _oxmidbsnudf4masked, nil
}

func NewOxmIdBsnUdf4Masked() *OxmIdBsnUdf4Masked {
	obj := &OxmIdBsnUdf4Masked{
		OxmId: NewOxmId(203016),
	}
	return obj
}
func (self *OxmIdBsnUdf4Masked) GetOXMName() string {
	return "bsn_udf4_masked"
}

func (self *OxmIdBsnUdf4Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdBsnUdf5 struct {
	*OxmId
}

type IOxmIdBsnUdf5 interface {
	IOxmId
}

func (self *OxmIdBsnUdf5) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdBsnUdf5(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf5, error) {
	_oxmidbsnudf5 := &OxmIdBsnUdf5{OxmId: parent}
	return _oxmidbsnudf5, nil
}

func NewOxmIdBsnUdf5() *OxmIdBsnUdf5 {
	obj := &OxmIdBsnUdf5{
		OxmId: NewOxmId(203268),
	}
	return obj
}
func (self *OxmIdBsnUdf5) GetOXMName() string {
	return "bsn_udf5"
}

func (self *OxmIdBsnUdf5) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdBsnUdf5Masked struct {
	*OxmId
}

type IOxmIdBsnUdf5Masked interface {
	IOxmId
}

func (self *OxmIdBsnUdf5Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdBsnUdf5Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf5Masked, error) {
	_oxmidbsnudf5masked := &OxmIdBsnUdf5Masked{OxmId: parent}
	return _oxmidbsnudf5masked, nil
}

func NewOxmIdBsnUdf5Masked() *OxmIdBsnUdf5Masked {
	obj := &OxmIdBsnUdf5Masked{
		OxmId: NewOxmId(203528),
	}
	return obj
}
func (self *OxmIdBsnUdf5Masked) GetOXMName() string {
	return "bsn_udf5_masked"
}

func (self *OxmIdBsnUdf5Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdBsnUdf6 struct {
	*OxmId
}

type IOxmIdBsnUdf6 interface {
	IOxmId
}

func (self *OxmIdBsnUdf6) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdBsnUdf6(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf6, error) {
	_oxmidbsnudf6 := &OxmIdBsnUdf6{OxmId: parent}
	return _oxmidbsnudf6, nil
}

func NewOxmIdBsnUdf6() *OxmIdBsnUdf6 {
	obj := &OxmIdBsnUdf6{
		OxmId: NewOxmId(203780),
	}
	return obj
}
func (self *OxmIdBsnUdf6) GetOXMName() string {
	return "bsn_udf6"
}

func (self *OxmIdBsnUdf6) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdBsnUdf6Masked struct {
	*OxmId
}

type IOxmIdBsnUdf6Masked interface {
	IOxmId
}

func (self *OxmIdBsnUdf6Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdBsnUdf6Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf6Masked, error) {
	_oxmidbsnudf6masked := &OxmIdBsnUdf6Masked{OxmId: parent}
	return _oxmidbsnudf6masked, nil
}

func NewOxmIdBsnUdf6Masked() *OxmIdBsnUdf6Masked {
	obj := &OxmIdBsnUdf6Masked{
		OxmId: NewOxmId(204040),
	}
	return obj
}
func (self *OxmIdBsnUdf6Masked) GetOXMName() string {
	return "bsn_udf6_masked"
}

func (self *OxmIdBsnUdf6Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdBsnUdf7 struct {
	*OxmId
}

type IOxmIdBsnUdf7 interface {
	IOxmId
}

func (self *OxmIdBsnUdf7) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdBsnUdf7(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf7, error) {
	_oxmidbsnudf7 := &OxmIdBsnUdf7{OxmId: parent}
	return _oxmidbsnudf7, nil
}

func NewOxmIdBsnUdf7() *OxmIdBsnUdf7 {
	obj := &OxmIdBsnUdf7{
		OxmId: NewOxmId(204292),
	}
	return obj
}
func (self *OxmIdBsnUdf7) GetOXMName() string {
	return "bsn_udf7"
}

func (self *OxmIdBsnUdf7) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdBsnUdf7Masked struct {
	*OxmId
}

type IOxmIdBsnUdf7Masked interface {
	IOxmId
}

func (self *OxmIdBsnUdf7Masked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdBsnUdf7Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf7Masked, error) {
	_oxmidbsnudf7masked := &OxmIdBsnUdf7Masked{OxmId: parent}
	return _oxmidbsnudf7masked, nil
}

func NewOxmIdBsnUdf7Masked() *OxmIdBsnUdf7Masked {
	obj := &OxmIdBsnUdf7Masked{
		OxmId: NewOxmId(204552),
	}
	return obj
}
func (self *OxmIdBsnUdf7Masked) GetOXMName() string {
	return "bsn_udf7_masked"
}

func (self *OxmIdBsnUdf7Masked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdBsnVfi struct {
	*OxmId
}

type IOxmIdBsnVfi interface {
	IOxmId
}

func (self *OxmIdBsnVfi) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdBsnVfi(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnVfi, error) {
	_oxmidbsnvfi := &OxmIdBsnVfi{OxmId: parent}
	return _oxmidbsnvfi, nil
}

func NewOxmIdBsnVfi() *OxmIdBsnVfi {
	obj := &OxmIdBsnVfi{
		OxmId: NewOxmId(209410),
	}
	return obj
}
func (self *OxmIdBsnVfi) GetOXMName() string {
	return "bsn_vfi"
}

func (self *OxmIdBsnVfi) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdBsnVfiMasked struct {
	*OxmId
}

type IOxmIdBsnVfiMasked interface {
	IOxmId
}

func (self *OxmIdBsnVfiMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdBsnVfiMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnVfiMasked, error) {
	_oxmidbsnvfimasked := &OxmIdBsnVfiMasked{OxmId: parent}
	return _oxmidbsnvfimasked, nil
}

func NewOxmIdBsnVfiMasked() *OxmIdBsnVfiMasked {
	obj := &OxmIdBsnVfiMasked{
		OxmId: NewOxmId(209668),
	}
	return obj
}
func (self *OxmIdBsnVfiMasked) GetOXMName() string {
	return "bsn_vfi_masked"
}

func (self *OxmIdBsnVfiMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdBsnVlanXlatePortGroupId struct {
	*OxmId
}

type IOxmIdBsnVlanXlatePortGroupId interface {
	IOxmId
}

func (self *OxmIdBsnVlanXlatePortGroupId) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdBsnVlanXlatePortGroupId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnVlanXlatePortGroupId, error) {
	_oxmidbsnvlanxlateportgroupid := &OxmIdBsnVlanXlatePortGroupId{OxmId: parent}
	return _oxmidbsnvlanxlateportgroupid, nil
}

func NewOxmIdBsnVlanXlatePortGroupId() *OxmIdBsnVlanXlatePortGroupId {
	obj := &OxmIdBsnVlanXlatePortGroupId{
		OxmId: NewOxmId(205316),
	}
	return obj
}
func (self *OxmIdBsnVlanXlatePortGroupId) GetOXMName() string {
	return "bsn_vlan_xlate_port_group_id"
}

func (self *OxmIdBsnVlanXlatePortGroupId) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdBsnVlanXlatePortGroupIdMasked struct {
	*OxmId
}

type IOxmIdBsnVlanXlatePortGroupIdMasked interface {
	IOxmId
}

func (self *OxmIdBsnVlanXlatePortGroupIdMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdBsnVlanXlatePortGroupIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnVlanXlatePortGroupIdMasked, error) {
	_oxmidbsnvlanxlateportgroupidmasked := &OxmIdBsnVlanXlatePortGroupIdMasked{OxmId: parent}
	return _oxmidbsnvlanxlateportgroupidmasked, nil
}

func NewOxmIdBsnVlanXlatePortGroupIdMasked() *OxmIdBsnVlanXlatePortGroupIdMasked {
	obj := &OxmIdBsnVlanXlatePortGroupIdMasked{
		OxmId: NewOxmId(205576),
	}
	return obj
}
func (self *OxmIdBsnVlanXlatePortGroupIdMasked) GetOXMName() string {
	return "bsn_vlan_xlate_port_group_id_masked"
}

func (self *OxmIdBsnVlanXlatePortGroupIdMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdBsnVrf struct {
	*OxmId
}

type IOxmIdBsnVrf interface {
	IOxmId
}

func (self *OxmIdBsnVrf) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdBsnVrf(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnVrf, error) {
	_oxmidbsnvrf := &OxmIdBsnVrf{OxmId: parent}
	return _oxmidbsnvrf, nil
}

func NewOxmIdBsnVrf() *OxmIdBsnVrf {
	obj := &OxmIdBsnVrf{
		OxmId: NewOxmId(197636),
	}
	return obj
}
func (self *OxmIdBsnVrf) GetOXMName() string {
	return "bsn_vrf"
}

func (self *OxmIdBsnVrf) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdBsnVrfMasked struct {
	*OxmId
}

type IOxmIdBsnVrfMasked interface {
	IOxmId
}

func (self *OxmIdBsnVrfMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdBsnVrfMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnVrfMasked, error) {
	_oxmidbsnvrfmasked := &OxmIdBsnVrfMasked{OxmId: parent}
	return _oxmidbsnvrfmasked, nil
}

func NewOxmIdBsnVrfMasked() *OxmIdBsnVrfMasked {
	obj := &OxmIdBsnVrfMasked{
		OxmId: NewOxmId(197896),
	}
	return obj
}
func (self *OxmIdBsnVrfMasked) GetOXMName() string {
	return "bsn_vrf_masked"
}

func (self *OxmIdBsnVrfMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdBsnVxlanNetworkId struct {
	*OxmId
}

type IOxmIdBsnVxlanNetworkId interface {
	IOxmId
}

func (self *OxmIdBsnVxlanNetworkId) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdBsnVxlanNetworkId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnVxlanNetworkId, error) {
	_oxmidbsnvxlannetworkid := &OxmIdBsnVxlanNetworkId{OxmId: parent}
	return _oxmidbsnvxlannetworkid, nil
}

func NewOxmIdBsnVxlanNetworkId() *OxmIdBsnVxlanNetworkId {
	obj := &OxmIdBsnVxlanNetworkId{
		OxmId: NewOxmId(207364),
	}
	return obj
}
func (self *OxmIdBsnVxlanNetworkId) GetOXMName() string {
	return "bsn_vxlan_network_id"
}

func (self *OxmIdBsnVxlanNetworkId) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdBsnVxlanNetworkIdMasked struct {
	*OxmId
}

type IOxmIdBsnVxlanNetworkIdMasked interface {
	IOxmId
}

func (self *OxmIdBsnVxlanNetworkIdMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdBsnVxlanNetworkIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnVxlanNetworkIdMasked, error) {
	_oxmidbsnvxlannetworkidmasked := &OxmIdBsnVxlanNetworkIdMasked{OxmId: parent}
	return _oxmidbsnvxlannetworkidmasked, nil
}

func NewOxmIdBsnVxlanNetworkIdMasked() *OxmIdBsnVxlanNetworkIdMasked {
	obj := &OxmIdBsnVxlanNetworkIdMasked{
		OxmId: NewOxmId(207624),
	}
	return obj
}
func (self *OxmIdBsnVxlanNetworkIdMasked) GetOXMName() string {
	return "bsn_vxlan_network_id_masked"
}

func (self *OxmIdBsnVxlanNetworkIdMasked) 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 OxmIdIpv6Exthdr struct {
	*OxmId
}

type IOxmIdIpv6Exthdr interface {
	IOxmId
}

func (self *OxmIdIpv6Exthdr) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdIpv6Exthdr(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6Exthdr, error) {
	_oxmidipv6exthdr := &OxmIdIpv6Exthdr{OxmId: parent}
	return _oxmidipv6exthdr, nil
}

func NewOxmIdIpv6Exthdr() *OxmIdIpv6Exthdr {
	obj := &OxmIdIpv6Exthdr{
		OxmId: NewOxmId(2147503618),
	}
	return obj
}
func (self *OxmIdIpv6Exthdr) GetOXMName() string {
	return "ipv6_exthdr"
}

func (self *OxmIdIpv6Exthdr) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdIpv6ExthdrMasked struct {
	*OxmId
}

type IOxmIdIpv6ExthdrMasked interface {
	IOxmId
}

func (self *OxmIdIpv6ExthdrMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdIpv6ExthdrMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6ExthdrMasked, error) {
	_oxmidipv6exthdrmasked := &OxmIdIpv6ExthdrMasked{OxmId: parent}
	return _oxmidipv6exthdrmasked, nil
}

func NewOxmIdIpv6ExthdrMasked() *OxmIdIpv6ExthdrMasked {
	obj := &OxmIdIpv6ExthdrMasked{
		OxmId: NewOxmId(2147503876),
	}
	return obj
}
func (self *OxmIdIpv6ExthdrMasked) GetOXMName() string {
	return "ipv6_exthdr_masked"
}

func (self *OxmIdIpv6ExthdrMasked) 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 OxmIdMplsBos struct {
	*OxmId
}

type IOxmIdMplsBos interface {
	IOxmId
}

func (self *OxmIdMplsBos) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdMplsBos(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMplsBos, error) {
	_oxmidmplsbos := &OxmIdMplsBos{OxmId: parent}
	return _oxmidmplsbos, nil
}

func NewOxmIdMplsBos() *OxmIdMplsBos {
	obj := &OxmIdMplsBos{
		OxmId: NewOxmId(2147502081),
	}
	return obj
}
func (self *OxmIdMplsBos) GetOXMName() string {
	return "mpls_bos"
}

func (self *OxmIdMplsBos) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdMplsBosMasked struct {
	*OxmId
}

type IOxmIdMplsBosMasked interface {
	IOxmId
}

func (self *OxmIdMplsBosMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdMplsBosMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMplsBosMasked, error) {
	_oxmidmplsbosmasked := &OxmIdMplsBosMasked{OxmId: parent}
	return _oxmidmplsbosmasked, nil
}

func NewOxmIdMplsBosMasked() *OxmIdMplsBosMasked {
	obj := &OxmIdMplsBosMasked{
		OxmId: NewOxmId(2147502338),
	}
	return obj
}
func (self *OxmIdMplsBosMasked) GetOXMName() string {
	return "mpls_bos_masked"
}

func (self *OxmIdMplsBosMasked) 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 OxmIdOvsTcpFlags struct {
	*OxmId
	ExperimenterId uint32
}

type IOxmIdOvsTcpFlags interface {
	IOxmId
	GetExperimenterId() uint32
}

func (self *OxmIdOvsTcpFlags) GetExperimenterId() uint32 {
	return self.ExperimenterId
}

func (self *OxmIdOvsTcpFlags) SetExperimenterId(v uint32) {
	self.ExperimenterId = v
}

func (self *OxmIdOvsTcpFlags) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint32(uint32(self.ExperimenterId))

	return nil
}

func DecodeOxmIdOvsTcpFlags(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdOvsTcpFlags, error) {
	_oxmidovstcpflags := &OxmIdOvsTcpFlags{OxmId: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("OxmIdOvsTcpFlags packet too short: %d < 4", decoder.Length())
	}
	_oxmidovstcpflags.ExperimenterId = uint32(decoder.ReadUint32())
	return _oxmidovstcpflags, nil
}

func NewOxmIdOvsTcpFlags() *OxmIdOvsTcpFlags {
	obj := &OxmIdOvsTcpFlags{
		OxmId: NewOxmId(4294923270),
	}
	return obj
}
func (self *OxmIdOvsTcpFlags) GetOXMName() string {
	return "ovs_tcp_flags"
}

func (self *OxmIdOvsTcpFlags) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdOvsTcpFlagsMasked struct {
	*OxmId
	ExperimenterId uint32
}

type IOxmIdOvsTcpFlagsMasked interface {
	IOxmId
	GetExperimenterId() uint32
}

func (self *OxmIdOvsTcpFlagsMasked) GetExperimenterId() uint32 {
	return self.ExperimenterId
}

func (self *OxmIdOvsTcpFlagsMasked) SetExperimenterId(v uint32) {
	self.ExperimenterId = v
}

func (self *OxmIdOvsTcpFlagsMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint32(uint32(self.ExperimenterId))

	return nil
}

func DecodeOxmIdOvsTcpFlagsMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdOvsTcpFlagsMasked, error) {
	_oxmidovstcpflagsmasked := &OxmIdOvsTcpFlagsMasked{OxmId: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("OxmIdOvsTcpFlagsMasked packet too short: %d < 4", decoder.Length())
	}
	_oxmidovstcpflagsmasked.ExperimenterId = uint32(decoder.ReadUint32())
	return _oxmidovstcpflagsmasked, nil
}

func NewOxmIdOvsTcpFlagsMasked() *OxmIdOvsTcpFlagsMasked {
	obj := &OxmIdOvsTcpFlagsMasked{
		OxmId: NewOxmId(4294923528),
	}
	return obj
}
func (self *OxmIdOvsTcpFlagsMasked) GetOXMName() string {
	return "ovs_tcp_flags_masked"
}

func (self *OxmIdOvsTcpFlagsMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdPacketType struct {
	*OxmId
}

type IOxmIdPacketType interface {
	IOxmId
}

func (self *OxmIdPacketType) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdPacketType(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdPacketType, error) {
	_oxmidpackettype := &OxmIdPacketType{OxmId: parent}
	return _oxmidpackettype, nil
}

func NewOxmIdPacketType() *OxmIdPacketType {
	obj := &OxmIdPacketType{
		OxmId: NewOxmId(2147506180),
	}
	return obj
}
func (self *OxmIdPacketType) GetOXMName() string {
	return "packet_type"
}

func (self *OxmIdPacketType) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdPbbUca struct {
	*OxmId
}

type IOxmIdPbbUca interface {
	IOxmId
}

func (self *OxmIdPbbUca) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdPbbUca(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdPbbUca, error) {
	_oxmidpbbuca := &OxmIdPbbUca{OxmId: parent}
	return _oxmidpbbuca, nil
}

func NewOxmIdPbbUca() *OxmIdPbbUca {
	obj := &OxmIdPbbUca{
		OxmId: NewOxmId(2147504641),
	}
	return obj
}
func (self *OxmIdPbbUca) GetOXMName() string {
	return "pbb_uca"
}

func (self *OxmIdPbbUca) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdPbbUcaMasked struct {
	*OxmId
}

type IOxmIdPbbUcaMasked interface {
	IOxmId
}

func (self *OxmIdPbbUcaMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdPbbUcaMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdPbbUcaMasked, error) {
	_oxmidpbbucamasked := &OxmIdPbbUcaMasked{OxmId: parent}
	return _oxmidpbbucamasked, nil
}

func NewOxmIdPbbUcaMasked() *OxmIdPbbUcaMasked {
	obj := &OxmIdPbbUcaMasked{
		OxmId: NewOxmId(2147504898),
	}
	return obj
}
func (self *OxmIdPbbUcaMasked) GetOXMName() string {
	return "pbb_uca_masked"
}

func (self *OxmIdPbbUcaMasked) 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 OxmIdTunnelId struct {
	*OxmId
}

type IOxmIdTunnelId interface {
	IOxmId
}

func (self *OxmIdTunnelId) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunnelId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunnelId, error) {
	_oxmidtunnelid := &OxmIdTunnelId{OxmId: parent}
	return _oxmidtunnelid, nil
}

func NewOxmIdTunnelId() *OxmIdTunnelId {
	obj := &OxmIdTunnelId{
		OxmId: NewOxmId(2147503112),
	}
	return obj
}
func (self *OxmIdTunnelId) GetOXMName() string {
	return "tunnel_id"
}

func (self *OxmIdTunnelId) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunnelIdMasked struct {
	*OxmId
}

type IOxmIdTunnelIdMasked interface {
	IOxmId
}

func (self *OxmIdTunnelIdMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunnelIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunnelIdMasked, error) {
	_oxmidtunnelidmasked := &OxmIdTunnelIdMasked{OxmId: parent}
	return _oxmidtunnelidmasked, nil
}

func NewOxmIdTunnelIdMasked() *OxmIdTunnelIdMasked {
	obj := &OxmIdTunnelIdMasked{
		OxmId: NewOxmId(2147503376),
	}
	return obj
}
func (self *OxmIdTunnelIdMasked) GetOXMName() string {
	return "tunnel_id_masked"
}

func (self *OxmIdTunnelIdMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunnelIpv4Dst struct {
	*OxmId
}

type IOxmIdTunnelIpv4Dst interface {
	IOxmId
}

func (self *OxmIdTunnelIpv4Dst) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunnelIpv4Dst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunnelIpv4Dst, error) {
	_oxmidtunnelipv4dst := &OxmIdTunnelIpv4Dst{OxmId: parent}
	return _oxmidtunnelipv4dst, nil
}

func NewOxmIdTunnelIpv4Dst() *OxmIdTunnelIpv4Dst {
	obj := &OxmIdTunnelIpv4Dst{
		OxmId: NewOxmId(81924),
	}
	return obj
}
func (self *OxmIdTunnelIpv4Dst) GetOXMName() string {
	return "tunnel_ipv4_dst"
}

func (self *OxmIdTunnelIpv4Dst) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunnelIpv4DstMasked struct {
	*OxmId
}

type IOxmIdTunnelIpv4DstMasked interface {
	IOxmId
}

func (self *OxmIdTunnelIpv4DstMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunnelIpv4DstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunnelIpv4DstMasked, error) {
	_oxmidtunnelipv4dstmasked := &OxmIdTunnelIpv4DstMasked{OxmId: parent}
	return _oxmidtunnelipv4dstmasked, nil
}

func NewOxmIdTunnelIpv4DstMasked() *OxmIdTunnelIpv4DstMasked {
	obj := &OxmIdTunnelIpv4DstMasked{
		OxmId: NewOxmId(82184),
	}
	return obj
}
func (self *OxmIdTunnelIpv4DstMasked) GetOXMName() string {
	return "tunnel_ipv4_dst_masked"
}

func (self *OxmIdTunnelIpv4DstMasked) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunnelIpv4Src struct {
	*OxmId
}

type IOxmIdTunnelIpv4Src interface {
	IOxmId
}

func (self *OxmIdTunnelIpv4Src) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunnelIpv4Src(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunnelIpv4Src, error) {
	_oxmidtunnelipv4src := &OxmIdTunnelIpv4Src{OxmId: parent}
	return _oxmidtunnelipv4src, nil
}

func NewOxmIdTunnelIpv4Src() *OxmIdTunnelIpv4Src {
	obj := &OxmIdTunnelIpv4Src{
		OxmId: NewOxmId(81412),
	}
	return obj
}
func (self *OxmIdTunnelIpv4Src) GetOXMName() string {
	return "tunnel_ipv4_src"
}

func (self *OxmIdTunnelIpv4Src) MarshalJSON() ([]byte, error) {
	if self.TypeLen == 0 {
		return []byte("\"\""), nil
	} else {
		return []byte("\"" + self.GetOXMName() + "\""), nil
	}
}

type OxmIdTunnelIpv4SrcMasked struct {
	*OxmId
}

type IOxmIdTunnelIpv4SrcMasked interface {
	IOxmId
}

func (self *OxmIdTunnelIpv4SrcMasked) Serialize(encoder *goloxi.Encoder) error {
	if err := self.OxmId.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeOxmIdTunnelIpv4SrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunnelIpv4SrcMasked, error) {
	_oxmidtunnelipv4srcmasked := &OxmIdTunnelIpv4SrcMasked{OxmId: parent}
	return _oxmidtunnelipv4srcmasked, nil
}

func NewOxmIdTunnelIpv4SrcMasked() *OxmIdTunnelIpv4SrcMasked {
	obj := &OxmIdTunnelIpv4SrcMasked{
		OxmId: NewOxmId(81672),
	}
	return obj
}
func (self *OxmIdTunnelIpv4SrcMasked) GetOXMName() string {
	return "tunnel_ipv4_src_masked"
}

func (self *OxmIdTunnelIpv4SrcMasked) 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
	Port       Port
	Len        uint16
	Properties []IQueueProp
}

type IPacketQueue interface {
	goloxi.Serializable
	GetQueueId() uint32
	GetPort() Port
	GetLen() uint16
	GetProperties() []IQueueProp
}

func (self *PacketQueue) GetQueueId() uint32 {
	return self.QueueId
}

func (self *PacketQueue) SetQueueId(v uint32) {
	self.QueueId = v
}

func (self *PacketQueue) GetPort() Port {
	return self.Port
}

func (self *PacketQueue) SetPort(v Port) {
	self.Port = 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))
	self.Port.Serialize(encoder)
	encoder.PutUint16(uint16(self.Len))
	encoder.Write(bytes.Repeat([]byte{0}, 6))
	for _, obj := range self.Properties {
		if err := obj.Serialize(encoder); err != nil {
			return err
		}
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+8:startIndex+10], uint16(length))

	return nil
}

func DecodePacketQueue(decoder *goloxi.Decoder) (*PacketQueue, error) {
	_packetqueue := &PacketQueue{}
	if decoder.Length() < 16 {
		return nil, fmt.Errorf("PacketQueue packet too short: %d < 16", decoder.Length())
	}
	_packetqueue.QueueId = uint32(decoder.ReadUint32())
	_packetqueue.Port.Decode(decoder)
	_packetqueue.Len = uint16(decoder.ReadUint16())
	oldDecoder := decoder
	defer func() { decoder = oldDecoder }()
	decoder = decoder.SliceDecoder(int(_packetqueue.Len), 2+8)
	decoder.Skip(6)

	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
	Length     uint16
	HwAddr     net.HardwareAddr
	Name       string
	Config     PortConfig
	State      PortState
	Properties []IPortDescProp
}

type IPortDesc interface {
	goloxi.Serializable
	GetPortNo() Port
	GetLength() uint16
	GetHwAddr() net.HardwareAddr
	GetName() string
	GetConfig() PortConfig
	GetState() PortState
	GetProperties() []IPortDescProp
}

func (self *PortDesc) GetPortNo() Port {
	return self.PortNo
}

func (self *PortDesc) SetPortNo(v Port) {
	self.PortNo = v
}

func (self *PortDesc) GetLength() uint16 {
	return self.Length
}

func (self *PortDesc) SetLength(v uint16) {
	self.Length = 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) GetProperties() []IPortDescProp {
	return self.Properties
}

func (self *PortDesc) SetProperties(v []IPortDescProp) {
	self.Properties = v
}

func (self *PortDesc) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())

	self.PortNo.Serialize(encoder)
	encoder.PutUint16(uint16(self.Length))
	encoder.Write(bytes.Repeat([]byte{0}, 2))
	encoder.Write(self.HwAddr)
	encoder.Write(bytes.Repeat([]byte{0}, 2))
	encoder.Write([]byte(self.Name))
	encoder.PutUint32(uint32(self.Config))
	encoder.PutUint32(uint32(self.State))
	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 (self *PortDesc) Decode(decoder *goloxi.Decoder) error {
	if decoder.Length() < 40 {
		return fmt.Errorf("PortDesc packet too short: %d < 40", decoder.Length())
	}

	self.PortNo.Decode(decoder)
	self.Length = uint16(decoder.ReadUint16())
	oldDecoder := decoder
	defer func() { decoder = oldDecoder }()
	decoder = decoder.SliceDecoder(int(self.Length), 2+4)
	decoder.Skip(2)
	self.HwAddr = net.HardwareAddr(decoder.Read(6))
	decoder.Skip(2)
	self.Name = string(bytes.Trim(decoder.Read(16), "\x00"))
	self.Config = PortConfig(decoder.ReadUint32())
	self.State = PortState(decoder.ReadUint32())

	for decoder.Length() >= 4 {
		item, err := DecodePortDescProp(decoder)
		if err != nil {
			return err
		}
		if item != nil {
			self.Properties = append(self.Properties, item)
		}
	}

	return nil
}

func NewPortDesc() *PortDesc {
	obj := &PortDesc{}
	return obj
}

type PortDescProp struct {
	Type   uint16
	Length uint16
}

type IPortDescProp interface {
	goloxi.Serializable
	GetType() uint16
	GetLength() uint16
}

func (self *PortDescProp) GetType() uint16 {
	return self.Type
}

func (self *PortDescProp) SetType(v uint16) {
	self.Type = v
}

func (self *PortDescProp) GetLength() uint16 {
	return self.Length
}

func (self *PortDescProp) SetLength(v uint16) {
	self.Length = v
}

func (self *PortDescProp) Serialize(encoder *goloxi.Encoder) error {

	encoder.PutUint16(uint16(self.Type))
	encoder.PutUint16(uint16(self.Length))

	return nil
}

func DecodePortDescProp(decoder *goloxi.Decoder) (IPortDescProp, error) {
	_portdescprop := &PortDescProp{}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("PortDescProp packet too short: %d < 4", decoder.Length())
	}
	_portdescprop.Type = uint16(decoder.ReadUint16())
	_portdescprop.Length = uint16(decoder.ReadUint16())
	oldDecoder := decoder
	defer func() { decoder = oldDecoder }()
	decoder = decoder.SliceDecoder(int(_portdescprop.Length), 2+2)

	switch _portdescprop.Type {
	case 0:
		return DecodePortDescPropEthernet(_portdescprop, decoder)
	case 1:
		return DecodePortDescPropOptical(_portdescprop, decoder)
	case 65535:
		return DecodePortDescPropExperimenter(_portdescprop, decoder)
	default:
		return nil, fmt.Errorf("Invalid type '%d' for 'PortDescProp'", _portdescprop.Type)
	}
}

func NewPortDescProp(_type uint16) *PortDescProp {
	obj := &PortDescProp{}
	obj.Type = _type
	return obj
}

type PortDescPropExperimenter struct {
	*PortDescProp
	Experimenter uint32
	ExpType      uint32
}

type IPortDescPropExperimenter interface {
	IPortDescProp
	GetExperimenter() uint32
	GetExpType() uint32
}

func (self *PortDescPropExperimenter) GetExperimenter() uint32 {
	return self.Experimenter
}

func (self *PortDescPropExperimenter) SetExperimenter(v uint32) {
	self.Experimenter = v
}

func (self *PortDescPropExperimenter) GetExpType() uint32 {
	return self.ExpType
}

func (self *PortDescPropExperimenter) SetExpType(v uint32) {
	self.ExpType = v
}

func (self *PortDescPropExperimenter) Serialize(encoder *goloxi.Encoder) error {
	if err := self.PortDescProp.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint32(uint32(self.Experimenter))
	encoder.PutUint32(uint32(self.ExpType))

	return nil
}

func DecodePortDescPropExperimenter(parent *PortDescProp, decoder *goloxi.Decoder) (IPortDescPropExperimenter, error) {
	_portdescpropexperimenter := &PortDescPropExperimenter{PortDescProp: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("PortDescPropExperimenter packet too short: %d < 8", decoder.Length())
	}
	_portdescpropexperimenter.Experimenter = uint32(decoder.ReadUint32())
	_portdescpropexperimenter.ExpType = uint32(decoder.ReadUint32())

	switch _portdescpropexperimenter.Experimenter {
	case 6035143:
		return DecodePortDescPropBsn(_portdescpropexperimenter, decoder)
	default:
		return nil, fmt.Errorf("Invalid type '%d' for 'PortDescPropExperimenter'", _portdescpropexperimenter.Experimenter)
	}
}

func NewPortDescPropExperimenter(_experimenter uint32) *PortDescPropExperimenter {
	obj := &PortDescPropExperimenter{
		PortDescProp: NewPortDescProp(65535),
	}
	obj.Experimenter = _experimenter
	return obj
}

type PortDescPropBsn struct {
	*PortDescPropExperimenter
}

type IPortDescPropBsn interface {
	IPortDescPropExperimenter
}

func (self *PortDescPropBsn) Serialize(encoder *goloxi.Encoder) error {
	if err := self.PortDescPropExperimenter.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodePortDescPropBsn(parent *PortDescPropExperimenter, decoder *goloxi.Decoder) (IPortDescPropBsn, error) {
	_portdescpropbsn := &PortDescPropBsn{PortDescPropExperimenter: parent}

	switch _portdescpropbsn.ExpType {
	case 0:
		return DecodePortDescPropBsnUplink(_portdescpropbsn, decoder)
	case 1:
		return DecodePortDescPropBsnGenerationId(_portdescpropbsn, decoder)
	case 2:
		return DecodePortDescPropBsnForwardErrorCorrection(_portdescpropbsn, decoder)
	case 3:
		return DecodePortDescPropBsnBreakout(_portdescpropbsn, decoder)
	case 4:
		return DecodePortDescPropBsnSpeedCapabilities(_portdescpropbsn, decoder)
	case 5:
		return DecodePortDescPropBsnMiscCapabilities(_portdescpropbsn, decoder)
	case 6:
		return DecodePortDescPropBsnSffJson(_portdescpropbsn, decoder)
	case 7:
		return DecodePortDescPropBsnDriverInfoJson(_portdescpropbsn, decoder)
	case 8:
		return DecodePortDescPropBsnExtendedCapabilities(_portdescpropbsn, decoder)
	default:
		return nil, fmt.Errorf("Invalid type '%d' for 'PortDescPropBsn'", _portdescpropbsn.ExpType)
	}
}

func NewPortDescPropBsn(_exp_type uint32) *PortDescPropBsn {
	obj := &PortDescPropBsn{
		PortDescPropExperimenter: NewPortDescPropExperimenter(6035143),
	}
	obj.ExpType = _exp_type
	return obj
}

type PortDescPropBsnBreakout struct {
	*PortDescPropBsn
	SubInterfaceCount     uint16
	SubInterfaceSpeedGbps uint16
}

type IPortDescPropBsnBreakout interface {
	IPortDescPropBsn
	GetSubInterfaceCount() uint16
	GetSubInterfaceSpeedGbps() uint16
}

func (self *PortDescPropBsnBreakout) GetSubInterfaceCount() uint16 {
	return self.SubInterfaceCount
}

func (self *PortDescPropBsnBreakout) SetSubInterfaceCount(v uint16) {
	self.SubInterfaceCount = v
}

func (self *PortDescPropBsnBreakout) GetSubInterfaceSpeedGbps() uint16 {
	return self.SubInterfaceSpeedGbps
}

func (self *PortDescPropBsnBreakout) SetSubInterfaceSpeedGbps(v uint16) {
	self.SubInterfaceSpeedGbps = v
}

func (self *PortDescPropBsnBreakout) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.PortDescPropBsn.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint16(uint16(self.SubInterfaceCount))
	encoder.PutUint16(uint16(self.SubInterfaceSpeedGbps))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodePortDescPropBsnBreakout(parent *PortDescPropBsn, decoder *goloxi.Decoder) (*PortDescPropBsnBreakout, error) {
	_portdescpropbsnbreakout := &PortDescPropBsnBreakout{PortDescPropBsn: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("PortDescPropBsnBreakout packet too short: %d < 4", decoder.Length())
	}
	_portdescpropbsnbreakout.SubInterfaceCount = uint16(decoder.ReadUint16())
	_portdescpropbsnbreakout.SubInterfaceSpeedGbps = uint16(decoder.ReadUint16())
	return _portdescpropbsnbreakout, nil
}

func NewPortDescPropBsnBreakout() *PortDescPropBsnBreakout {
	obj := &PortDescPropBsnBreakout{
		PortDescPropBsn: NewPortDescPropBsn(3),
	}
	return obj
}

type PortDescPropBsnDriverInfoJson struct {
	*PortDescPropBsn
	DriverInfoJson []byte
}

type IPortDescPropBsnDriverInfoJson interface {
	IPortDescPropBsn
	GetDriverInfoJson() []byte
}

func (self *PortDescPropBsnDriverInfoJson) GetDriverInfoJson() []byte {
	return self.DriverInfoJson
}

func (self *PortDescPropBsnDriverInfoJson) SetDriverInfoJson(v []byte) {
	self.DriverInfoJson = v
}

func (self *PortDescPropBsnDriverInfoJson) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.PortDescPropBsn.Serialize(encoder); err != nil {
		return err
	}

	encoder.Write(self.DriverInfoJson)
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodePortDescPropBsnDriverInfoJson(parent *PortDescPropBsn, decoder *goloxi.Decoder) (*PortDescPropBsnDriverInfoJson, error) {
	_portdescpropbsndriverinfojson := &PortDescPropBsnDriverInfoJson{PortDescPropBsn: parent}
	_portdescpropbsndriverinfojson.DriverInfoJson = decoder.Read(int(decoder.Length()))
	return _portdescpropbsndriverinfojson, nil
}

func NewPortDescPropBsnDriverInfoJson() *PortDescPropBsnDriverInfoJson {
	obj := &PortDescPropBsnDriverInfoJson{
		PortDescPropBsn: NewPortDescPropBsn(7),
	}
	return obj
}

type PortDescPropBsnExtendedCapabilities struct {
	*PortDescPropBsn
	Configurability uint64
	Conflict        uint64
	Reserved1       uint64
	Reserved2       uint64
}

type IPortDescPropBsnExtendedCapabilities interface {
	IPortDescPropBsn
	GetConfigurability() uint64
	GetConflict() uint64
	GetReserved1() uint64
	GetReserved2() uint64
}

func (self *PortDescPropBsnExtendedCapabilities) GetConfigurability() uint64 {
	return self.Configurability
}

func (self *PortDescPropBsnExtendedCapabilities) SetConfigurability(v uint64) {
	self.Configurability = v
}

func (self *PortDescPropBsnExtendedCapabilities) GetConflict() uint64 {
	return self.Conflict
}

func (self *PortDescPropBsnExtendedCapabilities) SetConflict(v uint64) {
	self.Conflict = v
}

func (self *PortDescPropBsnExtendedCapabilities) GetReserved1() uint64 {
	return self.Reserved1
}

func (self *PortDescPropBsnExtendedCapabilities) SetReserved1(v uint64) {
	self.Reserved1 = v
}

func (self *PortDescPropBsnExtendedCapabilities) GetReserved2() uint64 {
	return self.Reserved2
}

func (self *PortDescPropBsnExtendedCapabilities) SetReserved2(v uint64) {
	self.Reserved2 = v
}

func (self *PortDescPropBsnExtendedCapabilities) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.PortDescPropBsn.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint64(uint64(self.Configurability))
	encoder.PutUint64(uint64(self.Conflict))
	encoder.PutUint64(uint64(self.Reserved1))
	encoder.PutUint64(uint64(self.Reserved2))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodePortDescPropBsnExtendedCapabilities(parent *PortDescPropBsn, decoder *goloxi.Decoder) (*PortDescPropBsnExtendedCapabilities, error) {
	_portdescpropbsnextendedcapabilities := &PortDescPropBsnExtendedCapabilities{PortDescPropBsn: parent}
	if decoder.Length() < 32 {
		return nil, fmt.Errorf("PortDescPropBsnExtendedCapabilities packet too short: %d < 32", decoder.Length())
	}
	_portdescpropbsnextendedcapabilities.Configurability = uint64(decoder.ReadUint64())
	_portdescpropbsnextendedcapabilities.Conflict = uint64(decoder.ReadUint64())
	_portdescpropbsnextendedcapabilities.Reserved1 = uint64(decoder.ReadUint64())
	_portdescpropbsnextendedcapabilities.Reserved2 = uint64(decoder.ReadUint64())
	return _portdescpropbsnextendedcapabilities, nil
}

func NewPortDescPropBsnExtendedCapabilities() *PortDescPropBsnExtendedCapabilities {
	obj := &PortDescPropBsnExtendedCapabilities{
		PortDescPropBsn: NewPortDescPropBsn(8),
	}
	return obj
}

type PortDescPropBsnForwardErrorCorrection struct {
	*PortDescPropBsn
	Configured BsnFecConfigState
	Enabled    uint32
}

type IPortDescPropBsnForwardErrorCorrection interface {
	IPortDescPropBsn
	GetConfigured() BsnFecConfigState
	GetEnabled() uint32
}

func (self *PortDescPropBsnForwardErrorCorrection) GetConfigured() BsnFecConfigState {
	return self.Configured
}

func (self *PortDescPropBsnForwardErrorCorrection) SetConfigured(v BsnFecConfigState) {
	self.Configured = v
}

func (self *PortDescPropBsnForwardErrorCorrection) GetEnabled() uint32 {
	return self.Enabled
}

func (self *PortDescPropBsnForwardErrorCorrection) SetEnabled(v uint32) {
	self.Enabled = v
}

func (self *PortDescPropBsnForwardErrorCorrection) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.PortDescPropBsn.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint32(uint32(self.Configured))
	encoder.PutUint32(uint32(self.Enabled))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodePortDescPropBsnForwardErrorCorrection(parent *PortDescPropBsn, decoder *goloxi.Decoder) (*PortDescPropBsnForwardErrorCorrection, error) {
	_portdescpropbsnforwarderrorcorrection := &PortDescPropBsnForwardErrorCorrection{PortDescPropBsn: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("PortDescPropBsnForwardErrorCorrection packet too short: %d < 8", decoder.Length())
	}
	_portdescpropbsnforwarderrorcorrection.Configured = BsnFecConfigState(decoder.ReadUint32())
	_portdescpropbsnforwarderrorcorrection.Enabled = uint32(decoder.ReadUint32())
	return _portdescpropbsnforwarderrorcorrection, nil
}

func NewPortDescPropBsnForwardErrorCorrection() *PortDescPropBsnForwardErrorCorrection {
	obj := &PortDescPropBsnForwardErrorCorrection{
		PortDescPropBsn: NewPortDescPropBsn(2),
	}
	return obj
}

type PortDescPropBsnGenerationId struct {
	*PortDescPropBsn
	GenerationId uint64
}

type IPortDescPropBsnGenerationId interface {
	IPortDescPropBsn
	GetGenerationId() uint64
}

func (self *PortDescPropBsnGenerationId) GetGenerationId() uint64 {
	return self.GenerationId
}

func (self *PortDescPropBsnGenerationId) SetGenerationId(v uint64) {
	self.GenerationId = v
}

func (self *PortDescPropBsnGenerationId) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.PortDescPropBsn.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint64(uint64(self.GenerationId))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodePortDescPropBsnGenerationId(parent *PortDescPropBsn, decoder *goloxi.Decoder) (*PortDescPropBsnGenerationId, error) {
	_portdescpropbsngenerationid := &PortDescPropBsnGenerationId{PortDescPropBsn: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("PortDescPropBsnGenerationId packet too short: %d < 8", decoder.Length())
	}
	_portdescpropbsngenerationid.GenerationId = uint64(decoder.ReadUint64())
	return _portdescpropbsngenerationid, nil
}

func NewPortDescPropBsnGenerationId() *PortDescPropBsnGenerationId {
	obj := &PortDescPropBsnGenerationId{
		PortDescPropBsn: NewPortDescPropBsn(1),
	}
	return obj
}

type PortDescPropBsnMiscCapabilities struct {
	*PortDescPropBsn
	Current   uint64
	Available uint64
	Supported uint64
}

type IPortDescPropBsnMiscCapabilities interface {
	IPortDescPropBsn
	GetCurrent() uint64
	GetAvailable() uint64
	GetSupported() uint64
}

func (self *PortDescPropBsnMiscCapabilities) GetCurrent() uint64 {
	return self.Current
}

func (self *PortDescPropBsnMiscCapabilities) SetCurrent(v uint64) {
	self.Current = v
}

func (self *PortDescPropBsnMiscCapabilities) GetAvailable() uint64 {
	return self.Available
}

func (self *PortDescPropBsnMiscCapabilities) SetAvailable(v uint64) {
	self.Available = v
}

func (self *PortDescPropBsnMiscCapabilities) GetSupported() uint64 {
	return self.Supported
}

func (self *PortDescPropBsnMiscCapabilities) SetSupported(v uint64) {
	self.Supported = v
}

func (self *PortDescPropBsnMiscCapabilities) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.PortDescPropBsn.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint64(uint64(self.Current))
	encoder.PutUint64(uint64(self.Available))
	encoder.PutUint64(uint64(self.Supported))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodePortDescPropBsnMiscCapabilities(parent *PortDescPropBsn, decoder *goloxi.Decoder) (*PortDescPropBsnMiscCapabilities, error) {
	_portdescpropbsnmisccapabilities := &PortDescPropBsnMiscCapabilities{PortDescPropBsn: parent}
	if decoder.Length() < 24 {
		return nil, fmt.Errorf("PortDescPropBsnMiscCapabilities packet too short: %d < 24", decoder.Length())
	}
	_portdescpropbsnmisccapabilities.Current = uint64(decoder.ReadUint64())
	_portdescpropbsnmisccapabilities.Available = uint64(decoder.ReadUint64())
	_portdescpropbsnmisccapabilities.Supported = uint64(decoder.ReadUint64())
	return _portdescpropbsnmisccapabilities, nil
}

func NewPortDescPropBsnMiscCapabilities() *PortDescPropBsnMiscCapabilities {
	obj := &PortDescPropBsnMiscCapabilities{
		PortDescPropBsn: NewPortDescPropBsn(5),
	}
	return obj
}

type PortDescPropBsnSffJson struct {
	*PortDescPropBsn
	DataJson []byte
}

type IPortDescPropBsnSffJson interface {
	IPortDescPropBsn
	GetDataJson() []byte
}

func (self *PortDescPropBsnSffJson) GetDataJson() []byte {
	return self.DataJson
}

func (self *PortDescPropBsnSffJson) SetDataJson(v []byte) {
	self.DataJson = v
}

func (self *PortDescPropBsnSffJson) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.PortDescPropBsn.Serialize(encoder); err != nil {
		return err
	}

	encoder.Write(self.DataJson)
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodePortDescPropBsnSffJson(parent *PortDescPropBsn, decoder *goloxi.Decoder) (*PortDescPropBsnSffJson, error) {
	_portdescpropbsnsffjson := &PortDescPropBsnSffJson{PortDescPropBsn: parent}
	_portdescpropbsnsffjson.DataJson = decoder.Read(int(decoder.Length()))
	return _portdescpropbsnsffjson, nil
}

func NewPortDescPropBsnSffJson() *PortDescPropBsnSffJson {
	obj := &PortDescPropBsnSffJson{
		PortDescPropBsn: NewPortDescPropBsn(6),
	}
	return obj
}

type PortDescPropBsnSpeedCapabilities struct {
	*PortDescPropBsn
	Current   uint64
	Available uint64
	Supported uint64
}

type IPortDescPropBsnSpeedCapabilities interface {
	IPortDescPropBsn
	GetCurrent() uint64
	GetAvailable() uint64
	GetSupported() uint64
}

func (self *PortDescPropBsnSpeedCapabilities) GetCurrent() uint64 {
	return self.Current
}

func (self *PortDescPropBsnSpeedCapabilities) SetCurrent(v uint64) {
	self.Current = v
}

func (self *PortDescPropBsnSpeedCapabilities) GetAvailable() uint64 {
	return self.Available
}

func (self *PortDescPropBsnSpeedCapabilities) SetAvailable(v uint64) {
	self.Available = v
}

func (self *PortDescPropBsnSpeedCapabilities) GetSupported() uint64 {
	return self.Supported
}

func (self *PortDescPropBsnSpeedCapabilities) SetSupported(v uint64) {
	self.Supported = v
}

func (self *PortDescPropBsnSpeedCapabilities) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.PortDescPropBsn.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint64(uint64(self.Current))
	encoder.PutUint64(uint64(self.Available))
	encoder.PutUint64(uint64(self.Supported))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodePortDescPropBsnSpeedCapabilities(parent *PortDescPropBsn, decoder *goloxi.Decoder) (*PortDescPropBsnSpeedCapabilities, error) {
	_portdescpropbsnspeedcapabilities := &PortDescPropBsnSpeedCapabilities{PortDescPropBsn: parent}
	if decoder.Length() < 24 {
		return nil, fmt.Errorf("PortDescPropBsnSpeedCapabilities packet too short: %d < 24", decoder.Length())
	}
	_portdescpropbsnspeedcapabilities.Current = uint64(decoder.ReadUint64())
	_portdescpropbsnspeedcapabilities.Available = uint64(decoder.ReadUint64())
	_portdescpropbsnspeedcapabilities.Supported = uint64(decoder.ReadUint64())
	return _portdescpropbsnspeedcapabilities, nil
}

func NewPortDescPropBsnSpeedCapabilities() *PortDescPropBsnSpeedCapabilities {
	obj := &PortDescPropBsnSpeedCapabilities{
		PortDescPropBsn: NewPortDescPropBsn(4),
	}
	return obj
}

type PortDescPropBsnUplink struct {
	*PortDescPropBsn
}

type IPortDescPropBsnUplink interface {
	IPortDescPropBsn
}

func (self *PortDescPropBsnUplink) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.PortDescPropBsn.Serialize(encoder); err != nil {
		return err
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodePortDescPropBsnUplink(parent *PortDescPropBsn, decoder *goloxi.Decoder) (*PortDescPropBsnUplink, error) {
	_portdescpropbsnuplink := &PortDescPropBsnUplink{PortDescPropBsn: parent}
	return _portdescpropbsnuplink, nil
}

func NewPortDescPropBsnUplink() *PortDescPropBsnUplink {
	obj := &PortDescPropBsnUplink{
		PortDescPropBsn: NewPortDescPropBsn(0),
	}
	return obj
}

type PortDescPropEthernet struct {
	*PortDescProp
	Curr       uint32
	Advertised uint32
	Supported  uint32
	Peer       uint32
	CurrSpeed  uint32
	MaxSpeed   uint32
}

type IPortDescPropEthernet interface {
	IPortDescProp
	GetCurr() uint32
	GetAdvertised() uint32
	GetSupported() uint32
	GetPeer() uint32
	GetCurrSpeed() uint32
	GetMaxSpeed() uint32
}

func (self *PortDescPropEthernet) GetCurr() uint32 {
	return self.Curr
}

func (self *PortDescPropEthernet) SetCurr(v uint32) {
	self.Curr = v
}

func (self *PortDescPropEthernet) GetAdvertised() uint32 {
	return self.Advertised
}

func (self *PortDescPropEthernet) SetAdvertised(v uint32) {
	self.Advertised = v
}

func (self *PortDescPropEthernet) GetSupported() uint32 {
	return self.Supported
}

func (self *PortDescPropEthernet) SetSupported(v uint32) {
	self.Supported = v
}

func (self *PortDescPropEthernet) GetPeer() uint32 {
	return self.Peer
}

func (self *PortDescPropEthernet) SetPeer(v uint32) {
	self.Peer = v
}

func (self *PortDescPropEthernet) GetCurrSpeed() uint32 {
	return self.CurrSpeed
}

func (self *PortDescPropEthernet) SetCurrSpeed(v uint32) {
	self.CurrSpeed = v
}

func (self *PortDescPropEthernet) GetMaxSpeed() uint32 {
	return self.MaxSpeed
}

func (self *PortDescPropEthernet) SetMaxSpeed(v uint32) {
	self.MaxSpeed = v
}

func (self *PortDescPropEthernet) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.PortDescProp.Serialize(encoder); err != nil {
		return err
	}

	encoder.Write(bytes.Repeat([]byte{0}, 4))
	encoder.PutUint32(uint32(self.Curr))
	encoder.PutUint32(uint32(self.Advertised))
	encoder.PutUint32(uint32(self.Supported))
	encoder.PutUint32(uint32(self.Peer))
	encoder.PutUint32(uint32(self.CurrSpeed))
	encoder.PutUint32(uint32(self.MaxSpeed))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodePortDescPropEthernet(parent *PortDescProp, decoder *goloxi.Decoder) (*PortDescPropEthernet, error) {
	_portdescpropethernet := &PortDescPropEthernet{PortDescProp: parent}
	if decoder.Length() < 28 {
		return nil, fmt.Errorf("PortDescPropEthernet packet too short: %d < 28", decoder.Length())
	}
	decoder.Skip(4)
	_portdescpropethernet.Curr = uint32(decoder.ReadUint32())
	_portdescpropethernet.Advertised = uint32(decoder.ReadUint32())
	_portdescpropethernet.Supported = uint32(decoder.ReadUint32())
	_portdescpropethernet.Peer = uint32(decoder.ReadUint32())
	_portdescpropethernet.CurrSpeed = uint32(decoder.ReadUint32())
	_portdescpropethernet.MaxSpeed = uint32(decoder.ReadUint32())
	return _portdescpropethernet, nil
}

func NewPortDescPropEthernet() *PortDescPropEthernet {
	obj := &PortDescPropEthernet{
		PortDescProp: NewPortDescProp(0),
	}
	return obj
}

type PortDescPropOptical struct {
	*PortDescProp
	Supported      uint32
	TxMinFreqLmda  uint32
	TxMaxFreqLmda  uint32
	TxGridFreqLmda uint32
	RxMinFreqLmda  uint32
	RxMaxFreqLmda  uint32
	RxGridFreqLmda uint32
	TxPwrMin       uint32
	TxPwrMax       uint32
}

type IPortDescPropOptical interface {
	IPortDescProp
	GetSupported() uint32
	GetTxMinFreqLmda() uint32
	GetTxMaxFreqLmda() uint32
	GetTxGridFreqLmda() uint32
	GetRxMinFreqLmda() uint32
	GetRxMaxFreqLmda() uint32
	GetRxGridFreqLmda() uint32
	GetTxPwrMin() uint32
	GetTxPwrMax() uint32
}

func (self *PortDescPropOptical) GetSupported() uint32 {
	return self.Supported
}

func (self *PortDescPropOptical) SetSupported(v uint32) {
	self.Supported = v
}

func (self *PortDescPropOptical) GetTxMinFreqLmda() uint32 {
	return self.TxMinFreqLmda
}

func (self *PortDescPropOptical) SetTxMinFreqLmda(v uint32) {
	self.TxMinFreqLmda = v
}

func (self *PortDescPropOptical) GetTxMaxFreqLmda() uint32 {
	return self.TxMaxFreqLmda
}

func (self *PortDescPropOptical) SetTxMaxFreqLmda(v uint32) {
	self.TxMaxFreqLmda = v
}

func (self *PortDescPropOptical) GetTxGridFreqLmda() uint32 {
	return self.TxGridFreqLmda
}

func (self *PortDescPropOptical) SetTxGridFreqLmda(v uint32) {
	self.TxGridFreqLmda = v
}

func (self *PortDescPropOptical) GetRxMinFreqLmda() uint32 {
	return self.RxMinFreqLmda
}

func (self *PortDescPropOptical) SetRxMinFreqLmda(v uint32) {
	self.RxMinFreqLmda = v
}

func (self *PortDescPropOptical) GetRxMaxFreqLmda() uint32 {
	return self.RxMaxFreqLmda
}

func (self *PortDescPropOptical) SetRxMaxFreqLmda(v uint32) {
	self.RxMaxFreqLmda = v
}

func (self *PortDescPropOptical) GetRxGridFreqLmda() uint32 {
	return self.RxGridFreqLmda
}

func (self *PortDescPropOptical) SetRxGridFreqLmda(v uint32) {
	self.RxGridFreqLmda = v
}

func (self *PortDescPropOptical) GetTxPwrMin() uint32 {
	return self.TxPwrMin
}

func (self *PortDescPropOptical) SetTxPwrMin(v uint32) {
	self.TxPwrMin = v
}

func (self *PortDescPropOptical) GetTxPwrMax() uint32 {
	return self.TxPwrMax
}

func (self *PortDescPropOptical) SetTxPwrMax(v uint32) {
	self.TxPwrMax = v
}

func (self *PortDescPropOptical) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.PortDescProp.Serialize(encoder); err != nil {
		return err
	}

	encoder.Write(bytes.Repeat([]byte{0}, 4))
	encoder.PutUint32(uint32(self.Supported))
	encoder.PutUint32(uint32(self.TxMinFreqLmda))
	encoder.PutUint32(uint32(self.TxMaxFreqLmda))
	encoder.PutUint32(uint32(self.TxGridFreqLmda))
	encoder.PutUint32(uint32(self.RxMinFreqLmda))
	encoder.PutUint32(uint32(self.RxMaxFreqLmda))
	encoder.PutUint32(uint32(self.RxGridFreqLmda))
	encoder.PutUint32(uint32(self.TxPwrMin))
	encoder.PutUint32(uint32(self.TxPwrMax))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodePortDescPropOptical(parent *PortDescProp, decoder *goloxi.Decoder) (*PortDescPropOptical, error) {
	_portdescpropoptical := &PortDescPropOptical{PortDescProp: parent}
	if decoder.Length() < 40 {
		return nil, fmt.Errorf("PortDescPropOptical packet too short: %d < 40", decoder.Length())
	}
	decoder.Skip(4)
	_portdescpropoptical.Supported = uint32(decoder.ReadUint32())
	_portdescpropoptical.TxMinFreqLmda = uint32(decoder.ReadUint32())
	_portdescpropoptical.TxMaxFreqLmda = uint32(decoder.ReadUint32())
	_portdescpropoptical.TxGridFreqLmda = uint32(decoder.ReadUint32())
	_portdescpropoptical.RxMinFreqLmda = uint32(decoder.ReadUint32())
	_portdescpropoptical.RxMaxFreqLmda = uint32(decoder.ReadUint32())
	_portdescpropoptical.RxGridFreqLmda = uint32(decoder.ReadUint32())
	_portdescpropoptical.TxPwrMin = uint32(decoder.ReadUint32())
	_portdescpropoptical.TxPwrMax = uint32(decoder.ReadUint32())
	return _portdescpropoptical, nil
}

func NewPortDescPropOptical() *PortDescPropOptical {
	obj := &PortDescPropOptical{
		PortDescProp: NewPortDescProp(1),
	}
	return obj
}

type PortModProp struct {
	Type   uint16
	Length uint16
}

type IPortModProp interface {
	goloxi.Serializable
	GetType() uint16
	GetLength() uint16
}

func (self *PortModProp) GetType() uint16 {
	return self.Type
}

func (self *PortModProp) SetType(v uint16) {
	self.Type = v
}

func (self *PortModProp) GetLength() uint16 {
	return self.Length
}

func (self *PortModProp) SetLength(v uint16) {
	self.Length = v
}

func (self *PortModProp) Serialize(encoder *goloxi.Encoder) error {

	encoder.PutUint16(uint16(self.Type))
	encoder.PutUint16(uint16(self.Length))

	return nil
}

func DecodePortModProp(decoder *goloxi.Decoder) (IPortModProp, error) {
	_portmodprop := &PortModProp{}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("PortModProp packet too short: %d < 4", decoder.Length())
	}
	_portmodprop.Type = uint16(decoder.ReadUint16())
	_portmodprop.Length = uint16(decoder.ReadUint16())
	oldDecoder := decoder
	defer func() { decoder = oldDecoder }()
	decoder = decoder.SliceDecoder(int(_portmodprop.Length), 2+2)

	switch _portmodprop.Type {
	case 0:
		return DecodePortModPropEthernet(_portmodprop, decoder)
	case 1:
		return DecodePortModPropOptical(_portmodprop, decoder)
	case 65535:
		return DecodePortModPropExperimenter(_portmodprop, decoder)
	default:
		return nil, fmt.Errorf("Invalid type '%d' for 'PortModProp'", _portmodprop.Type)
	}
}

func NewPortModProp(_type uint16) *PortModProp {
	obj := &PortModProp{}
	obj.Type = _type
	return obj
}

type PortModPropEthernet struct {
	*PortModProp
	Advertise PortFeatures
}

type IPortModPropEthernet interface {
	IPortModProp
	GetAdvertise() PortFeatures
}

func (self *PortModPropEthernet) GetAdvertise() PortFeatures {
	return self.Advertise
}

func (self *PortModPropEthernet) SetAdvertise(v PortFeatures) {
	self.Advertise = v
}

func (self *PortModPropEthernet) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.PortModProp.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint32(uint32(self.Advertise))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodePortModPropEthernet(parent *PortModProp, decoder *goloxi.Decoder) (*PortModPropEthernet, error) {
	_portmodpropethernet := &PortModPropEthernet{PortModProp: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("PortModPropEthernet packet too short: %d < 4", decoder.Length())
	}
	_portmodpropethernet.Advertise = PortFeatures(decoder.ReadUint32())
	return _portmodpropethernet, nil
}

func NewPortModPropEthernet() *PortModPropEthernet {
	obj := &PortModPropEthernet{
		PortModProp: NewPortModProp(0),
	}
	return obj
}

type PortModPropExperimenter struct {
	*PortModProp
	Experimenter uint32
	ExpType      uint32
}

type IPortModPropExperimenter interface {
	IPortModProp
	GetExperimenter() uint32
	GetExpType() uint32
}

func (self *PortModPropExperimenter) GetExperimenter() uint32 {
	return self.Experimenter
}

func (self *PortModPropExperimenter) SetExperimenter(v uint32) {
	self.Experimenter = v
}

func (self *PortModPropExperimenter) GetExpType() uint32 {
	return self.ExpType
}

func (self *PortModPropExperimenter) SetExpType(v uint32) {
	self.ExpType = v
}

func (self *PortModPropExperimenter) Serialize(encoder *goloxi.Encoder) error {
	if err := self.PortModProp.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint32(uint32(self.Experimenter))
	encoder.PutUint32(uint32(self.ExpType))

	return nil
}

func DecodePortModPropExperimenter(parent *PortModProp, decoder *goloxi.Decoder) (IPortModPropExperimenter, error) {
	_portmodpropexperimenter := &PortModPropExperimenter{PortModProp: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("PortModPropExperimenter packet too short: %d < 8", decoder.Length())
	}
	_portmodpropexperimenter.Experimenter = uint32(decoder.ReadUint32())
	_portmodpropexperimenter.ExpType = uint32(decoder.ReadUint32())
	return _portmodpropexperimenter, nil
}

func NewPortModPropExperimenter(_experimenter uint32) *PortModPropExperimenter {
	obj := &PortModPropExperimenter{
		PortModProp: NewPortModProp(65535),
	}
	obj.Experimenter = _experimenter
	return obj
}

type PortModPropOptical struct {
	*PortModProp
	Configure uint32
	FreqLdma  uint32
	FlOffset  uint32
	GridSpan  uint32
	TxPwr     uint32
}

type IPortModPropOptical interface {
	IPortModProp
	GetConfigure() uint32
	GetFreqLdma() uint32
	GetFlOffset() uint32
	GetGridSpan() uint32
	GetTxPwr() uint32
}

func (self *PortModPropOptical) GetConfigure() uint32 {
	return self.Configure
}

func (self *PortModPropOptical) SetConfigure(v uint32) {
	self.Configure = v
}

func (self *PortModPropOptical) GetFreqLdma() uint32 {
	return self.FreqLdma
}

func (self *PortModPropOptical) SetFreqLdma(v uint32) {
	self.FreqLdma = v
}

func (self *PortModPropOptical) GetFlOffset() uint32 {
	return self.FlOffset
}

func (self *PortModPropOptical) SetFlOffset(v uint32) {
	self.FlOffset = v
}

func (self *PortModPropOptical) GetGridSpan() uint32 {
	return self.GridSpan
}

func (self *PortModPropOptical) SetGridSpan(v uint32) {
	self.GridSpan = v
}

func (self *PortModPropOptical) GetTxPwr() uint32 {
	return self.TxPwr
}

func (self *PortModPropOptical) SetTxPwr(v uint32) {
	self.TxPwr = v
}

func (self *PortModPropOptical) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.PortModProp.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint32(uint32(self.Configure))
	encoder.PutUint32(uint32(self.FreqLdma))
	encoder.PutUint32(uint32(self.FlOffset))
	encoder.PutUint32(uint32(self.GridSpan))
	encoder.PutUint32(uint32(self.TxPwr))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodePortModPropOptical(parent *PortModProp, decoder *goloxi.Decoder) (*PortModPropOptical, error) {
	_portmodpropoptical := &PortModPropOptical{PortModProp: parent}
	if decoder.Length() < 20 {
		return nil, fmt.Errorf("PortModPropOptical packet too short: %d < 20", decoder.Length())
	}
	_portmodpropoptical.Configure = uint32(decoder.ReadUint32())
	_portmodpropoptical.FreqLdma = uint32(decoder.ReadUint32())
	_portmodpropoptical.FlOffset = uint32(decoder.ReadUint32())
	_portmodpropoptical.GridSpan = uint32(decoder.ReadUint32())
	_portmodpropoptical.TxPwr = uint32(decoder.ReadUint32())
	return _portmodpropoptical, nil
}

func NewPortModPropOptical() *PortModPropOptical {
	obj := &PortModPropOptical{
		PortModProp: NewPortModProp(1),
	}
	return obj
}

type PortStatsEntry struct {
	Length       uint16
	PortNo       Port
	DurationSec  uint32
	DurationNsec uint32
	RxPackets    uint64
	TxPackets    uint64
	RxBytes      uint64
	TxBytes      uint64
	RxDropped    uint64
	TxDropped    uint64
	RxErrors     uint64
	TxErrors     uint64
	Properties   []IPortStatsProp
}

type IPortStatsEntry interface {
	goloxi.Serializable
	GetLength() uint16
	GetPortNo() Port
	GetDurationSec() uint32
	GetDurationNsec() uint32
	GetRxPackets() uint64
	GetTxPackets() uint64
	GetRxBytes() uint64
	GetTxBytes() uint64
	GetRxDropped() uint64
	GetTxDropped() uint64
	GetRxErrors() uint64
	GetTxErrors() uint64
	GetProperties() []IPortStatsProp
}

func (self *PortStatsEntry) GetLength() uint16 {
	return self.Length
}

func (self *PortStatsEntry) SetLength(v uint16) {
	self.Length = v
}

func (self *PortStatsEntry) GetPortNo() Port {
	return self.PortNo
}

func (self *PortStatsEntry) SetPortNo(v Port) {
	self.PortNo = v
}

func (self *PortStatsEntry) GetDurationSec() uint32 {
	return self.DurationSec
}

func (self *PortStatsEntry) SetDurationSec(v uint32) {
	self.DurationSec = v
}

func (self *PortStatsEntry) GetDurationNsec() uint32 {
	return self.DurationNsec
}

func (self *PortStatsEntry) SetDurationNsec(v uint32) {
	self.DurationNsec = 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) GetProperties() []IPortStatsProp {
	return self.Properties
}

func (self *PortStatsEntry) SetProperties(v []IPortStatsProp) {
	self.Properties = v
}

func (self *PortStatsEntry) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())

	encoder.PutUint16(uint16(self.Length))
	encoder.Write(bytes.Repeat([]byte{0}, 2))
	self.PortNo.Serialize(encoder)
	encoder.PutUint32(uint32(self.DurationSec))
	encoder.PutUint32(uint32(self.DurationNsec))
	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))
	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+0:startIndex+2], uint16(length))

	return nil
}

func DecodePortStatsEntry(decoder *goloxi.Decoder) (*PortStatsEntry, error) {
	_portstatsentry := &PortStatsEntry{}
	if decoder.Length() < 80 {
		return nil, fmt.Errorf("PortStatsEntry packet too short: %d < 80", decoder.Length())
	}
	_portstatsentry.Length = uint16(decoder.ReadUint16())
	oldDecoder := decoder
	defer func() { decoder = oldDecoder }()
	decoder = decoder.SliceDecoder(int(_portstatsentry.Length), 2+0)
	decoder.Skip(2)
	_portstatsentry.PortNo.Decode(decoder)
	_portstatsentry.DurationSec = uint32(decoder.ReadUint32())
	_portstatsentry.DurationNsec = uint32(decoder.ReadUint32())
	_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())

	for decoder.Length() >= 4 {
		item, err := DecodePortStatsProp(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_portstatsentry.Properties = append(_portstatsentry.Properties, item)
		}
	}
	return _portstatsentry, nil
}

func NewPortStatsEntry() *PortStatsEntry {
	obj := &PortStatsEntry{}
	return obj
}

type PortStatsProp struct {
	Type   uint16
	Length uint16
}

type IPortStatsProp interface {
	goloxi.Serializable
	GetType() uint16
	GetLength() uint16
}

func (self *PortStatsProp) GetType() uint16 {
	return self.Type
}

func (self *PortStatsProp) SetType(v uint16) {
	self.Type = v
}

func (self *PortStatsProp) GetLength() uint16 {
	return self.Length
}

func (self *PortStatsProp) SetLength(v uint16) {
	self.Length = v
}

func (self *PortStatsProp) Serialize(encoder *goloxi.Encoder) error {

	encoder.PutUint16(uint16(self.Type))
	encoder.PutUint16(uint16(self.Length))

	return nil
}

func DecodePortStatsProp(decoder *goloxi.Decoder) (IPortStatsProp, error) {
	_portstatsprop := &PortStatsProp{}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("PortStatsProp packet too short: %d < 4", decoder.Length())
	}
	_portstatsprop.Type = uint16(decoder.ReadUint16())
	_portstatsprop.Length = uint16(decoder.ReadUint16())
	oldDecoder := decoder
	defer func() { decoder = oldDecoder }()
	decoder = decoder.SliceDecoder(int(_portstatsprop.Length), 2+2)

	switch _portstatsprop.Type {
	case 0:
		return DecodePortStatsPropEthernet(_portstatsprop, decoder)
	case 1:
		return DecodePortStatsPropOptical(_portstatsprop, decoder)
	case 65535:
		return DecodePortStatsPropExperimenter(_portstatsprop, decoder)
	default:
		return nil, fmt.Errorf("Invalid type '%d' for 'PortStatsProp'", _portstatsprop.Type)
	}
}

func NewPortStatsProp(_type uint16) *PortStatsProp {
	obj := &PortStatsProp{}
	obj.Type = _type
	return obj
}

type PortStatsPropEthernet struct {
	*PortStatsProp
	RxFrameErr uint64
	RxOverErr  uint64
	RxCrcErr   uint64
	Collisions uint64
}

type IPortStatsPropEthernet interface {
	IPortStatsProp
	GetRxFrameErr() uint64
	GetRxOverErr() uint64
	GetRxCrcErr() uint64
	GetCollisions() uint64
}

func (self *PortStatsPropEthernet) GetRxFrameErr() uint64 {
	return self.RxFrameErr
}

func (self *PortStatsPropEthernet) SetRxFrameErr(v uint64) {
	self.RxFrameErr = v
}

func (self *PortStatsPropEthernet) GetRxOverErr() uint64 {
	return self.RxOverErr
}

func (self *PortStatsPropEthernet) SetRxOverErr(v uint64) {
	self.RxOverErr = v
}

func (self *PortStatsPropEthernet) GetRxCrcErr() uint64 {
	return self.RxCrcErr
}

func (self *PortStatsPropEthernet) SetRxCrcErr(v uint64) {
	self.RxCrcErr = v
}

func (self *PortStatsPropEthernet) GetCollisions() uint64 {
	return self.Collisions
}

func (self *PortStatsPropEthernet) SetCollisions(v uint64) {
	self.Collisions = v
}

func (self *PortStatsPropEthernet) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.PortStatsProp.Serialize(encoder); err != nil {
		return err
	}

	encoder.Write(bytes.Repeat([]byte{0}, 4))
	encoder.PutUint64(uint64(self.RxFrameErr))
	encoder.PutUint64(uint64(self.RxOverErr))
	encoder.PutUint64(uint64(self.RxCrcErr))
	encoder.PutUint64(uint64(self.Collisions))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodePortStatsPropEthernet(parent *PortStatsProp, decoder *goloxi.Decoder) (*PortStatsPropEthernet, error) {
	_portstatspropethernet := &PortStatsPropEthernet{PortStatsProp: parent}
	if decoder.Length() < 36 {
		return nil, fmt.Errorf("PortStatsPropEthernet packet too short: %d < 36", decoder.Length())
	}
	decoder.Skip(4)
	_portstatspropethernet.RxFrameErr = uint64(decoder.ReadUint64())
	_portstatspropethernet.RxOverErr = uint64(decoder.ReadUint64())
	_portstatspropethernet.RxCrcErr = uint64(decoder.ReadUint64())
	_portstatspropethernet.Collisions = uint64(decoder.ReadUint64())
	return _portstatspropethernet, nil
}

func NewPortStatsPropEthernet() *PortStatsPropEthernet {
	obj := &PortStatsPropEthernet{
		PortStatsProp: NewPortStatsProp(0),
	}
	return obj
}

type PortStatsPropExperimenter struct {
	*PortStatsProp
	Experimenter uint32
	ExpType      uint32
}

type IPortStatsPropExperimenter interface {
	IPortStatsProp
	GetExperimenter() uint32
	GetExpType() uint32
}

func (self *PortStatsPropExperimenter) GetExperimenter() uint32 {
	return self.Experimenter
}

func (self *PortStatsPropExperimenter) SetExperimenter(v uint32) {
	self.Experimenter = v
}

func (self *PortStatsPropExperimenter) GetExpType() uint32 {
	return self.ExpType
}

func (self *PortStatsPropExperimenter) SetExpType(v uint32) {
	self.ExpType = v
}

func (self *PortStatsPropExperimenter) Serialize(encoder *goloxi.Encoder) error {
	if err := self.PortStatsProp.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint32(uint32(self.Experimenter))
	encoder.PutUint32(uint32(self.ExpType))

	return nil
}

func DecodePortStatsPropExperimenter(parent *PortStatsProp, decoder *goloxi.Decoder) (IPortStatsPropExperimenter, error) {
	_portstatspropexperimenter := &PortStatsPropExperimenter{PortStatsProp: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("PortStatsPropExperimenter packet too short: %d < 8", decoder.Length())
	}
	_portstatspropexperimenter.Experimenter = uint32(decoder.ReadUint32())
	_portstatspropexperimenter.ExpType = uint32(decoder.ReadUint32())

	switch _portstatspropexperimenter.Experimenter {
	case 43521:
		return DecodePortStatsPropExperimenterIntel(_portstatspropexperimenter, decoder)
	default:
		return nil, fmt.Errorf("Invalid type '%d' for 'PortStatsPropExperimenter'", _portstatspropexperimenter.Experimenter)
	}
}

func NewPortStatsPropExperimenter(_experimenter uint32) *PortStatsPropExperimenter {
	obj := &PortStatsPropExperimenter{
		PortStatsProp: NewPortStatsProp(65535),
	}
	obj.Experimenter = _experimenter
	return obj
}

type PortStatsPropExperimenterIntel struct {
	*PortStatsPropExperimenter
	Rx1To64Packets      uint64
	Rx65To127Packets    uint64
	Rx128To255Packets   uint64
	Rx256To511Packets   uint64
	Rx512To1023Packets  uint64
	Rx1024To1522Packets uint64
	Rx1523ToMaxPackets  uint64
	Tx1To64Packets      uint64
	Tx65To127Packets    uint64
	Tx128To255Packets   uint64
	Tx256To511Packets   uint64
	Tx512To1023Packets  uint64
	Tx1024To1522Packets uint64
	Tx1523ToMaxPackets  uint64
	TxMulticastPackets  uint64
	RxBroadcastPackets  uint64
	TxBroadcastPackets  uint64
	RxUndersizedErrors  uint64
	RxOversizeErrors    uint64
	RxFragmentedErrors  uint64
	RxJabberErrors      uint64
}

type IPortStatsPropExperimenterIntel interface {
	IPortStatsPropExperimenter
	GetRx1To64Packets() uint64
	GetRx65To127Packets() uint64
	GetRx128To255Packets() uint64
	GetRx256To511Packets() uint64
	GetRx512To1023Packets() uint64
	GetRx1024To1522Packets() uint64
	GetRx1523ToMaxPackets() uint64
	GetTx1To64Packets() uint64
	GetTx65To127Packets() uint64
	GetTx128To255Packets() uint64
	GetTx256To511Packets() uint64
	GetTx512To1023Packets() uint64
	GetTx1024To1522Packets() uint64
	GetTx1523ToMaxPackets() uint64
	GetTxMulticastPackets() uint64
	GetRxBroadcastPackets() uint64
	GetTxBroadcastPackets() uint64
	GetRxUndersizedErrors() uint64
	GetRxOversizeErrors() uint64
	GetRxFragmentedErrors() uint64
	GetRxJabberErrors() uint64
}

func (self *PortStatsPropExperimenterIntel) GetRx1To64Packets() uint64 {
	return self.Rx1To64Packets
}

func (self *PortStatsPropExperimenterIntel) SetRx1To64Packets(v uint64) {
	self.Rx1To64Packets = v
}

func (self *PortStatsPropExperimenterIntel) GetRx65To127Packets() uint64 {
	return self.Rx65To127Packets
}

func (self *PortStatsPropExperimenterIntel) SetRx65To127Packets(v uint64) {
	self.Rx65To127Packets = v
}

func (self *PortStatsPropExperimenterIntel) GetRx128To255Packets() uint64 {
	return self.Rx128To255Packets
}

func (self *PortStatsPropExperimenterIntel) SetRx128To255Packets(v uint64) {
	self.Rx128To255Packets = v
}

func (self *PortStatsPropExperimenterIntel) GetRx256To511Packets() uint64 {
	return self.Rx256To511Packets
}

func (self *PortStatsPropExperimenterIntel) SetRx256To511Packets(v uint64) {
	self.Rx256To511Packets = v
}

func (self *PortStatsPropExperimenterIntel) GetRx512To1023Packets() uint64 {
	return self.Rx512To1023Packets
}

func (self *PortStatsPropExperimenterIntel) SetRx512To1023Packets(v uint64) {
	self.Rx512To1023Packets = v
}

func (self *PortStatsPropExperimenterIntel) GetRx1024To1522Packets() uint64 {
	return self.Rx1024To1522Packets
}

func (self *PortStatsPropExperimenterIntel) SetRx1024To1522Packets(v uint64) {
	self.Rx1024To1522Packets = v
}

func (self *PortStatsPropExperimenterIntel) GetRx1523ToMaxPackets() uint64 {
	return self.Rx1523ToMaxPackets
}

func (self *PortStatsPropExperimenterIntel) SetRx1523ToMaxPackets(v uint64) {
	self.Rx1523ToMaxPackets = v
}

func (self *PortStatsPropExperimenterIntel) GetTx1To64Packets() uint64 {
	return self.Tx1To64Packets
}

func (self *PortStatsPropExperimenterIntel) SetTx1To64Packets(v uint64) {
	self.Tx1To64Packets = v
}

func (self *PortStatsPropExperimenterIntel) GetTx65To127Packets() uint64 {
	return self.Tx65To127Packets
}

func (self *PortStatsPropExperimenterIntel) SetTx65To127Packets(v uint64) {
	self.Tx65To127Packets = v
}

func (self *PortStatsPropExperimenterIntel) GetTx128To255Packets() uint64 {
	return self.Tx128To255Packets
}

func (self *PortStatsPropExperimenterIntel) SetTx128To255Packets(v uint64) {
	self.Tx128To255Packets = v
}

func (self *PortStatsPropExperimenterIntel) GetTx256To511Packets() uint64 {
	return self.Tx256To511Packets
}

func (self *PortStatsPropExperimenterIntel) SetTx256To511Packets(v uint64) {
	self.Tx256To511Packets = v
}

func (self *PortStatsPropExperimenterIntel) GetTx512To1023Packets() uint64 {
	return self.Tx512To1023Packets
}

func (self *PortStatsPropExperimenterIntel) SetTx512To1023Packets(v uint64) {
	self.Tx512To1023Packets = v
}

func (self *PortStatsPropExperimenterIntel) GetTx1024To1522Packets() uint64 {
	return self.Tx1024To1522Packets
}

func (self *PortStatsPropExperimenterIntel) SetTx1024To1522Packets(v uint64) {
	self.Tx1024To1522Packets = v
}

func (self *PortStatsPropExperimenterIntel) GetTx1523ToMaxPackets() uint64 {
	return self.Tx1523ToMaxPackets
}

func (self *PortStatsPropExperimenterIntel) SetTx1523ToMaxPackets(v uint64) {
	self.Tx1523ToMaxPackets = v
}

func (self *PortStatsPropExperimenterIntel) GetTxMulticastPackets() uint64 {
	return self.TxMulticastPackets
}

func (self *PortStatsPropExperimenterIntel) SetTxMulticastPackets(v uint64) {
	self.TxMulticastPackets = v
}

func (self *PortStatsPropExperimenterIntel) GetRxBroadcastPackets() uint64 {
	return self.RxBroadcastPackets
}

func (self *PortStatsPropExperimenterIntel) SetRxBroadcastPackets(v uint64) {
	self.RxBroadcastPackets = v
}

func (self *PortStatsPropExperimenterIntel) GetTxBroadcastPackets() uint64 {
	return self.TxBroadcastPackets
}

func (self *PortStatsPropExperimenterIntel) SetTxBroadcastPackets(v uint64) {
	self.TxBroadcastPackets = v
}

func (self *PortStatsPropExperimenterIntel) GetRxUndersizedErrors() uint64 {
	return self.RxUndersizedErrors
}

func (self *PortStatsPropExperimenterIntel) SetRxUndersizedErrors(v uint64) {
	self.RxUndersizedErrors = v
}

func (self *PortStatsPropExperimenterIntel) GetRxOversizeErrors() uint64 {
	return self.RxOversizeErrors
}

func (self *PortStatsPropExperimenterIntel) SetRxOversizeErrors(v uint64) {
	self.RxOversizeErrors = v
}

func (self *PortStatsPropExperimenterIntel) GetRxFragmentedErrors() uint64 {
	return self.RxFragmentedErrors
}

func (self *PortStatsPropExperimenterIntel) SetRxFragmentedErrors(v uint64) {
	self.RxFragmentedErrors = v
}

func (self *PortStatsPropExperimenterIntel) GetRxJabberErrors() uint64 {
	return self.RxJabberErrors
}

func (self *PortStatsPropExperimenterIntel) SetRxJabberErrors(v uint64) {
	self.RxJabberErrors = v
}

func (self *PortStatsPropExperimenterIntel) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.PortStatsPropExperimenter.Serialize(encoder); err != nil {
		return err
	}

	encoder.Write(bytes.Repeat([]byte{0}, 4))
	encoder.PutUint64(uint64(self.Rx1To64Packets))
	encoder.PutUint64(uint64(self.Rx65To127Packets))
	encoder.PutUint64(uint64(self.Rx128To255Packets))
	encoder.PutUint64(uint64(self.Rx256To511Packets))
	encoder.PutUint64(uint64(self.Rx512To1023Packets))
	encoder.PutUint64(uint64(self.Rx1024To1522Packets))
	encoder.PutUint64(uint64(self.Rx1523ToMaxPackets))
	encoder.PutUint64(uint64(self.Tx1To64Packets))
	encoder.PutUint64(uint64(self.Tx65To127Packets))
	encoder.PutUint64(uint64(self.Tx128To255Packets))
	encoder.PutUint64(uint64(self.Tx256To511Packets))
	encoder.PutUint64(uint64(self.Tx512To1023Packets))
	encoder.PutUint64(uint64(self.Tx1024To1522Packets))
	encoder.PutUint64(uint64(self.Tx1523ToMaxPackets))
	encoder.PutUint64(uint64(self.TxMulticastPackets))
	encoder.PutUint64(uint64(self.RxBroadcastPackets))
	encoder.PutUint64(uint64(self.TxBroadcastPackets))
	encoder.PutUint64(uint64(self.RxUndersizedErrors))
	encoder.PutUint64(uint64(self.RxOversizeErrors))
	encoder.PutUint64(uint64(self.RxFragmentedErrors))
	encoder.PutUint64(uint64(self.RxJabberErrors))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodePortStatsPropExperimenterIntel(parent *PortStatsPropExperimenter, decoder *goloxi.Decoder) (*PortStatsPropExperimenterIntel, error) {
	_portstatspropexperimenterintel := &PortStatsPropExperimenterIntel{PortStatsPropExperimenter: parent}
	if decoder.Length() < 172 {
		return nil, fmt.Errorf("PortStatsPropExperimenterIntel packet too short: %d < 172", decoder.Length())
	}
	decoder.Skip(4)
	_portstatspropexperimenterintel.Rx1To64Packets = uint64(decoder.ReadUint64())
	_portstatspropexperimenterintel.Rx65To127Packets = uint64(decoder.ReadUint64())
	_portstatspropexperimenterintel.Rx128To255Packets = uint64(decoder.ReadUint64())
	_portstatspropexperimenterintel.Rx256To511Packets = uint64(decoder.ReadUint64())
	_portstatspropexperimenterintel.Rx512To1023Packets = uint64(decoder.ReadUint64())
	_portstatspropexperimenterintel.Rx1024To1522Packets = uint64(decoder.ReadUint64())
	_portstatspropexperimenterintel.Rx1523ToMaxPackets = uint64(decoder.ReadUint64())
	_portstatspropexperimenterintel.Tx1To64Packets = uint64(decoder.ReadUint64())
	_portstatspropexperimenterintel.Tx65To127Packets = uint64(decoder.ReadUint64())
	_portstatspropexperimenterintel.Tx128To255Packets = uint64(decoder.ReadUint64())
	_portstatspropexperimenterintel.Tx256To511Packets = uint64(decoder.ReadUint64())
	_portstatspropexperimenterintel.Tx512To1023Packets = uint64(decoder.ReadUint64())
	_portstatspropexperimenterintel.Tx1024To1522Packets = uint64(decoder.ReadUint64())
	_portstatspropexperimenterintel.Tx1523ToMaxPackets = uint64(decoder.ReadUint64())
	_portstatspropexperimenterintel.TxMulticastPackets = uint64(decoder.ReadUint64())
	_portstatspropexperimenterintel.RxBroadcastPackets = uint64(decoder.ReadUint64())
	_portstatspropexperimenterintel.TxBroadcastPackets = uint64(decoder.ReadUint64())
	_portstatspropexperimenterintel.RxUndersizedErrors = uint64(decoder.ReadUint64())
	_portstatspropexperimenterintel.RxOversizeErrors = uint64(decoder.ReadUint64())
	_portstatspropexperimenterintel.RxFragmentedErrors = uint64(decoder.ReadUint64())
	_portstatspropexperimenterintel.RxJabberErrors = uint64(decoder.ReadUint64())
	return _portstatspropexperimenterintel, nil
}

func NewPortStatsPropExperimenterIntel() *PortStatsPropExperimenterIntel {
	obj := &PortStatsPropExperimenterIntel{
		PortStatsPropExperimenter: NewPortStatsPropExperimenter(43521),
	}
	return obj
}

type PortStatsPropOptical struct {
	*PortStatsProp
	Flags       uint32
	TxFreqLmda  uint32
	TxOffset    uint32
	TxGridSpan  uint32
	RxFreqLmda  uint32
	RxOffset    uint32
	RxGridSpan  uint32
	TxPwr       uint16
	RxPwr       uint16
	BiasCurrent uint16
	Temperature uint16
}

type IPortStatsPropOptical interface {
	IPortStatsProp
	GetFlags() uint32
	GetTxFreqLmda() uint32
	GetTxOffset() uint32
	GetTxGridSpan() uint32
	GetRxFreqLmda() uint32
	GetRxOffset() uint32
	GetRxGridSpan() uint32
	GetTxPwr() uint16
	GetRxPwr() uint16
	GetBiasCurrent() uint16
	GetTemperature() uint16
}

func (self *PortStatsPropOptical) GetFlags() uint32 {
	return self.Flags
}

func (self *PortStatsPropOptical) SetFlags(v uint32) {
	self.Flags = v
}

func (self *PortStatsPropOptical) GetTxFreqLmda() uint32 {
	return self.TxFreqLmda
}

func (self *PortStatsPropOptical) SetTxFreqLmda(v uint32) {
	self.TxFreqLmda = v
}

func (self *PortStatsPropOptical) GetTxOffset() uint32 {
	return self.TxOffset
}

func (self *PortStatsPropOptical) SetTxOffset(v uint32) {
	self.TxOffset = v
}

func (self *PortStatsPropOptical) GetTxGridSpan() uint32 {
	return self.TxGridSpan
}

func (self *PortStatsPropOptical) SetTxGridSpan(v uint32) {
	self.TxGridSpan = v
}

func (self *PortStatsPropOptical) GetRxFreqLmda() uint32 {
	return self.RxFreqLmda
}

func (self *PortStatsPropOptical) SetRxFreqLmda(v uint32) {
	self.RxFreqLmda = v
}

func (self *PortStatsPropOptical) GetRxOffset() uint32 {
	return self.RxOffset
}

func (self *PortStatsPropOptical) SetRxOffset(v uint32) {
	self.RxOffset = v
}

func (self *PortStatsPropOptical) GetRxGridSpan() uint32 {
	return self.RxGridSpan
}

func (self *PortStatsPropOptical) SetRxGridSpan(v uint32) {
	self.RxGridSpan = v
}

func (self *PortStatsPropOptical) GetTxPwr() uint16 {
	return self.TxPwr
}

func (self *PortStatsPropOptical) SetTxPwr(v uint16) {
	self.TxPwr = v
}

func (self *PortStatsPropOptical) GetRxPwr() uint16 {
	return self.RxPwr
}

func (self *PortStatsPropOptical) SetRxPwr(v uint16) {
	self.RxPwr = v
}

func (self *PortStatsPropOptical) GetBiasCurrent() uint16 {
	return self.BiasCurrent
}

func (self *PortStatsPropOptical) SetBiasCurrent(v uint16) {
	self.BiasCurrent = v
}

func (self *PortStatsPropOptical) GetTemperature() uint16 {
	return self.Temperature
}

func (self *PortStatsPropOptical) SetTemperature(v uint16) {
	self.Temperature = v
}

func (self *PortStatsPropOptical) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.PortStatsProp.Serialize(encoder); err != nil {
		return err
	}

	encoder.Write(bytes.Repeat([]byte{0}, 4))
	encoder.PutUint32(uint32(self.Flags))
	encoder.PutUint32(uint32(self.TxFreqLmda))
	encoder.PutUint32(uint32(self.TxOffset))
	encoder.PutUint32(uint32(self.TxGridSpan))
	encoder.PutUint32(uint32(self.RxFreqLmda))
	encoder.PutUint32(uint32(self.RxOffset))
	encoder.PutUint32(uint32(self.RxGridSpan))
	encoder.PutUint16(uint16(self.TxPwr))
	encoder.PutUint16(uint16(self.RxPwr))
	encoder.PutUint16(uint16(self.BiasCurrent))
	encoder.PutUint16(uint16(self.Temperature))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodePortStatsPropOptical(parent *PortStatsProp, decoder *goloxi.Decoder) (*PortStatsPropOptical, error) {
	_portstatspropoptical := &PortStatsPropOptical{PortStatsProp: parent}
	if decoder.Length() < 40 {
		return nil, fmt.Errorf("PortStatsPropOptical packet too short: %d < 40", decoder.Length())
	}
	decoder.Skip(4)
	_portstatspropoptical.Flags = uint32(decoder.ReadUint32())
	_portstatspropoptical.TxFreqLmda = uint32(decoder.ReadUint32())
	_portstatspropoptical.TxOffset = uint32(decoder.ReadUint32())
	_portstatspropoptical.TxGridSpan = uint32(decoder.ReadUint32())
	_portstatspropoptical.RxFreqLmda = uint32(decoder.ReadUint32())
	_portstatspropoptical.RxOffset = uint32(decoder.ReadUint32())
	_portstatspropoptical.RxGridSpan = uint32(decoder.ReadUint32())
	_portstatspropoptical.TxPwr = uint16(decoder.ReadUint16())
	_portstatspropoptical.RxPwr = uint16(decoder.ReadUint16())
	_portstatspropoptical.BiasCurrent = uint16(decoder.ReadUint16())
	_portstatspropoptical.Temperature = uint16(decoder.ReadUint16())
	return _portstatspropoptical, nil
}

func NewPortStatsPropOptical() *PortStatsPropOptical {
	obj := &PortStatsPropOptical{
		PortStatsProp: NewPortStatsProp(1),
	}
	return obj
}

type QueueDesc struct {
	PortNo     uint32
	QueueId    uint32
	Length     uint16
	Properties []IQueueDescProp
}

type IQueueDesc interface {
	goloxi.Serializable
	GetPortNo() uint32
	GetQueueId() uint32
	GetLength() uint16
	GetProperties() []IQueueDescProp
}

func (self *QueueDesc) GetPortNo() uint32 {
	return self.PortNo
}

func (self *QueueDesc) SetPortNo(v uint32) {
	self.PortNo = v
}

func (self *QueueDesc) GetQueueId() uint32 {
	return self.QueueId
}

func (self *QueueDesc) SetQueueId(v uint32) {
	self.QueueId = v
}

func (self *QueueDesc) GetLength() uint16 {
	return self.Length
}

func (self *QueueDesc) SetLength(v uint16) {
	self.Length = v
}

func (self *QueueDesc) GetProperties() []IQueueDescProp {
	return self.Properties
}

func (self *QueueDesc) SetProperties(v []IQueueDescProp) {
	self.Properties = v
}

func (self *QueueDesc) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())

	encoder.PutUint32(uint32(self.PortNo))
	encoder.PutUint32(uint32(self.QueueId))
	encoder.PutUint16(uint16(self.Length))
	encoder.Write(bytes.Repeat([]byte{0}, 6))
	for _, obj := range self.Properties {
		if err := obj.Serialize(encoder); err != nil {
			return err
		}
	}
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+8:startIndex+10], uint16(length))

	return nil
}

func DecodeQueueDesc(decoder *goloxi.Decoder) (*QueueDesc, error) {
	_queuedesc := &QueueDesc{}
	if decoder.Length() < 16 {
		return nil, fmt.Errorf("QueueDesc packet too short: %d < 16", decoder.Length())
	}
	_queuedesc.PortNo = uint32(decoder.ReadUint32())
	_queuedesc.QueueId = uint32(decoder.ReadUint32())
	_queuedesc.Length = uint16(decoder.ReadUint16())
	oldDecoder := decoder
	defer func() { decoder = oldDecoder }()
	decoder = decoder.SliceDecoder(int(_queuedesc.Length), 2+8)
	decoder.Skip(6)

	for decoder.Length() >= 4 {
		item, err := DecodeQueueDescProp(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_queuedesc.Properties = append(_queuedesc.Properties, item)
		}
	}
	return _queuedesc, nil
}

func NewQueueDesc() *QueueDesc {
	obj := &QueueDesc{}
	return obj
}

type QueueDescProp struct {
	Type   uint16
	Length uint16
}

type IQueueDescProp interface {
	goloxi.Serializable
	GetType() uint16
	GetLength() uint16
}

func (self *QueueDescProp) GetType() uint16 {
	return self.Type
}

func (self *QueueDescProp) SetType(v uint16) {
	self.Type = v
}

func (self *QueueDescProp) GetLength() uint16 {
	return self.Length
}

func (self *QueueDescProp) SetLength(v uint16) {
	self.Length = v
}

func (self *QueueDescProp) Serialize(encoder *goloxi.Encoder) error {

	encoder.PutUint16(uint16(self.Type))
	encoder.PutUint16(uint16(self.Length))

	return nil
}

func DecodeQueueDescProp(decoder *goloxi.Decoder) (IQueueDescProp, error) {
	_queuedescprop := &QueueDescProp{}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("QueueDescProp packet too short: %d < 4", decoder.Length())
	}
	_queuedescprop.Type = uint16(decoder.ReadUint16())
	_queuedescprop.Length = uint16(decoder.ReadUint16())
	oldDecoder := decoder
	defer func() { decoder = oldDecoder }()
	decoder = decoder.SliceDecoder(int(_queuedescprop.Length), 2+2)

	switch _queuedescprop.Type {
	case 1:
		return DecodeQueueDescPropMinRate(_queuedescprop, decoder)
	case 2:
		return DecodeQueueDescPropMaxRate(_queuedescprop, decoder)
	case 65535:
		return DecodeQueueDescPropExperimenter(_queuedescprop, decoder)
	default:
		return nil, fmt.Errorf("Invalid type '%d' for 'QueueDescProp'", _queuedescprop.Type)
	}
}

func NewQueueDescProp(_type uint16) *QueueDescProp {
	obj := &QueueDescProp{}
	obj.Type = _type
	return obj
}

type QueueDescPropExperimenter struct {
	*QueueDescProp
	Experimenter uint32
	ExpType      uint32
}

type IQueueDescPropExperimenter interface {
	IQueueDescProp
	GetExperimenter() uint32
	GetExpType() uint32
}

func (self *QueueDescPropExperimenter) GetExperimenter() uint32 {
	return self.Experimenter
}

func (self *QueueDescPropExperimenter) SetExperimenter(v uint32) {
	self.Experimenter = v
}

func (self *QueueDescPropExperimenter) GetExpType() uint32 {
	return self.ExpType
}

func (self *QueueDescPropExperimenter) SetExpType(v uint32) {
	self.ExpType = v
}

func (self *QueueDescPropExperimenter) Serialize(encoder *goloxi.Encoder) error {
	if err := self.QueueDescProp.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint32(uint32(self.Experimenter))
	encoder.PutUint32(uint32(self.ExpType))

	return nil
}

func DecodeQueueDescPropExperimenter(parent *QueueDescProp, decoder *goloxi.Decoder) (IQueueDescPropExperimenter, error) {
	_queuedescpropexperimenter := &QueueDescPropExperimenter{QueueDescProp: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("QueueDescPropExperimenter packet too short: %d < 8", decoder.Length())
	}
	_queuedescpropexperimenter.Experimenter = uint32(decoder.ReadUint32())
	_queuedescpropexperimenter.ExpType = uint32(decoder.ReadUint32())

	switch _queuedescpropexperimenter.Experimenter {
	case 6035143:
		return DecodeQueueDescPropBsn(_queuedescpropexperimenter, decoder)
	default:
		return nil, fmt.Errorf("Invalid type '%d' for 'QueueDescPropExperimenter'", _queuedescpropexperimenter.Experimenter)
	}
}

func NewQueueDescPropExperimenter(_experimenter uint32) *QueueDescPropExperimenter {
	obj := &QueueDescPropExperimenter{
		QueueDescProp: NewQueueDescProp(65535),
	}
	obj.Experimenter = _experimenter
	return obj
}

type QueueDescPropBsn struct {
	*QueueDescPropExperimenter
}

type IQueueDescPropBsn interface {
	IQueueDescPropExperimenter
}

func (self *QueueDescPropBsn) Serialize(encoder *goloxi.Encoder) error {
	if err := self.QueueDescPropExperimenter.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeQueueDescPropBsn(parent *QueueDescPropExperimenter, decoder *goloxi.Decoder) (IQueueDescPropBsn, error) {
	_queuedescpropbsn := &QueueDescPropBsn{QueueDescPropExperimenter: parent}

	switch _queuedescpropbsn.ExpType {
	case 0:
		return DecodeQueueDescPropBsnQueueName(_queuedescpropbsn, decoder)
	default:
		return nil, fmt.Errorf("Invalid type '%d' for 'QueueDescPropBsn'", _queuedescpropbsn.ExpType)
	}
}

func NewQueueDescPropBsn(_exp_type uint32) *QueueDescPropBsn {
	obj := &QueueDescPropBsn{
		QueueDescPropExperimenter: NewQueueDescPropExperimenter(6035143),
	}
	obj.ExpType = _exp_type
	return obj
}

type QueueDescPropBsnQueueName struct {
	*QueueDescPropBsn
	Name []byte
}

type IQueueDescPropBsnQueueName interface {
	IQueueDescPropBsn
	GetName() []byte
}

func (self *QueueDescPropBsnQueueName) GetName() []byte {
	return self.Name
}

func (self *QueueDescPropBsnQueueName) SetName(v []byte) {
	self.Name = v
}

func (self *QueueDescPropBsnQueueName) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.QueueDescPropBsn.Serialize(encoder); err != nil {
		return err
	}

	encoder.Write(self.Name)
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeQueueDescPropBsnQueueName(parent *QueueDescPropBsn, decoder *goloxi.Decoder) (*QueueDescPropBsnQueueName, error) {
	_queuedescpropbsnqueuename := &QueueDescPropBsnQueueName{QueueDescPropBsn: parent}
	_queuedescpropbsnqueuename.Name = decoder.Read(int(decoder.Length()))
	return _queuedescpropbsnqueuename, nil
}

func NewQueueDescPropBsnQueueName() *QueueDescPropBsnQueueName {
	obj := &QueueDescPropBsnQueueName{
		QueueDescPropBsn: NewQueueDescPropBsn(0),
	}
	return obj
}

type QueueDescPropMaxRate struct {
	*QueueDescProp
	Rate uint16
}

type IQueueDescPropMaxRate interface {
	IQueueDescProp
	GetRate() uint16
}

func (self *QueueDescPropMaxRate) GetRate() uint16 {
	return self.Rate
}

func (self *QueueDescPropMaxRate) SetRate(v uint16) {
	self.Rate = v
}

func (self *QueueDescPropMaxRate) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.QueueDescProp.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint16(uint16(self.Rate))
	encoder.Write(bytes.Repeat([]byte{0}, 2))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeQueueDescPropMaxRate(parent *QueueDescProp, decoder *goloxi.Decoder) (*QueueDescPropMaxRate, error) {
	_queuedescpropmaxrate := &QueueDescPropMaxRate{QueueDescProp: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("QueueDescPropMaxRate packet too short: %d < 4", decoder.Length())
	}
	_queuedescpropmaxrate.Rate = uint16(decoder.ReadUint16())
	decoder.Skip(2)
	return _queuedescpropmaxrate, nil
}

func NewQueueDescPropMaxRate() *QueueDescPropMaxRate {
	obj := &QueueDescPropMaxRate{
		QueueDescProp: NewQueueDescProp(2),
	}
	return obj
}

type QueueDescPropMinRate struct {
	*QueueDescProp
	Rate uint16
}

type IQueueDescPropMinRate interface {
	IQueueDescProp
	GetRate() uint16
}

func (self *QueueDescPropMinRate) GetRate() uint16 {
	return self.Rate
}

func (self *QueueDescPropMinRate) SetRate(v uint16) {
	self.Rate = v
}

func (self *QueueDescPropMinRate) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.QueueDescProp.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint16(uint16(self.Rate))
	encoder.Write(bytes.Repeat([]byte{0}, 2))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeQueueDescPropMinRate(parent *QueueDescProp, decoder *goloxi.Decoder) (*QueueDescPropMinRate, error) {
	_queuedescpropminrate := &QueueDescPropMinRate{QueueDescProp: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("QueueDescPropMinRate packet too short: %d < 4", decoder.Length())
	}
	_queuedescpropminrate.Rate = uint16(decoder.ReadUint16())
	decoder.Skip(2)
	return _queuedescpropminrate, nil
}

func NewQueueDescPropMinRate() *QueueDescPropMinRate {
	obj := &QueueDescPropMinRate{
		QueueDescProp: NewQueueDescProp(1),
	}
	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)
	case 2:
		return DecodeQueuePropMaxRate(_queueprop, decoder)
	case 65535:
		return DecodeQueuePropExperimenter(_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 QueuePropExperimenter struct {
	*QueueProp
	Experimenter uint32
}

type IQueuePropExperimenter interface {
	IQueueProp
	GetExperimenter() uint32
}

func (self *QueuePropExperimenter) GetExperimenter() uint32 {
	return self.Experimenter
}

func (self *QueuePropExperimenter) SetExperimenter(v uint32) {
	self.Experimenter = v
}

func (self *QueuePropExperimenter) Serialize(encoder *goloxi.Encoder) error {
	if err := self.QueueProp.Serialize(encoder); err != nil {
		return err
	}

	encoder.Write(bytes.Repeat([]byte{0}, 4))
	encoder.PutUint32(uint32(self.Experimenter))
	encoder.Write(bytes.Repeat([]byte{0}, 4))

	return nil
}

func DecodeQueuePropExperimenter(parent *QueueProp, decoder *goloxi.Decoder) (IQueuePropExperimenter, error) {
	_queuepropexperimenter := &QueuePropExperimenter{QueueProp: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("QueuePropExperimenter packet too short: %d < 4", decoder.Length())
	}
	decoder.Skip(4)
	_queuepropexperimenter.Experimenter = uint32(decoder.ReadUint32())
	decoder.Skip(4)
	return _queuepropexperimenter, nil
}

func NewQueuePropExperimenter(_experimenter uint32) *QueuePropExperimenter {
	obj := &QueuePropExperimenter{
		QueueProp: NewQueueProp(65535),
	}
	obj.Experimenter = _experimenter
	return obj
}

type QueuePropMaxRate struct {
	*QueueProp
	Rate uint16
}

type IQueuePropMaxRate interface {
	IQueueProp
	GetRate() uint16
}

func (self *QueuePropMaxRate) GetRate() uint16 {
	return self.Rate
}

func (self *QueuePropMaxRate) SetRate(v uint16) {
	self.Rate = v
}

func (self *QueuePropMaxRate) 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 DecodeQueuePropMaxRate(parent *QueueProp, decoder *goloxi.Decoder) (*QueuePropMaxRate, error) {
	_queuepropmaxrate := &QueuePropMaxRate{QueueProp: parent}
	if decoder.Length() < 12 {
		return nil, fmt.Errorf("QueuePropMaxRate packet too short: %d < 12", decoder.Length())
	}
	decoder.Skip(4)
	_queuepropmaxrate.Rate = uint16(decoder.ReadUint16())
	decoder.Skip(6)
	return _queuepropmaxrate, nil
}

func NewQueuePropMaxRate() *QueuePropMaxRate {
	obj := &QueuePropMaxRate{
		QueueProp: NewQueueProp(2),
	}
	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 {
	Length       uint16
	PortNo       Port
	QueueId      uint32
	TxBytes      uint64
	TxPackets    uint64
	TxErrors     uint64
	DurationSec  uint32
	DurationNsec uint32
	Properties   []IQueueStatsProp
}

type IQueueStatsEntry interface {
	goloxi.Serializable
	GetLength() uint16
	GetPortNo() Port
	GetQueueId() uint32
	GetTxBytes() uint64
	GetTxPackets() uint64
	GetTxErrors() uint64
	GetDurationSec() uint32
	GetDurationNsec() uint32
	GetProperties() []IQueueStatsProp
}

func (self *QueueStatsEntry) GetLength() uint16 {
	return self.Length
}

func (self *QueueStatsEntry) SetLength(v uint16) {
	self.Length = v
}

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) GetDurationSec() uint32 {
	return self.DurationSec
}

func (self *QueueStatsEntry) SetDurationSec(v uint32) {
	self.DurationSec = v
}

func (self *QueueStatsEntry) GetDurationNsec() uint32 {
	return self.DurationNsec
}

func (self *QueueStatsEntry) SetDurationNsec(v uint32) {
	self.DurationNsec = v
}

func (self *QueueStatsEntry) GetProperties() []IQueueStatsProp {
	return self.Properties
}

func (self *QueueStatsEntry) SetProperties(v []IQueueStatsProp) {
	self.Properties = v
}

func (self *QueueStatsEntry) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())

	encoder.PutUint16(uint16(self.Length))
	encoder.Write(bytes.Repeat([]byte{0}, 6))
	self.PortNo.Serialize(encoder)
	encoder.PutUint32(uint32(self.QueueId))
	encoder.PutUint64(uint64(self.TxBytes))
	encoder.PutUint64(uint64(self.TxPackets))
	encoder.PutUint64(uint64(self.TxErrors))
	encoder.PutUint32(uint32(self.DurationSec))
	encoder.PutUint32(uint32(self.DurationNsec))
	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+0:startIndex+2], uint16(length))

	return nil
}

func DecodeQueueStatsEntry(decoder *goloxi.Decoder) (*QueueStatsEntry, error) {
	_queuestatsentry := &QueueStatsEntry{}
	if decoder.Length() < 48 {
		return nil, fmt.Errorf("QueueStatsEntry packet too short: %d < 48", decoder.Length())
	}
	_queuestatsentry.Length = uint16(decoder.ReadUint16())
	oldDecoder := decoder
	defer func() { decoder = oldDecoder }()
	decoder = decoder.SliceDecoder(int(_queuestatsentry.Length), 2+0)
	decoder.Skip(6)
	_queuestatsentry.PortNo.Decode(decoder)
	_queuestatsentry.QueueId = uint32(decoder.ReadUint32())
	_queuestatsentry.TxBytes = uint64(decoder.ReadUint64())
	_queuestatsentry.TxPackets = uint64(decoder.ReadUint64())
	_queuestatsentry.TxErrors = uint64(decoder.ReadUint64())
	_queuestatsentry.DurationSec = uint32(decoder.ReadUint32())
	_queuestatsentry.DurationNsec = uint32(decoder.ReadUint32())

	for decoder.Length() >= 4 {
		item, err := DecodeQueueStatsProp(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_queuestatsentry.Properties = append(_queuestatsentry.Properties, item)
		}
	}
	return _queuestatsentry, nil
}

func NewQueueStatsEntry() *QueueStatsEntry {
	obj := &QueueStatsEntry{}
	return obj
}

type QueueStatsProp struct {
	Type   uint16
	Length uint16
}

type IQueueStatsProp interface {
	goloxi.Serializable
	GetType() uint16
	GetLength() uint16
}

func (self *QueueStatsProp) GetType() uint16 {
	return self.Type
}

func (self *QueueStatsProp) SetType(v uint16) {
	self.Type = v
}

func (self *QueueStatsProp) GetLength() uint16 {
	return self.Length
}

func (self *QueueStatsProp) SetLength(v uint16) {
	self.Length = v
}

func (self *QueueStatsProp) Serialize(encoder *goloxi.Encoder) error {

	encoder.PutUint16(uint16(self.Type))
	encoder.PutUint16(uint16(self.Length))

	return nil
}

func DecodeQueueStatsProp(decoder *goloxi.Decoder) (IQueueStatsProp, error) {
	_queuestatsprop := &QueueStatsProp{}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("QueueStatsProp packet too short: %d < 4", decoder.Length())
	}
	_queuestatsprop.Type = uint16(decoder.ReadUint16())
	_queuestatsprop.Length = uint16(decoder.ReadUint16())
	oldDecoder := decoder
	defer func() { decoder = oldDecoder }()
	decoder = decoder.SliceDecoder(int(_queuestatsprop.Length), 2+2)

	switch _queuestatsprop.Type {
	case 65535:
		return DecodeQueueStatsPropExperimenter(_queuestatsprop, decoder)
	default:
		return nil, fmt.Errorf("Invalid type '%d' for 'QueueStatsProp'", _queuestatsprop.Type)
	}
}

func NewQueueStatsProp(_type uint16) *QueueStatsProp {
	obj := &QueueStatsProp{}
	obj.Type = _type
	return obj
}

type QueueStatsPropExperimenter struct {
	*QueueStatsProp
	Experimenter uint32
	ExpType      uint32
}

type IQueueStatsPropExperimenter interface {
	IQueueStatsProp
	GetExperimenter() uint32
	GetExpType() uint32
}

func (self *QueueStatsPropExperimenter) GetExperimenter() uint32 {
	return self.Experimenter
}

func (self *QueueStatsPropExperimenter) SetExperimenter(v uint32) {
	self.Experimenter = v
}

func (self *QueueStatsPropExperimenter) GetExpType() uint32 {
	return self.ExpType
}

func (self *QueueStatsPropExperimenter) SetExpType(v uint32) {
	self.ExpType = v
}

func (self *QueueStatsPropExperimenter) Serialize(encoder *goloxi.Encoder) error {
	if err := self.QueueStatsProp.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint32(uint32(self.Experimenter))
	encoder.PutUint32(uint32(self.ExpType))

	return nil
}

func DecodeQueueStatsPropExperimenter(parent *QueueStatsProp, decoder *goloxi.Decoder) (IQueueStatsPropExperimenter, error) {
	_queuestatspropexperimenter := &QueueStatsPropExperimenter{QueueStatsProp: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("QueueStatsPropExperimenter packet too short: %d < 8", decoder.Length())
	}
	_queuestatspropexperimenter.Experimenter = uint32(decoder.ReadUint32())
	_queuestatspropexperimenter.ExpType = uint32(decoder.ReadUint32())
	return _queuestatspropexperimenter, nil
}

func NewQueueStatsPropExperimenter(_experimenter uint32) *QueueStatsPropExperimenter {
	obj := &QueueStatsPropExperimenter{
		QueueStatsProp: NewQueueStatsProp(65535),
	}
	obj.Experimenter = _experimenter
	return obj
}

type RoleProp struct {
	Type   uint16
	Length uint16
}

type IRoleProp interface {
	goloxi.Serializable
	GetType() uint16
	GetLength() uint16
}

func (self *RoleProp) GetType() uint16 {
	return self.Type
}

func (self *RoleProp) SetType(v uint16) {
	self.Type = v
}

func (self *RoleProp) GetLength() uint16 {
	return self.Length
}

func (self *RoleProp) SetLength(v uint16) {
	self.Length = v
}

func (self *RoleProp) Serialize(encoder *goloxi.Encoder) error {

	encoder.PutUint16(uint16(self.Type))
	encoder.PutUint16(uint16(self.Length))

	return nil
}

func DecodeRoleProp(decoder *goloxi.Decoder) (IRoleProp, error) {
	_roleprop := &RoleProp{}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("RoleProp packet too short: %d < 4", decoder.Length())
	}
	_roleprop.Type = uint16(decoder.ReadUint16())
	_roleprop.Length = uint16(decoder.ReadUint16())
	oldDecoder := decoder
	defer func() { decoder = oldDecoder }()
	decoder = decoder.SliceDecoder(int(_roleprop.Length), 2+2)

	switch _roleprop.Type {
	case 65535:
		return DecodeRolePropExperimenter(_roleprop, decoder)
	default:
		return nil, fmt.Errorf("Invalid type '%d' for 'RoleProp'", _roleprop.Type)
	}
}

func NewRoleProp(_type uint16) *RoleProp {
	obj := &RoleProp{}
	obj.Type = _type
	return obj
}

type RolePropExperimenter struct {
	*RoleProp
	Experimenter uint32
	ExpType      uint32
}

type IRolePropExperimenter interface {
	IRoleProp
	GetExperimenter() uint32
	GetExpType() uint32
}

func (self *RolePropExperimenter) GetExperimenter() uint32 {
	return self.Experimenter
}

func (self *RolePropExperimenter) SetExperimenter(v uint32) {
	self.Experimenter = v
}

func (self *RolePropExperimenter) GetExpType() uint32 {
	return self.ExpType
}

func (self *RolePropExperimenter) SetExpType(v uint32) {
	self.ExpType = v
}

func (self *RolePropExperimenter) Serialize(encoder *goloxi.Encoder) error {
	if err := self.RoleProp.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint32(uint32(self.Experimenter))
	encoder.PutUint32(uint32(self.ExpType))

	return nil
}

func DecodeRolePropExperimenter(parent *RoleProp, decoder *goloxi.Decoder) (IRolePropExperimenter, error) {
	_rolepropexperimenter := &RolePropExperimenter{RoleProp: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("RolePropExperimenter packet too short: %d < 8", decoder.Length())
	}
	_rolepropexperimenter.Experimenter = uint32(decoder.ReadUint32())
	_rolepropexperimenter.ExpType = uint32(decoder.ReadUint32())
	return _rolepropexperimenter, nil
}

func NewRolePropExperimenter(_experimenter uint32) *RolePropExperimenter {
	obj := &RolePropExperimenter{
		RoleProp: NewRoleProp(65535),
	}
	obj.Experimenter = _experimenter
	return obj
}

type TableDesc struct {
	Length  uint16
	TableId uint8
	Config  TableConfig
}

type ITableDesc interface {
	goloxi.Serializable
	GetLength() uint16
	GetTableId() uint8
	GetConfig() TableConfig
}

func (self *TableDesc) GetLength() uint16 {
	return self.Length
}

func (self *TableDesc) SetLength(v uint16) {
	self.Length = v
}

func (self *TableDesc) GetTableId() uint8 {
	return self.TableId
}

func (self *TableDesc) SetTableId(v uint8) {
	self.TableId = v
}

func (self *TableDesc) GetConfig() TableConfig {
	return self.Config
}

func (self *TableDesc) SetConfig(v TableConfig) {
	self.Config = v
}

func (self *TableDesc) 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.Config))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))

	return nil
}
func (self *TableDesc) Decode(decoder *goloxi.Decoder) error {
	if decoder.Length() < 8 {
		return fmt.Errorf("TableDesc packet too short: %d < 8", decoder.Length())
	}

	self.Length = uint16(decoder.ReadUint16())
	oldDecoder := decoder
	defer func() { decoder = oldDecoder }()
	decoder = decoder.SliceDecoder(int(self.Length), 2+0)
	self.TableId = uint8(decoder.ReadByte())
	decoder.Skip(1)
	self.Config = TableConfig(decoder.ReadUint32())

	return nil
}

func NewTableDesc() *TableDesc {
	obj := &TableDesc{}
	return obj
}

type TableFeatureProp struct {
	Type   uint16
	Length uint16
}

type ITableFeatureProp interface {
	goloxi.Serializable
	GetType() uint16
	GetLength() uint16
}

func (self *TableFeatureProp) GetType() uint16 {
	return self.Type
}

func (self *TableFeatureProp) SetType(v uint16) {
	self.Type = v
}

func (self *TableFeatureProp) GetLength() uint16 {
	return self.Length
}

func (self *TableFeatureProp) SetLength(v uint16) {
	self.Length = v
}

func (self *TableFeatureProp) Serialize(encoder *goloxi.Encoder) error {

	encoder.PutUint16(uint16(self.Type))
	encoder.PutUint16(uint16(self.Length))

	return nil
}

func DecodeTableFeatureProp(decoder *goloxi.Decoder) (ITableFeatureProp, error) {
	_tablefeatureprop := &TableFeatureProp{}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("TableFeatureProp packet too short: %d < 4", decoder.Length())
	}
	_tablefeatureprop.Type = uint16(decoder.ReadUint16())
	_tablefeatureprop.Length = uint16(decoder.ReadUint16())
	oldDecoder := decoder
	defer func() { decoder = oldDecoder }()
	decoder = decoder.SliceDecoder(int(_tablefeatureprop.Length), 2+2)

	switch _tablefeatureprop.Type {
	case 0:
		return DecodeTableFeaturePropInstructions(_tablefeatureprop, decoder)
	case 1:
		return DecodeTableFeaturePropInstructionsMiss(_tablefeatureprop, decoder)
	case 2:
		return DecodeTableFeaturePropNextTables(_tablefeatureprop, decoder)
	case 3:
		return DecodeTableFeaturePropNextTablesMiss(_tablefeatureprop, decoder)
	case 4:
		return DecodeTableFeaturePropWriteActions(_tablefeatureprop, decoder)
	case 5:
		return DecodeTableFeaturePropWriteActionsMiss(_tablefeatureprop, decoder)
	case 6:
		return DecodeTableFeaturePropApplyActions(_tablefeatureprop, decoder)
	case 7:
		return DecodeTableFeaturePropApplyActionsMiss(_tablefeatureprop, decoder)
	case 8:
		return DecodeTableFeaturePropMatch(_tablefeatureprop, decoder)
	case 10:
		return DecodeTableFeaturePropWildcards(_tablefeatureprop, decoder)
	case 12:
		return DecodeTableFeaturePropWriteSetfield(_tablefeatureprop, decoder)
	case 13:
		return DecodeTableFeaturePropWriteSetfieldMiss(_tablefeatureprop, decoder)
	case 14:
		return DecodeTableFeaturePropApplySetfield(_tablefeatureprop, decoder)
	case 15:
		return DecodeTableFeaturePropApplySetfieldMiss(_tablefeatureprop, decoder)
	case 16:
		return DecodeTableFeaturePropTableSyncFrom(_tablefeatureprop, decoder)
	case 65534:
		return DecodeTableFeaturePropExperimenter(_tablefeatureprop, decoder)
	case 65535:
		return DecodeTableFeaturePropExperimenterMiss(_tablefeatureprop, decoder)
	default:
		return nil, fmt.Errorf("Invalid type '%d' for 'TableFeatureProp'", _tablefeatureprop.Type)
	}
}

func NewTableFeatureProp(_type uint16) *TableFeatureProp {
	obj := &TableFeatureProp{}
	obj.Type = _type
	return obj
}

type TableFeaturePropApplyActions struct {
	*TableFeatureProp
	ActionIds []IActionId
}

type ITableFeaturePropApplyActions interface {
	ITableFeatureProp
	GetActionIds() []IActionId
}

func (self *TableFeaturePropApplyActions) GetActionIds() []IActionId {
	return self.ActionIds
}

func (self *TableFeaturePropApplyActions) SetActionIds(v []IActionId) {
	self.ActionIds = v
}

func (self *TableFeaturePropApplyActions) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.TableFeatureProp.Serialize(encoder); err != nil {
		return err
	}

	for _, obj := range self.ActionIds {
		if err := obj.Serialize(encoder); err != nil {
			return err
		}
	}
	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 DecodeTableFeaturePropApplyActions(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropApplyActions, error) {
	_tablefeaturepropapplyactions := &TableFeaturePropApplyActions{TableFeatureProp: parent}
	defer decoder.SkipAlign()

	for decoder.Length() >= 4 {
		item, err := DecodeActionId(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_tablefeaturepropapplyactions.ActionIds = append(_tablefeaturepropapplyactions.ActionIds, item)
		}
	}
	return _tablefeaturepropapplyactions, nil
}

func NewTableFeaturePropApplyActions() *TableFeaturePropApplyActions {
	obj := &TableFeaturePropApplyActions{
		TableFeatureProp: NewTableFeatureProp(6),
	}
	return obj
}

type TableFeaturePropApplyActionsMiss struct {
	*TableFeatureProp
	ActionIds []IActionId
}

type ITableFeaturePropApplyActionsMiss interface {
	ITableFeatureProp
	GetActionIds() []IActionId
}

func (self *TableFeaturePropApplyActionsMiss) GetActionIds() []IActionId {
	return self.ActionIds
}

func (self *TableFeaturePropApplyActionsMiss) SetActionIds(v []IActionId) {
	self.ActionIds = v
}

func (self *TableFeaturePropApplyActionsMiss) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.TableFeatureProp.Serialize(encoder); err != nil {
		return err
	}

	for _, obj := range self.ActionIds {
		if err := obj.Serialize(encoder); err != nil {
			return err
		}
	}
	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 DecodeTableFeaturePropApplyActionsMiss(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropApplyActionsMiss, error) {
	_tablefeaturepropapplyactionsmiss := &TableFeaturePropApplyActionsMiss{TableFeatureProp: parent}
	defer decoder.SkipAlign()

	for decoder.Length() >= 4 {
		item, err := DecodeActionId(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_tablefeaturepropapplyactionsmiss.ActionIds = append(_tablefeaturepropapplyactionsmiss.ActionIds, item)
		}
	}
	return _tablefeaturepropapplyactionsmiss, nil
}

func NewTableFeaturePropApplyActionsMiss() *TableFeaturePropApplyActionsMiss {
	obj := &TableFeaturePropApplyActionsMiss{
		TableFeatureProp: NewTableFeatureProp(7),
	}
	return obj
}

type TableFeaturePropApplySetfield struct {
	*TableFeatureProp
	OxmIds []*Uint32
}

type ITableFeaturePropApplySetfield interface {
	ITableFeatureProp
	GetOxmIds() []*Uint32
}

func (self *TableFeaturePropApplySetfield) GetOxmIds() []*Uint32 {
	return self.OxmIds
}

func (self *TableFeaturePropApplySetfield) SetOxmIds(v []*Uint32) {
	self.OxmIds = v
}

func (self *TableFeaturePropApplySetfield) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.TableFeatureProp.Serialize(encoder); err != nil {
		return err
	}

	for _, obj := range self.OxmIds {
		if err := obj.Serialize(encoder); err != nil {
			return err
		}
	}
	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 DecodeTableFeaturePropApplySetfield(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropApplySetfield, error) {
	_tablefeaturepropapplysetfield := &TableFeaturePropApplySetfield{TableFeatureProp: parent}
	defer decoder.SkipAlign()

	for decoder.Length() >= 4 {
		item, err := DecodeUint32(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_tablefeaturepropapplysetfield.OxmIds = append(_tablefeaturepropapplysetfield.OxmIds, item)
		}
	}
	return _tablefeaturepropapplysetfield, nil
}

func NewTableFeaturePropApplySetfield() *TableFeaturePropApplySetfield {
	obj := &TableFeaturePropApplySetfield{
		TableFeatureProp: NewTableFeatureProp(14),
	}
	return obj
}

type TableFeaturePropApplySetfieldMiss struct {
	*TableFeatureProp
	OxmIds []*Uint32
}

type ITableFeaturePropApplySetfieldMiss interface {
	ITableFeatureProp
	GetOxmIds() []*Uint32
}

func (self *TableFeaturePropApplySetfieldMiss) GetOxmIds() []*Uint32 {
	return self.OxmIds
}

func (self *TableFeaturePropApplySetfieldMiss) SetOxmIds(v []*Uint32) {
	self.OxmIds = v
}

func (self *TableFeaturePropApplySetfieldMiss) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.TableFeatureProp.Serialize(encoder); err != nil {
		return err
	}

	for _, obj := range self.OxmIds {
		if err := obj.Serialize(encoder); err != nil {
			return err
		}
	}
	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 DecodeTableFeaturePropApplySetfieldMiss(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropApplySetfieldMiss, error) {
	_tablefeaturepropapplysetfieldmiss := &TableFeaturePropApplySetfieldMiss{TableFeatureProp: parent}
	defer decoder.SkipAlign()

	for decoder.Length() >= 4 {
		item, err := DecodeUint32(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_tablefeaturepropapplysetfieldmiss.OxmIds = append(_tablefeaturepropapplysetfieldmiss.OxmIds, item)
		}
	}
	return _tablefeaturepropapplysetfieldmiss, nil
}

func NewTableFeaturePropApplySetfieldMiss() *TableFeaturePropApplySetfieldMiss {
	obj := &TableFeaturePropApplySetfieldMiss{
		TableFeatureProp: NewTableFeatureProp(15),
	}
	return obj
}

type TableFeaturePropExperimenter struct {
	*TableFeatureProp
	Experimenter uint32
	Subtype      uint32
}

type ITableFeaturePropExperimenter interface {
	ITableFeatureProp
	GetExperimenter() uint32
	GetSubtype() uint32
}

func (self *TableFeaturePropExperimenter) GetExperimenter() uint32 {
	return self.Experimenter
}

func (self *TableFeaturePropExperimenter) SetExperimenter(v uint32) {
	self.Experimenter = v
}

func (self *TableFeaturePropExperimenter) GetSubtype() uint32 {
	return self.Subtype
}

func (self *TableFeaturePropExperimenter) SetSubtype(v uint32) {
	self.Subtype = v
}

func (self *TableFeaturePropExperimenter) Serialize(encoder *goloxi.Encoder) error {
	if err := self.TableFeatureProp.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint32(uint32(self.Experimenter))
	encoder.PutUint32(uint32(self.Subtype))

	return nil
}

func DecodeTableFeaturePropExperimenter(parent *TableFeatureProp, decoder *goloxi.Decoder) (ITableFeaturePropExperimenter, error) {
	_tablefeaturepropexperimenter := &TableFeaturePropExperimenter{TableFeatureProp: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("TableFeaturePropExperimenter packet too short: %d < 8", decoder.Length())
	}
	defer decoder.SkipAlign()

	_tablefeaturepropexperimenter.Experimenter = uint32(decoder.ReadUint32())
	_tablefeaturepropexperimenter.Subtype = uint32(decoder.ReadUint32())
	return _tablefeaturepropexperimenter, nil
}

func NewTableFeaturePropExperimenter(_experimenter uint32) *TableFeaturePropExperimenter {
	obj := &TableFeaturePropExperimenter{
		TableFeatureProp: NewTableFeatureProp(65534),
	}
	obj.Experimenter = _experimenter
	return obj
}

type TableFeaturePropExperimenterMiss struct {
	*TableFeatureProp
	Experimenter uint32
	Subtype      uint32
}

type ITableFeaturePropExperimenterMiss interface {
	ITableFeatureProp
	GetExperimenter() uint32
	GetSubtype() uint32
}

func (self *TableFeaturePropExperimenterMiss) GetExperimenter() uint32 {
	return self.Experimenter
}

func (self *TableFeaturePropExperimenterMiss) SetExperimenter(v uint32) {
	self.Experimenter = v
}

func (self *TableFeaturePropExperimenterMiss) GetSubtype() uint32 {
	return self.Subtype
}

func (self *TableFeaturePropExperimenterMiss) SetSubtype(v uint32) {
	self.Subtype = v
}

func (self *TableFeaturePropExperimenterMiss) Serialize(encoder *goloxi.Encoder) error {
	if err := self.TableFeatureProp.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint32(uint32(self.Experimenter))
	encoder.PutUint32(uint32(self.Subtype))

	return nil
}

func DecodeTableFeaturePropExperimenterMiss(parent *TableFeatureProp, decoder *goloxi.Decoder) (ITableFeaturePropExperimenterMiss, error) {
	_tablefeaturepropexperimentermiss := &TableFeaturePropExperimenterMiss{TableFeatureProp: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("TableFeaturePropExperimenterMiss packet too short: %d < 8", decoder.Length())
	}
	defer decoder.SkipAlign()

	_tablefeaturepropexperimentermiss.Experimenter = uint32(decoder.ReadUint32())
	_tablefeaturepropexperimentermiss.Subtype = uint32(decoder.ReadUint32())
	return _tablefeaturepropexperimentermiss, nil
}

func NewTableFeaturePropExperimenterMiss(_experimenter uint32) *TableFeaturePropExperimenterMiss {
	obj := &TableFeaturePropExperimenterMiss{
		TableFeatureProp: NewTableFeatureProp(65535),
	}
	obj.Experimenter = _experimenter
	return obj
}

type TableFeaturePropInstructions struct {
	*TableFeatureProp
	InstructionIds []IInstructionId
}

type ITableFeaturePropInstructions interface {
	ITableFeatureProp
	GetInstructionIds() []IInstructionId
}

func (self *TableFeaturePropInstructions) GetInstructionIds() []IInstructionId {
	return self.InstructionIds
}

func (self *TableFeaturePropInstructions) SetInstructionIds(v []IInstructionId) {
	self.InstructionIds = v
}

func (self *TableFeaturePropInstructions) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.TableFeatureProp.Serialize(encoder); err != nil {
		return err
	}

	for _, obj := range self.InstructionIds {
		if err := obj.Serialize(encoder); err != nil {
			return err
		}
	}
	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 DecodeTableFeaturePropInstructions(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropInstructions, error) {
	_tablefeaturepropinstructions := &TableFeaturePropInstructions{TableFeatureProp: parent}
	defer decoder.SkipAlign()

	for decoder.Length() >= 4 {
		item, err := DecodeInstructionId(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_tablefeaturepropinstructions.InstructionIds = append(_tablefeaturepropinstructions.InstructionIds, item)
		}
	}
	return _tablefeaturepropinstructions, nil
}

func NewTableFeaturePropInstructions() *TableFeaturePropInstructions {
	obj := &TableFeaturePropInstructions{
		TableFeatureProp: NewTableFeatureProp(0),
	}
	return obj
}

type TableFeaturePropInstructionsMiss struct {
	*TableFeatureProp
	InstructionIds []IInstructionId
}

type ITableFeaturePropInstructionsMiss interface {
	ITableFeatureProp
	GetInstructionIds() []IInstructionId
}

func (self *TableFeaturePropInstructionsMiss) GetInstructionIds() []IInstructionId {
	return self.InstructionIds
}

func (self *TableFeaturePropInstructionsMiss) SetInstructionIds(v []IInstructionId) {
	self.InstructionIds = v
}

func (self *TableFeaturePropInstructionsMiss) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.TableFeatureProp.Serialize(encoder); err != nil {
		return err
	}

	for _, obj := range self.InstructionIds {
		if err := obj.Serialize(encoder); err != nil {
			return err
		}
	}
	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 DecodeTableFeaturePropInstructionsMiss(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropInstructionsMiss, error) {
	_tablefeaturepropinstructionsmiss := &TableFeaturePropInstructionsMiss{TableFeatureProp: parent}
	defer decoder.SkipAlign()

	for decoder.Length() >= 4 {
		item, err := DecodeInstructionId(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_tablefeaturepropinstructionsmiss.InstructionIds = append(_tablefeaturepropinstructionsmiss.InstructionIds, item)
		}
	}
	return _tablefeaturepropinstructionsmiss, nil
}

func NewTableFeaturePropInstructionsMiss() *TableFeaturePropInstructionsMiss {
	obj := &TableFeaturePropInstructionsMiss{
		TableFeatureProp: NewTableFeatureProp(1),
	}
	return obj
}

type TableFeaturePropMatch struct {
	*TableFeatureProp
	OxmIds []*Uint32
}

type ITableFeaturePropMatch interface {
	ITableFeatureProp
	GetOxmIds() []*Uint32
}

func (self *TableFeaturePropMatch) GetOxmIds() []*Uint32 {
	return self.OxmIds
}

func (self *TableFeaturePropMatch) SetOxmIds(v []*Uint32) {
	self.OxmIds = v
}

func (self *TableFeaturePropMatch) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.TableFeatureProp.Serialize(encoder); err != nil {
		return err
	}

	for _, obj := range self.OxmIds {
		if err := obj.Serialize(encoder); err != nil {
			return err
		}
	}
	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 DecodeTableFeaturePropMatch(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropMatch, error) {
	_tablefeaturepropmatch := &TableFeaturePropMatch{TableFeatureProp: parent}
	defer decoder.SkipAlign()

	for decoder.Length() >= 4 {
		item, err := DecodeUint32(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_tablefeaturepropmatch.OxmIds = append(_tablefeaturepropmatch.OxmIds, item)
		}
	}
	return _tablefeaturepropmatch, nil
}

func NewTableFeaturePropMatch() *TableFeaturePropMatch {
	obj := &TableFeaturePropMatch{
		TableFeatureProp: NewTableFeatureProp(8),
	}
	return obj
}

type TableFeaturePropNextTables struct {
	*TableFeatureProp
	NextTableIds []*Uint8
}

type ITableFeaturePropNextTables interface {
	ITableFeatureProp
	GetNextTableIds() []*Uint8
}

func (self *TableFeaturePropNextTables) GetNextTableIds() []*Uint8 {
	return self.NextTableIds
}

func (self *TableFeaturePropNextTables) SetNextTableIds(v []*Uint8) {
	self.NextTableIds = v
}

func (self *TableFeaturePropNextTables) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.TableFeatureProp.Serialize(encoder); err != nil {
		return err
	}

	for _, obj := range self.NextTableIds {
		if err := obj.Serialize(encoder); err != nil {
			return err
		}
	}
	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 DecodeTableFeaturePropNextTables(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropNextTables, error) {
	_tablefeaturepropnexttables := &TableFeaturePropNextTables{TableFeatureProp: parent}
	defer decoder.SkipAlign()

	for decoder.Length() >= 1 {
		item, err := DecodeUint8(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_tablefeaturepropnexttables.NextTableIds = append(_tablefeaturepropnexttables.NextTableIds, item)
		}
	}
	return _tablefeaturepropnexttables, nil
}

func NewTableFeaturePropNextTables() *TableFeaturePropNextTables {
	obj := &TableFeaturePropNextTables{
		TableFeatureProp: NewTableFeatureProp(2),
	}
	return obj
}

type TableFeaturePropNextTablesMiss struct {
	*TableFeatureProp
	NextTableIds []*Uint8
}

type ITableFeaturePropNextTablesMiss interface {
	ITableFeatureProp
	GetNextTableIds() []*Uint8
}

func (self *TableFeaturePropNextTablesMiss) GetNextTableIds() []*Uint8 {
	return self.NextTableIds
}

func (self *TableFeaturePropNextTablesMiss) SetNextTableIds(v []*Uint8) {
	self.NextTableIds = v
}

func (self *TableFeaturePropNextTablesMiss) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.TableFeatureProp.Serialize(encoder); err != nil {
		return err
	}

	for _, obj := range self.NextTableIds {
		if err := obj.Serialize(encoder); err != nil {
			return err
		}
	}
	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 DecodeTableFeaturePropNextTablesMiss(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropNextTablesMiss, error) {
	_tablefeaturepropnexttablesmiss := &TableFeaturePropNextTablesMiss{TableFeatureProp: parent}
	defer decoder.SkipAlign()

	for decoder.Length() >= 1 {
		item, err := DecodeUint8(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_tablefeaturepropnexttablesmiss.NextTableIds = append(_tablefeaturepropnexttablesmiss.NextTableIds, item)
		}
	}
	return _tablefeaturepropnexttablesmiss, nil
}

func NewTableFeaturePropNextTablesMiss() *TableFeaturePropNextTablesMiss {
	obj := &TableFeaturePropNextTablesMiss{
		TableFeatureProp: NewTableFeatureProp(3),
	}
	return obj
}

type TableFeaturePropTableSyncFrom struct {
	*TableFeatureProp
	TableIds []*Uint8
}

type ITableFeaturePropTableSyncFrom interface {
	ITableFeatureProp
	GetTableIds() []*Uint8
}

func (self *TableFeaturePropTableSyncFrom) GetTableIds() []*Uint8 {
	return self.TableIds
}

func (self *TableFeaturePropTableSyncFrom) SetTableIds(v []*Uint8) {
	self.TableIds = v
}

func (self *TableFeaturePropTableSyncFrom) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.TableFeatureProp.Serialize(encoder); err != nil {
		return err
	}

	for _, obj := range self.TableIds {
		if err := obj.Serialize(encoder); err != nil {
			return err
		}
	}
	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 DecodeTableFeaturePropTableSyncFrom(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropTableSyncFrom, error) {
	_tablefeatureproptablesyncfrom := &TableFeaturePropTableSyncFrom{TableFeatureProp: parent}
	defer decoder.SkipAlign()

	for decoder.Length() >= 1 {
		item, err := DecodeUint8(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_tablefeatureproptablesyncfrom.TableIds = append(_tablefeatureproptablesyncfrom.TableIds, item)
		}
	}
	return _tablefeatureproptablesyncfrom, nil
}

func NewTableFeaturePropTableSyncFrom() *TableFeaturePropTableSyncFrom {
	obj := &TableFeaturePropTableSyncFrom{
		TableFeatureProp: NewTableFeatureProp(16),
	}
	return obj
}

type TableFeaturePropWildcards struct {
	*TableFeatureProp
	OxmIds []*Uint32
}

type ITableFeaturePropWildcards interface {
	ITableFeatureProp
	GetOxmIds() []*Uint32
}

func (self *TableFeaturePropWildcards) GetOxmIds() []*Uint32 {
	return self.OxmIds
}

func (self *TableFeaturePropWildcards) SetOxmIds(v []*Uint32) {
	self.OxmIds = v
}

func (self *TableFeaturePropWildcards) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.TableFeatureProp.Serialize(encoder); err != nil {
		return err
	}

	for _, obj := range self.OxmIds {
		if err := obj.Serialize(encoder); err != nil {
			return err
		}
	}
	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 DecodeTableFeaturePropWildcards(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropWildcards, error) {
	_tablefeaturepropwildcards := &TableFeaturePropWildcards{TableFeatureProp: parent}
	defer decoder.SkipAlign()

	for decoder.Length() >= 4 {
		item, err := DecodeUint32(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_tablefeaturepropwildcards.OxmIds = append(_tablefeaturepropwildcards.OxmIds, item)
		}
	}
	return _tablefeaturepropwildcards, nil
}

func NewTableFeaturePropWildcards() *TableFeaturePropWildcards {
	obj := &TableFeaturePropWildcards{
		TableFeatureProp: NewTableFeatureProp(10),
	}
	return obj
}

type TableFeaturePropWriteActions struct {
	*TableFeatureProp
	ActionIds []IActionId
}

type ITableFeaturePropWriteActions interface {
	ITableFeatureProp
	GetActionIds() []IActionId
}

func (self *TableFeaturePropWriteActions) GetActionIds() []IActionId {
	return self.ActionIds
}

func (self *TableFeaturePropWriteActions) SetActionIds(v []IActionId) {
	self.ActionIds = v
}

func (self *TableFeaturePropWriteActions) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.TableFeatureProp.Serialize(encoder); err != nil {
		return err
	}

	for _, obj := range self.ActionIds {
		if err := obj.Serialize(encoder); err != nil {
			return err
		}
	}
	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 DecodeTableFeaturePropWriteActions(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropWriteActions, error) {
	_tablefeaturepropwriteactions := &TableFeaturePropWriteActions{TableFeatureProp: parent}
	defer decoder.SkipAlign()

	for decoder.Length() >= 4 {
		item, err := DecodeActionId(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_tablefeaturepropwriteactions.ActionIds = append(_tablefeaturepropwriteactions.ActionIds, item)
		}
	}
	return _tablefeaturepropwriteactions, nil
}

func NewTableFeaturePropWriteActions() *TableFeaturePropWriteActions {
	obj := &TableFeaturePropWriteActions{
		TableFeatureProp: NewTableFeatureProp(4),
	}
	return obj
}

type TableFeaturePropWriteActionsMiss struct {
	*TableFeatureProp
	ActionIds []IActionId
}

type ITableFeaturePropWriteActionsMiss interface {
	ITableFeatureProp
	GetActionIds() []IActionId
}

func (self *TableFeaturePropWriteActionsMiss) GetActionIds() []IActionId {
	return self.ActionIds
}

func (self *TableFeaturePropWriteActionsMiss) SetActionIds(v []IActionId) {
	self.ActionIds = v
}

func (self *TableFeaturePropWriteActionsMiss) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.TableFeatureProp.Serialize(encoder); err != nil {
		return err
	}

	for _, obj := range self.ActionIds {
		if err := obj.Serialize(encoder); err != nil {
			return err
		}
	}
	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 DecodeTableFeaturePropWriteActionsMiss(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropWriteActionsMiss, error) {
	_tablefeaturepropwriteactionsmiss := &TableFeaturePropWriteActionsMiss{TableFeatureProp: parent}
	defer decoder.SkipAlign()

	for decoder.Length() >= 4 {
		item, err := DecodeActionId(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_tablefeaturepropwriteactionsmiss.ActionIds = append(_tablefeaturepropwriteactionsmiss.ActionIds, item)
		}
	}
	return _tablefeaturepropwriteactionsmiss, nil
}

func NewTableFeaturePropWriteActionsMiss() *TableFeaturePropWriteActionsMiss {
	obj := &TableFeaturePropWriteActionsMiss{
		TableFeatureProp: NewTableFeatureProp(5),
	}
	return obj
}

type TableFeaturePropWriteSetfield struct {
	*TableFeatureProp
	OxmIds []*Uint32
}

type ITableFeaturePropWriteSetfield interface {
	ITableFeatureProp
	GetOxmIds() []*Uint32
}

func (self *TableFeaturePropWriteSetfield) GetOxmIds() []*Uint32 {
	return self.OxmIds
}

func (self *TableFeaturePropWriteSetfield) SetOxmIds(v []*Uint32) {
	self.OxmIds = v
}

func (self *TableFeaturePropWriteSetfield) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.TableFeatureProp.Serialize(encoder); err != nil {
		return err
	}

	for _, obj := range self.OxmIds {
		if err := obj.Serialize(encoder); err != nil {
			return err
		}
	}
	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 DecodeTableFeaturePropWriteSetfield(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropWriteSetfield, error) {
	_tablefeaturepropwritesetfield := &TableFeaturePropWriteSetfield{TableFeatureProp: parent}
	defer decoder.SkipAlign()

	for decoder.Length() >= 4 {
		item, err := DecodeUint32(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_tablefeaturepropwritesetfield.OxmIds = append(_tablefeaturepropwritesetfield.OxmIds, item)
		}
	}
	return _tablefeaturepropwritesetfield, nil
}

func NewTableFeaturePropWriteSetfield() *TableFeaturePropWriteSetfield {
	obj := &TableFeaturePropWriteSetfield{
		TableFeatureProp: NewTableFeatureProp(12),
	}
	return obj
}

type TableFeaturePropWriteSetfieldMiss struct {
	*TableFeatureProp
	OxmIds []*Uint32
}

type ITableFeaturePropWriteSetfieldMiss interface {
	ITableFeatureProp
	GetOxmIds() []*Uint32
}

func (self *TableFeaturePropWriteSetfieldMiss) GetOxmIds() []*Uint32 {
	return self.OxmIds
}

func (self *TableFeaturePropWriteSetfieldMiss) SetOxmIds(v []*Uint32) {
	self.OxmIds = v
}

func (self *TableFeaturePropWriteSetfieldMiss) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.TableFeatureProp.Serialize(encoder); err != nil {
		return err
	}

	for _, obj := range self.OxmIds {
		if err := obj.Serialize(encoder); err != nil {
			return err
		}
	}
	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 DecodeTableFeaturePropWriteSetfieldMiss(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropWriteSetfieldMiss, error) {
	_tablefeaturepropwritesetfieldmiss := &TableFeaturePropWriteSetfieldMiss{TableFeatureProp: parent}
	defer decoder.SkipAlign()

	for decoder.Length() >= 4 {
		item, err := DecodeUint32(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_tablefeaturepropwritesetfieldmiss.OxmIds = append(_tablefeaturepropwritesetfieldmiss.OxmIds, item)
		}
	}
	return _tablefeaturepropwritesetfieldmiss, nil
}

func NewTableFeaturePropWriteSetfieldMiss() *TableFeaturePropWriteSetfieldMiss {
	obj := &TableFeaturePropWriteSetfieldMiss{
		TableFeatureProp: NewTableFeatureProp(13),
	}
	return obj
}

type TableFeatures struct {
	Length        uint16
	TableId       uint8
	Name          string
	MetadataMatch uint64
	MetadataWrite uint64
	Config        uint32
	MaxEntries    uint32
	Properties    []ITableFeatureProp
}

type ITableFeatures interface {
	goloxi.Serializable
	GetLength() uint16
	GetTableId() uint8
	GetName() string
	GetMetadataMatch() uint64
	GetMetadataWrite() uint64
	GetConfig() uint32
	GetMaxEntries() uint32
	GetProperties() []ITableFeatureProp
}

func (self *TableFeatures) GetLength() uint16 {
	return self.Length
}

func (self *TableFeatures) SetLength(v uint16) {
	self.Length = v
}

func (self *TableFeatures) GetTableId() uint8 {
	return self.TableId
}

func (self *TableFeatures) SetTableId(v uint8) {
	self.TableId = v
}

func (self *TableFeatures) GetName() string {
	return self.Name
}

func (self *TableFeatures) SetName(v string) {
	self.Name = v
}

func (self *TableFeatures) GetMetadataMatch() uint64 {
	return self.MetadataMatch
}

func (self *TableFeatures) SetMetadataMatch(v uint64) {
	self.MetadataMatch = v
}

func (self *TableFeatures) GetMetadataWrite() uint64 {
	return self.MetadataWrite
}

func (self *TableFeatures) SetMetadataWrite(v uint64) {
	self.MetadataWrite = v
}

func (self *TableFeatures) GetConfig() uint32 {
	return self.Config
}

func (self *TableFeatures) SetConfig(v uint32) {
	self.Config = v
}

func (self *TableFeatures) GetMaxEntries() uint32 {
	return self.MaxEntries
}

func (self *TableFeatures) SetMaxEntries(v uint32) {
	self.MaxEntries = v
}

func (self *TableFeatures) GetProperties() []ITableFeatureProp {
	return self.Properties
}

func (self *TableFeatures) SetProperties(v []ITableFeatureProp) {
	self.Properties = v
}

func (self *TableFeatures) 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}, 5))
	encoder.Write([]byte(self.Name))
	encoder.PutUint64(uint64(self.MetadataMatch))
	encoder.PutUint64(uint64(self.MetadataWrite))
	encoder.PutUint32(uint32(self.Config))
	encoder.PutUint32(uint32(self.MaxEntries))
	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+0:startIndex+2], uint16(length))

	return nil
}

func DecodeTableFeatures(decoder *goloxi.Decoder) (*TableFeatures, error) {
	_tablefeatures := &TableFeatures{}
	if decoder.Length() < 64 {
		return nil, fmt.Errorf("TableFeatures packet too short: %d < 64", decoder.Length())
	}
	_tablefeatures.Length = uint16(decoder.ReadUint16())
	oldDecoder := decoder
	defer func() { decoder = oldDecoder }()
	decoder = decoder.SliceDecoder(int(_tablefeatures.Length), 2+0)
	_tablefeatures.TableId = uint8(decoder.ReadByte())
	decoder.Skip(5)
	_tablefeatures.Name = string(bytes.Trim(decoder.Read(32), "\x00"))
	_tablefeatures.MetadataMatch = uint64(decoder.ReadUint64())
	_tablefeatures.MetadataWrite = uint64(decoder.ReadUint64())
	_tablefeatures.Config = uint32(decoder.ReadUint32())
	_tablefeatures.MaxEntries = uint32(decoder.ReadUint32())

	for decoder.Length() >= 4 {
		item, err := DecodeTableFeatureProp(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_tablefeatures.Properties = append(_tablefeatures.Properties, item)
		}
	}
	return _tablefeatures, nil
}

func NewTableFeatures() *TableFeatures {
	obj := &TableFeatures{}
	return obj
}

type TableModProp struct {
	Type   uint16
	Length uint16
}

type ITableModProp interface {
	goloxi.Serializable
	GetType() uint16
	GetLength() uint16
}

func (self *TableModProp) GetType() uint16 {
	return self.Type
}

func (self *TableModProp) SetType(v uint16) {
	self.Type = v
}

func (self *TableModProp) GetLength() uint16 {
	return self.Length
}

func (self *TableModProp) SetLength(v uint16) {
	self.Length = v
}

func (self *TableModProp) Serialize(encoder *goloxi.Encoder) error {

	encoder.PutUint16(uint16(self.Type))
	encoder.PutUint16(uint16(self.Length))

	return nil
}

func DecodeTableModProp(decoder *goloxi.Decoder) (ITableModProp, error) {
	_tablemodprop := &TableModProp{}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("TableModProp packet too short: %d < 4", decoder.Length())
	}
	_tablemodprop.Type = uint16(decoder.ReadUint16())
	_tablemodprop.Length = uint16(decoder.ReadUint16())
	oldDecoder := decoder
	defer func() { decoder = oldDecoder }()
	decoder = decoder.SliceDecoder(int(_tablemodprop.Length), 2+2)
	return _tablemodprop, nil
}

func NewTableModProp(_type uint16) *TableModProp {
	obj := &TableModProp{}
	obj.Type = _type
	return obj
}

type TableModPropEviction struct {
	Type   uint16
	Length uint16
	Flags  TableModPropEvictionFlag
}

type ITableModPropEviction interface {
	goloxi.Serializable
	GetType() uint16
	GetLength() uint16
	GetFlags() TableModPropEvictionFlag
}

func (self *TableModPropEviction) GetType() uint16 {
	return self.Type
}

func (self *TableModPropEviction) SetType(v uint16) {
	self.Type = v
}

func (self *TableModPropEviction) GetLength() uint16 {
	return self.Length
}

func (self *TableModPropEviction) SetLength(v uint16) {
	self.Length = v
}

func (self *TableModPropEviction) GetFlags() TableModPropEvictionFlag {
	return self.Flags
}

func (self *TableModPropEviction) SetFlags(v TableModPropEvictionFlag) {
	self.Flags = v
}

func (self *TableModPropEviction) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())

	encoder.PutUint16(uint16(self.Type))
	encoder.PutUint16(uint16(self.Length))
	encoder.PutUint32(uint32(self.Flags))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeTableModPropEviction(decoder *goloxi.Decoder) (*TableModPropEviction, error) {
	_tablemodpropeviction := &TableModPropEviction{}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("TableModPropEviction packet too short: %d < 8", decoder.Length())
	}
	_tablemodpropeviction.Type = uint16(decoder.ReadUint16())
	_tablemodpropeviction.Length = uint16(decoder.ReadUint16())
	oldDecoder := decoder
	defer func() { decoder = oldDecoder }()
	decoder = decoder.SliceDecoder(int(_tablemodpropeviction.Length), 2+2)
	_tablemodpropeviction.Flags = TableModPropEvictionFlag(decoder.ReadUint32())
	return _tablemodpropeviction, nil
}

func NewTableModPropEviction() *TableModPropEviction {
	obj := &TableModPropEviction{}
	return obj
}

type TableModPropExperimenter struct {
	Type         uint16
	Length       uint16
	Experimenter uint32
	ExpType      uint32
}

type ITableModPropExperimenter interface {
	goloxi.Serializable
	GetType() uint16
	GetLength() uint16
	GetExperimenter() uint32
	GetExpType() uint32
}

func (self *TableModPropExperimenter) GetType() uint16 {
	return self.Type
}

func (self *TableModPropExperimenter) SetType(v uint16) {
	self.Type = v
}

func (self *TableModPropExperimenter) GetLength() uint16 {
	return self.Length
}

func (self *TableModPropExperimenter) SetLength(v uint16) {
	self.Length = v
}

func (self *TableModPropExperimenter) GetExperimenter() uint32 {
	return self.Experimenter
}

func (self *TableModPropExperimenter) SetExperimenter(v uint32) {
	self.Experimenter = v
}

func (self *TableModPropExperimenter) GetExpType() uint32 {
	return self.ExpType
}

func (self *TableModPropExperimenter) SetExpType(v uint32) {
	self.ExpType = v
}

func (self *TableModPropExperimenter) Serialize(encoder *goloxi.Encoder) error {

	encoder.PutUint16(uint16(self.Type))
	encoder.PutUint16(uint16(self.Length))
	encoder.PutUint32(uint32(self.Experimenter))
	encoder.PutUint32(uint32(self.ExpType))

	return nil
}

func DecodeTableModPropExperimenter(decoder *goloxi.Decoder) (ITableModPropExperimenter, error) {
	_tablemodpropexperimenter := &TableModPropExperimenter{}
	if decoder.Length() < 12 {
		return nil, fmt.Errorf("TableModPropExperimenter packet too short: %d < 12", decoder.Length())
	}
	_tablemodpropexperimenter.Type = uint16(decoder.ReadUint16())
	_tablemodpropexperimenter.Length = uint16(decoder.ReadUint16())
	oldDecoder := decoder
	defer func() { decoder = oldDecoder }()
	decoder = decoder.SliceDecoder(int(_tablemodpropexperimenter.Length), 2+2)
	_tablemodpropexperimenter.Experimenter = uint32(decoder.ReadUint32())
	_tablemodpropexperimenter.ExpType = uint32(decoder.ReadUint32())
	return _tablemodpropexperimenter, nil
}

func NewTableModPropExperimenter(_experimenter uint32) *TableModPropExperimenter {
	obj := &TableModPropExperimenter{}
	obj.Experimenter = _experimenter
	return obj
}

type TableModPropVacancy struct {
	Type        uint16
	Length      uint16
	VacancyDown uint8
	VacancyUp   uint8
	Vacancy     uint8
}

type ITableModPropVacancy interface {
	goloxi.Serializable
	GetType() uint16
	GetLength() uint16
	GetVacancyDown() uint8
	GetVacancyUp() uint8
	GetVacancy() uint8
}

func (self *TableModPropVacancy) GetType() uint16 {
	return self.Type
}

func (self *TableModPropVacancy) SetType(v uint16) {
	self.Type = v
}

func (self *TableModPropVacancy) GetLength() uint16 {
	return self.Length
}

func (self *TableModPropVacancy) SetLength(v uint16) {
	self.Length = v
}

func (self *TableModPropVacancy) GetVacancyDown() uint8 {
	return self.VacancyDown
}

func (self *TableModPropVacancy) SetVacancyDown(v uint8) {
	self.VacancyDown = v
}

func (self *TableModPropVacancy) GetVacancyUp() uint8 {
	return self.VacancyUp
}

func (self *TableModPropVacancy) SetVacancyUp(v uint8) {
	self.VacancyUp = v
}

func (self *TableModPropVacancy) GetVacancy() uint8 {
	return self.Vacancy
}

func (self *TableModPropVacancy) SetVacancy(v uint8) {
	self.Vacancy = v
}

func (self *TableModPropVacancy) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())

	encoder.PutUint16(uint16(self.Type))
	encoder.PutUint16(uint16(self.Length))
	encoder.PutUint8(uint8(self.VacancyDown))
	encoder.PutUint8(uint8(self.VacancyUp))
	encoder.PutUint8(uint8(self.Vacancy))
	encoder.Write(bytes.Repeat([]byte{0}, 1))
	length := len(encoder.Bytes()) - startIndex

	binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))

	return nil
}

func DecodeTableModPropVacancy(decoder *goloxi.Decoder) (*TableModPropVacancy, error) {
	_tablemodpropvacancy := &TableModPropVacancy{}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("TableModPropVacancy packet too short: %d < 8", decoder.Length())
	}
	_tablemodpropvacancy.Type = uint16(decoder.ReadUint16())
	_tablemodpropvacancy.Length = uint16(decoder.ReadUint16())
	oldDecoder := decoder
	defer func() { decoder = oldDecoder }()
	decoder = decoder.SliceDecoder(int(_tablemodpropvacancy.Length), 2+2)
	_tablemodpropvacancy.VacancyDown = uint8(decoder.ReadByte())
	_tablemodpropvacancy.VacancyUp = uint8(decoder.ReadByte())
	_tablemodpropvacancy.Vacancy = uint8(decoder.ReadByte())
	decoder.Skip(1)
	return _tablemodpropvacancy, nil
}

func NewTableModPropVacancy() *TableModPropVacancy {
	obj := &TableModPropVacancy{}
	return obj
}

type TableStatsEntry struct {
	TableId      uint8
	ActiveCount  uint32
	LookupCount  uint64
	MatchedCount uint64
}

type ITableStatsEntry interface {
	goloxi.Serializable
	GetTableId() uint8
	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) 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.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() < 24 {
		return nil, fmt.Errorf("TableStatsEntry packet too short: %d < 24", decoder.Length())
	}
	_tablestatsentry.TableId = uint8(decoder.ReadByte())
	decoder.Skip(3)
	_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
}

type Uint32 struct {
	Value uint32
}

type IUint32 interface {
	goloxi.Serializable
	GetValue() uint32
}

func (self *Uint32) GetValue() uint32 {
	return self.Value
}

func (self *Uint32) SetValue(v uint32) {
	self.Value = v
}

func (self *Uint32) Serialize(encoder *goloxi.Encoder) error {

	encoder.PutUint32(uint32(self.Value))

	return nil
}

func DecodeUint32(decoder *goloxi.Decoder) (*Uint32, error) {
	_uint32 := &Uint32{}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("Uint32 packet too short: %d < 4", decoder.Length())
	}
	_uint32.Value = uint32(decoder.ReadUint32())
	return _uint32, nil
}

func NewUint32() *Uint32 {
	obj := &Uint32{}
	return obj
}

type Uint64 struct {
	Value uint64
}

type IUint64 interface {
	goloxi.Serializable
	GetValue() uint64
}

func (self *Uint64) GetValue() uint64 {
	return self.Value
}

func (self *Uint64) SetValue(v uint64) {
	self.Value = v
}

func (self *Uint64) Serialize(encoder *goloxi.Encoder) error {

	encoder.PutUint64(uint64(self.Value))

	return nil
}

func DecodeUint64(decoder *goloxi.Decoder) (*Uint64, error) {
	_uint64 := &Uint64{}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("Uint64 packet too short: %d < 8", decoder.Length())
	}
	_uint64.Value = uint64(decoder.ReadUint64())
	return _uint64, nil
}

func NewUint64() *Uint64 {
	obj := &Uint64{}
	return obj
}

type Uint8 struct {
	Value uint8
}

type IUint8 interface {
	goloxi.Serializable
	GetValue() uint8
}

func (self *Uint8) GetValue() uint8 {
	return self.Value
}

func (self *Uint8) SetValue(v uint8) {
	self.Value = v
}

func (self *Uint8) Serialize(encoder *goloxi.Encoder) error {

	encoder.PutUint8(uint8(self.Value))

	return nil
}

func DecodeUint8(decoder *goloxi.Decoder) (*Uint8, error) {
	_uint8 := &Uint8{}
	if decoder.Length() < 1 {
		return nil, fmt.Errorf("Uint8 packet too short: %d < 1", decoder.Length())
	}
	_uint8.Value = uint8(decoder.ReadByte())
	return _uint8, nil
}

func NewUint8() *Uint8 {
	obj := &Uint8{}
	return obj
}