/*
 * 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 Header struct {
	Version uint8
	Type    uint8
	Length  uint16
	Xid     uint32
}

type IHeader interface {
	goloxi.Serializable
	GetVersion() uint8
	GetType() uint8
	GetLength() uint16
	GetXid() uint32
}

func (self *Header) GetVersion() uint8 {
	return self.Version
}

func (self *Header) SetVersion(v uint8) {
	self.Version = v
}

func (self *Header) GetType() uint8 {
	return self.Type
}

func (self *Header) SetType(v uint8) {
	self.Type = v
}

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

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

func (self *Header) GetXid() uint32 {
	return self.Xid
}

func (self *Header) SetXid(v uint32) {
	self.Xid = v
}

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

	encoder.PutUint8(uint8(5))
	encoder.PutUint8(uint8(self.Type))
	encoder.PutUint16(uint16(self.Length))
	encoder.PutUint32(uint32(self.Xid))

	return nil
}
func (self *Header) Decode(decoder *goloxi.Decoder) error {
	if decoder.Length() < 8 {
		return fmt.Errorf("Header packet too short: %d < 8", decoder.Length())
	}

	self.Version = uint8(decoder.ReadByte())
	self.Type = uint8(decoder.ReadByte())
	self.Length = uint16(decoder.ReadUint16())
	oldDecoder := decoder
	defer func() { decoder = oldDecoder }()
	decoder = decoder.SliceDecoder(int(self.Length), 2+2)
	self.Xid = uint32(decoder.ReadUint32())

	return nil
}
func DecodeHeader(decoder *goloxi.Decoder) (IHeader, error) {
	_header := &Header{}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("Header packet too short: %d < 8", decoder.Length())
	}
	_header.Version = uint8(decoder.ReadByte())
	_header.Type = uint8(decoder.ReadByte())
	_header.Length = uint16(decoder.ReadUint16())
	oldDecoder := decoder
	defer func() { decoder = oldDecoder }()
	decoder = decoder.SliceDecoder(int(_header.Length), 2+2)
	_header.Xid = uint32(decoder.ReadUint32())

	switch _header.Type {
	case 0:
		return DecodeHello(_header, decoder)
	case 1:
		return DecodeErrorMsg(_header, decoder)
	case 2:
		return DecodeEchoRequest(_header, decoder)
	case 3:
		return DecodeEchoReply(_header, decoder)
	case 4:
		return DecodeExperimenter(_header, decoder)
	case 5:
		return DecodeFeaturesRequest(_header, decoder)
	case 6:
		return DecodeFeaturesReply(_header, decoder)
	case 7:
		return DecodeGetConfigRequest(_header, decoder)
	case 8:
		return DecodeGetConfigReply(_header, decoder)
	case 9:
		return DecodeSetConfig(_header, decoder)
	case 10:
		return DecodePacketIn(_header, decoder)
	case 11:
		return DecodeFlowRemoved(_header, decoder)
	case 12:
		return DecodePortStatus(_header, decoder)
	case 13:
		return DecodePacketOut(_header, decoder)
	case 14:
		return DecodeFlowMod(_header, decoder)
	case 15:
		return DecodeGroupMod(_header, decoder)
	case 16:
		return DecodePortMod(_header, decoder)
	case 17:
		return DecodeTableMod(_header, decoder)
	case 18:
		return DecodeStatsRequest(_header, decoder)
	case 19:
		return DecodeStatsReply(_header, decoder)
	case 20:
		return DecodeBarrierRequest(_header, decoder)
	case 21:
		return DecodeBarrierReply(_header, decoder)
	case 24:
		return DecodeRoleRequest(_header, decoder)
	case 25:
		return DecodeRoleReply(_header, decoder)
	case 26:
		return DecodeAsyncGetRequest(_header, decoder)
	case 27:
		return DecodeAsyncGetReply(_header, decoder)
	case 28:
		return DecodeAsyncSet(_header, decoder)
	case 29:
		return DecodeMeterMod(_header, decoder)
	case 30:
		return DecodeRoleStatus(_header, decoder)
	case 31:
		return DecodeTableStatus(_header, decoder)
	case 32:
		return DecodeRequestforward(_header, decoder)
	case 33:
		return DecodeBundleCtrlMsg(_header, decoder)
	case 34:
		return DecodeBundleAddMsg(_header, decoder)
	default:
		return nil, fmt.Errorf("Invalid type '%d' for 'Header'", _header.Type)
	}
}

func NewHeader(_type uint8) *Header {
	obj := &Header{}
	obj.Type = _type
	return obj
}

type StatsReply struct {
	*Header
	StatsType uint16
	Flags     StatsReplyFlags
}

type IStatsReply interface {
	IHeader
	GetStatsType() uint16
	GetFlags() StatsReplyFlags
}

func (self *StatsReply) GetStatsType() uint16 {
	return self.StatsType
}

func (self *StatsReply) SetStatsType(v uint16) {
	self.StatsType = v
}

func (self *StatsReply) GetFlags() StatsReplyFlags {
	return self.Flags
}

func (self *StatsReply) SetFlags(v StatsReplyFlags) {
	self.Flags = v
}

func (self *StatsReply) Serialize(encoder *goloxi.Encoder) error {
	if err := self.Header.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint16(uint16(self.StatsType))
	encoder.PutUint16(uint16(self.Flags))

	return nil
}

func DecodeStatsReply(parent *Header, decoder *goloxi.Decoder) (IStatsReply, error) {
	_statsreply := &StatsReply{Header: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("StatsReply packet too short: %d < 4", decoder.Length())
	}
	_statsreply.StatsType = uint16(decoder.ReadUint16())
	_statsreply.Flags = StatsReplyFlags(decoder.ReadUint16())

	switch _statsreply.StatsType {
	case 0:
		return DecodeDescStatsReply(_statsreply, decoder)
	case 1:
		return DecodeFlowStatsReply(_statsreply, decoder)
	case 2:
		return DecodeAggregateStatsReply(_statsreply, decoder)
	case 3:
		return DecodeTableStatsReply(_statsreply, decoder)
	case 4:
		return DecodePortStatsReply(_statsreply, decoder)
	case 5:
		return DecodeQueueStatsReply(_statsreply, decoder)
	case 6:
		return DecodeGroupStatsReply(_statsreply, decoder)
	case 7:
		return DecodeGroupDescStatsReply(_statsreply, decoder)
	case 8:
		return DecodeGroupFeaturesStatsReply(_statsreply, decoder)
	case 9:
		return DecodeMeterStatsReply(_statsreply, decoder)
	case 10:
		return DecodeMeterConfigStatsReply(_statsreply, decoder)
	case 11:
		return DecodeMeterFeaturesStatsReply(_statsreply, decoder)
	case 12:
		return DecodeTableFeaturesStatsReply(_statsreply, decoder)
	case 13:
		return DecodePortDescStatsReply(_statsreply, decoder)
	case 14:
		return DecodeTableDescStatsReply(_statsreply, decoder)
	case 15:
		return DecodeQueueDescStatsReply(_statsreply, decoder)
	case 16:
		return DecodeFlowMonitorReply(_statsreply, decoder)
	case 65535:
		return DecodeExperimenterStatsReply(_statsreply, decoder)
	default:
		return nil, fmt.Errorf("Invalid type '%d' for 'StatsReply'", _statsreply.StatsType)
	}
}

func NewStatsReply(_stats_type uint16) *StatsReply {
	obj := &StatsReply{
		Header: NewHeader(19),
	}
	obj.StatsType = _stats_type
	return obj
}

type AggregateStatsReply struct {
	*StatsReply
	PacketCount uint64
	ByteCount   uint64
	FlowCount   uint32
}

type IAggregateStatsReply interface {
	IStatsReply
	GetPacketCount() uint64
	GetByteCount() uint64
	GetFlowCount() uint32
}

func (self *AggregateStatsReply) GetPacketCount() uint64 {
	return self.PacketCount
}

func (self *AggregateStatsReply) SetPacketCount(v uint64) {
	self.PacketCount = v
}

func (self *AggregateStatsReply) GetByteCount() uint64 {
	return self.ByteCount
}

func (self *AggregateStatsReply) SetByteCount(v uint64) {
	self.ByteCount = v
}

func (self *AggregateStatsReply) GetFlowCount() uint32 {
	return self.FlowCount
}

func (self *AggregateStatsReply) SetFlowCount(v uint32) {
	self.FlowCount = v
}

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

	encoder.Write(bytes.Repeat([]byte{0}, 4))
	encoder.PutUint64(uint64(self.PacketCount))
	encoder.PutUint64(uint64(self.ByteCount))
	encoder.PutUint32(uint32(self.FlowCount))
	encoder.Write(bytes.Repeat([]byte{0}, 4))
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeAggregateStatsReply(parent *StatsReply, decoder *goloxi.Decoder) (*AggregateStatsReply, error) {
	_aggregatestatsreply := &AggregateStatsReply{StatsReply: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("AggregateStatsReply packet too short: %d < 4", decoder.Length())
	}
	decoder.Skip(4)
	_aggregatestatsreply.PacketCount = uint64(decoder.ReadUint64())
	_aggregatestatsreply.ByteCount = uint64(decoder.ReadUint64())
	_aggregatestatsreply.FlowCount = uint32(decoder.ReadUint32())
	decoder.Skip(4)
	return _aggregatestatsreply, nil
}

func NewAggregateStatsReply() *AggregateStatsReply {
	obj := &AggregateStatsReply{
		StatsReply: NewStatsReply(2),
	}
	return obj
}

type StatsRequest struct {
	*Header
	StatsType uint16
	Flags     StatsRequestFlags
}

type IStatsRequest interface {
	IHeader
	GetStatsType() uint16
	GetFlags() StatsRequestFlags
}

func (self *StatsRequest) GetStatsType() uint16 {
	return self.StatsType
}

func (self *StatsRequest) SetStatsType(v uint16) {
	self.StatsType = v
}

func (self *StatsRequest) GetFlags() StatsRequestFlags {
	return self.Flags
}

func (self *StatsRequest) SetFlags(v StatsRequestFlags) {
	self.Flags = v
}

func (self *StatsRequest) Serialize(encoder *goloxi.Encoder) error {
	if err := self.Header.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint16(uint16(self.StatsType))
	encoder.PutUint16(uint16(self.Flags))

	return nil
}

func DecodeStatsRequest(parent *Header, decoder *goloxi.Decoder) (IStatsRequest, error) {
	_statsrequest := &StatsRequest{Header: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("StatsRequest packet too short: %d < 4", decoder.Length())
	}
	_statsrequest.StatsType = uint16(decoder.ReadUint16())
	_statsrequest.Flags = StatsRequestFlags(decoder.ReadUint16())

	switch _statsrequest.StatsType {
	case 0:
		return DecodeDescStatsRequest(_statsrequest, decoder)
	case 1:
		return DecodeFlowStatsRequest(_statsrequest, decoder)
	case 2:
		return DecodeAggregateStatsRequest(_statsrequest, decoder)
	case 3:
		return DecodeTableStatsRequest(_statsrequest, decoder)
	case 4:
		return DecodePortStatsRequest(_statsrequest, decoder)
	case 5:
		return DecodeQueueStatsRequest(_statsrequest, decoder)
	case 6:
		return DecodeGroupStatsRequest(_statsrequest, decoder)
	case 7:
		return DecodeGroupDescStatsRequest(_statsrequest, decoder)
	case 8:
		return DecodeGroupFeaturesStatsRequest(_statsrequest, decoder)
	case 9:
		return DecodeMeterStatsRequest(_statsrequest, decoder)
	case 10:
		return DecodeMeterConfigStatsRequest(_statsrequest, decoder)
	case 11:
		return DecodeMeterFeaturesStatsRequest(_statsrequest, decoder)
	case 12:
		return DecodeTableFeaturesStatsRequest(_statsrequest, decoder)
	case 13:
		return DecodePortDescStatsRequest(_statsrequest, decoder)
	case 14:
		return DecodeTableDescStatsRequest(_statsrequest, decoder)
	case 15:
		return DecodeQueueDescStatsRequest(_statsrequest, decoder)
	case 16:
		return DecodeFlowMonitorRequest(_statsrequest, decoder)
	case 65535:
		return DecodeExperimenterStatsRequest(_statsrequest, decoder)
	default:
		return nil, fmt.Errorf("Invalid type '%d' for 'StatsRequest'", _statsrequest.StatsType)
	}
}

func NewStatsRequest(_stats_type uint16) *StatsRequest {
	obj := &StatsRequest{
		Header: NewHeader(18),
	}
	obj.StatsType = _stats_type
	return obj
}

type AggregateStatsRequest struct {
	*StatsRequest
	TableId    uint8
	OutPort    Port
	OutGroup   uint32
	Cookie     uint64
	CookieMask uint64
	Match      Match
}

type IAggregateStatsRequest interface {
	IStatsRequest
	GetTableId() uint8
	GetOutPort() Port
	GetOutGroup() uint32
	GetCookie() uint64
	GetCookieMask() uint64
	GetMatch() Match
}

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

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

func (self *AggregateStatsRequest) GetOutPort() Port {
	return self.OutPort
}

func (self *AggregateStatsRequest) SetOutPort(v Port) {
	self.OutPort = v
}

func (self *AggregateStatsRequest) GetOutGroup() uint32 {
	return self.OutGroup
}

func (self *AggregateStatsRequest) SetOutGroup(v uint32) {
	self.OutGroup = v
}

func (self *AggregateStatsRequest) GetCookie() uint64 {
	return self.Cookie
}

func (self *AggregateStatsRequest) SetCookie(v uint64) {
	self.Cookie = v
}

func (self *AggregateStatsRequest) GetCookieMask() uint64 {
	return self.CookieMask
}

func (self *AggregateStatsRequest) SetCookieMask(v uint64) {
	self.CookieMask = v
}

func (self *AggregateStatsRequest) GetMatch() Match {
	return self.Match
}

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

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

	encoder.Write(bytes.Repeat([]byte{0}, 4))
	encoder.PutUint8(uint8(self.TableId))
	encoder.Write(bytes.Repeat([]byte{0}, 3))
	self.OutPort.Serialize(encoder)
	encoder.PutUint32(uint32(self.OutGroup))
	encoder.Write(bytes.Repeat([]byte{0}, 4))
	encoder.PutUint64(uint64(self.Cookie))
	encoder.PutUint64(uint64(self.CookieMask))
	if err := self.Match.Serialize(encoder); err != nil {
		return err
	}

	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeAggregateStatsRequest(parent *StatsRequest, decoder *goloxi.Decoder) (*AggregateStatsRequest, error) {
	_aggregatestatsrequest := &AggregateStatsRequest{StatsRequest: parent}
	if decoder.Length() < 28 {
		return nil, fmt.Errorf("AggregateStatsRequest packet too short: %d < 28", decoder.Length())
	}
	decoder.Skip(4)
	_aggregatestatsrequest.TableId = uint8(decoder.ReadByte())
	decoder.Skip(3)
	_aggregatestatsrequest.OutPort.Decode(decoder)
	_aggregatestatsrequest.OutGroup = uint32(decoder.ReadUint32())
	decoder.Skip(4)
	_aggregatestatsrequest.Cookie = uint64(decoder.ReadUint64())
	_aggregatestatsrequest.CookieMask = uint64(decoder.ReadUint64())
	if err := _aggregatestatsrequest.Match.Decode(decoder); err != nil {
		return nil, err
	}

	decoder.SkipAlign()
	return _aggregatestatsrequest, nil
}

func NewAggregateStatsRequest() *AggregateStatsRequest {
	obj := &AggregateStatsRequest{
		StatsRequest: NewStatsRequest(2),
	}
	return obj
}

type ErrorMsg struct {
	*Header
	ErrType uint16
}

type IErrorMsg interface {
	IHeader
	GetErrType() uint16
}

func (self *ErrorMsg) GetErrType() uint16 {
	return self.ErrType
}

func (self *ErrorMsg) SetErrType(v uint16) {
	self.ErrType = v
}

func (self *ErrorMsg) Serialize(encoder *goloxi.Encoder) error {
	if err := self.Header.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint16(uint16(self.ErrType))

	return nil
}

func DecodeErrorMsg(parent *Header, decoder *goloxi.Decoder) (IErrorMsg, error) {
	_errormsg := &ErrorMsg{Header: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("ErrorMsg packet too short: %d < 2", decoder.Length())
	}
	_errormsg.ErrType = uint16(decoder.ReadUint16())

	switch _errormsg.ErrType {
	case 0:
		return DecodeHelloFailedErrorMsg(_errormsg, decoder)
	case 1:
		return DecodeBadRequestErrorMsg(_errormsg, decoder)
	case 2:
		return DecodeBadActionErrorMsg(_errormsg, decoder)
	case 3:
		return DecodeBadInstructionErrorMsg(_errormsg, decoder)
	case 4:
		return DecodeBadMatchErrorMsg(_errormsg, decoder)
	case 5:
		return DecodeFlowModFailedErrorMsg(_errormsg, decoder)
	case 6:
		return DecodeGroupModFailedErrorMsg(_errormsg, decoder)
	case 7:
		return DecodePortModFailedErrorMsg(_errormsg, decoder)
	case 8:
		return DecodeTableModFailedErrorMsg(_errormsg, decoder)
	case 9:
		return DecodeQueueOpFailedErrorMsg(_errormsg, decoder)
	case 10:
		return DecodeSwitchConfigFailedErrorMsg(_errormsg, decoder)
	case 11:
		return DecodeRoleRequestFailedErrorMsg(_errormsg, decoder)
	case 12:
		return DecodeMeterModFailedErrorMsg(_errormsg, decoder)
	case 13:
		return DecodeTableFeaturesFailedErrorMsg(_errormsg, decoder)
	case 14:
		return DecodeBadPropertyErrorMsg(_errormsg, decoder)
	case 15:
		return DecodeAsyncConfigFailedErrorMsg(_errormsg, decoder)
	case 16:
		return DecodeFlowMonitorFailedErrorMsg(_errormsg, decoder)
	case 17:
		return DecodeBundleFailedErrorMsg(_errormsg, decoder)
	case 65535:
		return DecodeExperimenterErrorMsg(_errormsg, decoder)
	default:
		return nil, fmt.Errorf("Invalid type '%d' for 'ErrorMsg'", _errormsg.ErrType)
	}
}

func NewErrorMsg(_err_type uint16) *ErrorMsg {
	obj := &ErrorMsg{
		Header: NewHeader(1),
	}
	obj.ErrType = _err_type
	return obj
}

type AsyncConfigFailedErrorMsg struct {
	*ErrorMsg
	Code AsyncConfigFailedCode
	Data []byte
}

type IAsyncConfigFailedErrorMsg interface {
	IErrorMsg
	GetCode() AsyncConfigFailedCode
	GetData() []byte
}

func (self *AsyncConfigFailedErrorMsg) GetCode() AsyncConfigFailedCode {
	return self.Code
}

func (self *AsyncConfigFailedErrorMsg) SetCode(v AsyncConfigFailedCode) {
	self.Code = v
}

func (self *AsyncConfigFailedErrorMsg) GetData() []byte {
	return self.Data
}

func (self *AsyncConfigFailedErrorMsg) SetData(v []byte) {
	self.Data = v
}

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

	encoder.PutUint16(uint16(self.Code))
	encoder.Write(self.Data)
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeAsyncConfigFailedErrorMsg(parent *ErrorMsg, decoder *goloxi.Decoder) (*AsyncConfigFailedErrorMsg, error) {
	_asyncconfigfailederrormsg := &AsyncConfigFailedErrorMsg{ErrorMsg: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("AsyncConfigFailedErrorMsg packet too short: %d < 2", decoder.Length())
	}
	_asyncconfigfailederrormsg.Code = AsyncConfigFailedCode(decoder.ReadUint16())
	_asyncconfigfailederrormsg.Data = decoder.Read(int(decoder.Length()))
	return _asyncconfigfailederrormsg, nil
}

func NewAsyncConfigFailedErrorMsg() *AsyncConfigFailedErrorMsg {
	obj := &AsyncConfigFailedErrorMsg{
		ErrorMsg: NewErrorMsg(15),
	}
	return obj
}

type AsyncGetReply struct {
	*Header
	Properties []IAsyncConfigProp
}

type IAsyncGetReply interface {
	IHeader
	GetProperties() []IAsyncConfigProp
}

func (self *AsyncGetReply) GetProperties() []IAsyncConfigProp {
	return self.Properties
}

func (self *AsyncGetReply) SetProperties(v []IAsyncConfigProp) {
	self.Properties = v
}

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

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

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

	return nil
}

func DecodeAsyncGetReply(parent *Header, decoder *goloxi.Decoder) (*AsyncGetReply, error) {
	_asyncgetreply := &AsyncGetReply{Header: parent}

	for decoder.Length() >= 4 {
		item, err := DecodeAsyncConfigProp(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_asyncgetreply.Properties = append(_asyncgetreply.Properties, item)
		}
	}
	return _asyncgetreply, nil
}

func NewAsyncGetReply() *AsyncGetReply {
	obj := &AsyncGetReply{
		Header: NewHeader(27),
	}
	return obj
}

type AsyncGetRequest struct {
	*Header
	Properties []IAsyncConfigProp
}

type IAsyncGetRequest interface {
	IHeader
	GetProperties() []IAsyncConfigProp
}

func (self *AsyncGetRequest) GetProperties() []IAsyncConfigProp {
	return self.Properties
}

func (self *AsyncGetRequest) SetProperties(v []IAsyncConfigProp) {
	self.Properties = v
}

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

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

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

	return nil
}

func DecodeAsyncGetRequest(parent *Header, decoder *goloxi.Decoder) (*AsyncGetRequest, error) {
	_asyncgetrequest := &AsyncGetRequest{Header: parent}

	for decoder.Length() >= 4 {
		item, err := DecodeAsyncConfigProp(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_asyncgetrequest.Properties = append(_asyncgetrequest.Properties, item)
		}
	}
	return _asyncgetrequest, nil
}

func NewAsyncGetRequest() *AsyncGetRequest {
	obj := &AsyncGetRequest{
		Header: NewHeader(26),
	}
	return obj
}

type AsyncSet struct {
	*Header
	Properties []IAsyncConfigProp
}

type IAsyncSet interface {
	IHeader
	GetProperties() []IAsyncConfigProp
}

func (self *AsyncSet) GetProperties() []IAsyncConfigProp {
	return self.Properties
}

func (self *AsyncSet) SetProperties(v []IAsyncConfigProp) {
	self.Properties = v
}

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

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

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

	return nil
}

func DecodeAsyncSet(parent *Header, decoder *goloxi.Decoder) (*AsyncSet, error) {
	_asyncset := &AsyncSet{Header: parent}

	for decoder.Length() >= 4 {
		item, err := DecodeAsyncConfigProp(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_asyncset.Properties = append(_asyncset.Properties, item)
		}
	}
	return _asyncset, nil
}

func NewAsyncSet() *AsyncSet {
	obj := &AsyncSet{
		Header: NewHeader(28),
	}
	return obj
}

type BadActionErrorMsg struct {
	*ErrorMsg
	Code BadActionCode
	Data []byte
}

type IBadActionErrorMsg interface {
	IErrorMsg
	GetCode() BadActionCode
	GetData() []byte
}

func (self *BadActionErrorMsg) GetCode() BadActionCode {
	return self.Code
}

func (self *BadActionErrorMsg) SetCode(v BadActionCode) {
	self.Code = v
}

func (self *BadActionErrorMsg) GetData() []byte {
	return self.Data
}

func (self *BadActionErrorMsg) SetData(v []byte) {
	self.Data = v
}

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

	encoder.PutUint16(uint16(self.Code))
	encoder.Write(self.Data)
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeBadActionErrorMsg(parent *ErrorMsg, decoder *goloxi.Decoder) (*BadActionErrorMsg, error) {
	_badactionerrormsg := &BadActionErrorMsg{ErrorMsg: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("BadActionErrorMsg packet too short: %d < 2", decoder.Length())
	}
	_badactionerrormsg.Code = BadActionCode(decoder.ReadUint16())
	_badactionerrormsg.Data = decoder.Read(int(decoder.Length()))
	return _badactionerrormsg, nil
}

func NewBadActionErrorMsg() *BadActionErrorMsg {
	obj := &BadActionErrorMsg{
		ErrorMsg: NewErrorMsg(2),
	}
	return obj
}

type BadInstructionErrorMsg struct {
	*ErrorMsg
	Code BadInstructionCode
	Data []byte
}

type IBadInstructionErrorMsg interface {
	IErrorMsg
	GetCode() BadInstructionCode
	GetData() []byte
}

func (self *BadInstructionErrorMsg) GetCode() BadInstructionCode {
	return self.Code
}

func (self *BadInstructionErrorMsg) SetCode(v BadInstructionCode) {
	self.Code = v
}

func (self *BadInstructionErrorMsg) GetData() []byte {
	return self.Data
}

func (self *BadInstructionErrorMsg) SetData(v []byte) {
	self.Data = v
}

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

	encoder.PutUint16(uint16(self.Code))
	encoder.Write(self.Data)
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeBadInstructionErrorMsg(parent *ErrorMsg, decoder *goloxi.Decoder) (*BadInstructionErrorMsg, error) {
	_badinstructionerrormsg := &BadInstructionErrorMsg{ErrorMsg: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("BadInstructionErrorMsg packet too short: %d < 2", decoder.Length())
	}
	_badinstructionerrormsg.Code = BadInstructionCode(decoder.ReadUint16())
	_badinstructionerrormsg.Data = decoder.Read(int(decoder.Length()))
	return _badinstructionerrormsg, nil
}

func NewBadInstructionErrorMsg() *BadInstructionErrorMsg {
	obj := &BadInstructionErrorMsg{
		ErrorMsg: NewErrorMsg(3),
	}
	return obj
}

type BadMatchErrorMsg struct {
	*ErrorMsg
	Code BadMatchCode
	Data []byte
}

type IBadMatchErrorMsg interface {
	IErrorMsg
	GetCode() BadMatchCode
	GetData() []byte
}

func (self *BadMatchErrorMsg) GetCode() BadMatchCode {
	return self.Code
}

func (self *BadMatchErrorMsg) SetCode(v BadMatchCode) {
	self.Code = v
}

func (self *BadMatchErrorMsg) GetData() []byte {
	return self.Data
}

func (self *BadMatchErrorMsg) SetData(v []byte) {
	self.Data = v
}

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

	encoder.PutUint16(uint16(self.Code))
	encoder.Write(self.Data)
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeBadMatchErrorMsg(parent *ErrorMsg, decoder *goloxi.Decoder) (*BadMatchErrorMsg, error) {
	_badmatcherrormsg := &BadMatchErrorMsg{ErrorMsg: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("BadMatchErrorMsg packet too short: %d < 2", decoder.Length())
	}
	_badmatcherrormsg.Code = BadMatchCode(decoder.ReadUint16())
	_badmatcherrormsg.Data = decoder.Read(int(decoder.Length()))
	return _badmatcherrormsg, nil
}

func NewBadMatchErrorMsg() *BadMatchErrorMsg {
	obj := &BadMatchErrorMsg{
		ErrorMsg: NewErrorMsg(4),
	}
	return obj
}

type BadPropertyErrorMsg struct {
	*ErrorMsg
	Code BadPropertyCode
	Data []byte
}

type IBadPropertyErrorMsg interface {
	IErrorMsg
	GetCode() BadPropertyCode
	GetData() []byte
}

func (self *BadPropertyErrorMsg) GetCode() BadPropertyCode {
	return self.Code
}

func (self *BadPropertyErrorMsg) SetCode(v BadPropertyCode) {
	self.Code = v
}

func (self *BadPropertyErrorMsg) GetData() []byte {
	return self.Data
}

func (self *BadPropertyErrorMsg) SetData(v []byte) {
	self.Data = v
}

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

	encoder.PutUint16(uint16(self.Code))
	encoder.Write(self.Data)
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeBadPropertyErrorMsg(parent *ErrorMsg, decoder *goloxi.Decoder) (*BadPropertyErrorMsg, error) {
	_badpropertyerrormsg := &BadPropertyErrorMsg{ErrorMsg: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("BadPropertyErrorMsg packet too short: %d < 2", decoder.Length())
	}
	_badpropertyerrormsg.Code = BadPropertyCode(decoder.ReadUint16())
	_badpropertyerrormsg.Data = decoder.Read(int(decoder.Length()))
	return _badpropertyerrormsg, nil
}

func NewBadPropertyErrorMsg() *BadPropertyErrorMsg {
	obj := &BadPropertyErrorMsg{
		ErrorMsg: NewErrorMsg(14),
	}
	return obj
}

type BadRequestErrorMsg struct {
	*ErrorMsg
	Code BadRequestCode
	Data []byte
}

type IBadRequestErrorMsg interface {
	IErrorMsg
	GetCode() BadRequestCode
	GetData() []byte
}

func (self *BadRequestErrorMsg) GetCode() BadRequestCode {
	return self.Code
}

func (self *BadRequestErrorMsg) SetCode(v BadRequestCode) {
	self.Code = v
}

func (self *BadRequestErrorMsg) GetData() []byte {
	return self.Data
}

func (self *BadRequestErrorMsg) SetData(v []byte) {
	self.Data = v
}

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

	encoder.PutUint16(uint16(self.Code))
	encoder.Write(self.Data)
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeBadRequestErrorMsg(parent *ErrorMsg, decoder *goloxi.Decoder) (*BadRequestErrorMsg, error) {
	_badrequesterrormsg := &BadRequestErrorMsg{ErrorMsg: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("BadRequestErrorMsg packet too short: %d < 2", decoder.Length())
	}
	_badrequesterrormsg.Code = BadRequestCode(decoder.ReadUint16())
	_badrequesterrormsg.Data = decoder.Read(int(decoder.Length()))
	return _badrequesterrormsg, nil
}

func NewBadRequestErrorMsg() *BadRequestErrorMsg {
	obj := &BadRequestErrorMsg{
		ErrorMsg: NewErrorMsg(1),
	}
	return obj
}

type BarrierReply struct {
	*Header
}

type IBarrierReply interface {
	IHeader
}

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

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

	return nil
}

func DecodeBarrierReply(parent *Header, decoder *goloxi.Decoder) (*BarrierReply, error) {
	_barrierreply := &BarrierReply{Header: parent}
	return _barrierreply, nil
}

func NewBarrierReply() *BarrierReply {
	obj := &BarrierReply{
		Header: NewHeader(21),
	}
	return obj
}

type BarrierRequest struct {
	*Header
}

type IBarrierRequest interface {
	IHeader
}

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

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

	return nil
}

func DecodeBarrierRequest(parent *Header, decoder *goloxi.Decoder) (*BarrierRequest, error) {
	_barrierrequest := &BarrierRequest{Header: parent}
	return _barrierrequest, nil
}

func NewBarrierRequest() *BarrierRequest {
	obj := &BarrierRequest{
		Header: NewHeader(20),
	}
	return obj
}

type Experimenter struct {
	*Header
	Experimenter uint32
	Subtype      uint32
}

type IExperimenter interface {
	IHeader
	GetExperimenter() uint32
	GetSubtype() uint32
}

func (self *Experimenter) GetExperimenter() uint32 {
	return self.Experimenter
}

func (self *Experimenter) SetExperimenter(v uint32) {
	self.Experimenter = v
}

func (self *Experimenter) GetSubtype() uint32 {
	return self.Subtype
}

func (self *Experimenter) SetSubtype(v uint32) {
	self.Subtype = v
}

func (self *Experimenter) Serialize(encoder *goloxi.Encoder) error {
	if err := self.Header.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint32(uint32(self.Experimenter))
	encoder.PutUint32(uint32(self.Subtype))

	return nil
}

func DecodeExperimenter(parent *Header, decoder *goloxi.Decoder) (IExperimenter, error) {
	_experimenter := &Experimenter{Header: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("Experimenter packet too short: %d < 8", decoder.Length())
	}
	_experimenter.Experimenter = uint32(decoder.ReadUint32())
	_experimenter.Subtype = uint32(decoder.ReadUint32())

	switch _experimenter.Experimenter {
	case 8992:
		return DecodeNiciraHeader(_experimenter, decoder)
	case 6035143:
		return DecodeBsnHeader(_experimenter, decoder)
	default:
		return nil, fmt.Errorf("Invalid type '%d' for 'Experimenter'", _experimenter.Experimenter)
	}
}

func NewExperimenter(_experimenter uint32) *Experimenter {
	obj := &Experimenter{
		Header: NewHeader(4),
	}
	obj.Experimenter = _experimenter
	return obj
}

type BsnHeader struct {
	*Experimenter
}

type IBsnHeader interface {
	IExperimenter
}

func (self *BsnHeader) Serialize(encoder *goloxi.Encoder) error {
	if err := self.Experimenter.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeBsnHeader(parent *Experimenter, decoder *goloxi.Decoder) (IBsnHeader, error) {
	_bsnheader := &BsnHeader{Experimenter: parent}

	switch _bsnheader.Subtype {
	case 3:
		return DecodeBsnSetMirroring(_bsnheader, decoder)
	case 4:
		return DecodeBsnGetMirroringRequest(_bsnheader, decoder)
	case 5:
		return DecodeBsnGetMirroringReply(_bsnheader, decoder)
	case 9:
		return DecodeBsnGetInterfacesRequest(_bsnheader, decoder)
	case 10:
		return DecodeBsnGetInterfacesReply(_bsnheader, decoder)
	case 11:
		return DecodeBsnSetPktinSuppressionRequest(_bsnheader, decoder)
	case 15:
		return DecodeBsnVirtualPortCreateRequest(_bsnheader, decoder)
	case 16:
		return DecodeBsnVirtualPortCreateReply(_bsnheader, decoder)
	case 17:
		return DecodeBsnVirtualPortRemoveRequest(_bsnheader, decoder)
	case 18:
		return DecodeBsnBwEnableSetRequest(_bsnheader, decoder)
	case 19:
		return DecodeBsnBwEnableGetRequest(_bsnheader, decoder)
	case 20:
		return DecodeBsnBwEnableGetReply(_bsnheader, decoder)
	case 21:
		return DecodeBsnBwClearDataRequest(_bsnheader, decoder)
	case 22:
		return DecodeBsnBwClearDataReply(_bsnheader, decoder)
	case 23:
		return DecodeBsnBwEnableSetReply(_bsnheader, decoder)
	case 25:
		return DecodeBsnSetPktinSuppressionReply(_bsnheader, decoder)
	case 26:
		return DecodeBsnVirtualPortRemoveReply(_bsnheader, decoder)
	case 31:
		return DecodeBsnPduTxRequest(_bsnheader, decoder)
	case 32:
		return DecodeBsnPduTxReply(_bsnheader, decoder)
	case 33:
		return DecodeBsnPduRxRequest(_bsnheader, decoder)
	case 34:
		return DecodeBsnPduRxReply(_bsnheader, decoder)
	case 35:
		return DecodeBsnPduRxTimeout(_bsnheader, decoder)
	case 36:
		return DecodeBsnFlowIdleEnableSetRequest(_bsnheader, decoder)
	case 37:
		return DecodeBsnFlowIdleEnableSetReply(_bsnheader, decoder)
	case 38:
		return DecodeBsnFlowIdleEnableGetRequest(_bsnheader, decoder)
	case 39:
		return DecodeBsnFlowIdleEnableGetReply(_bsnheader, decoder)
	case 40:
		return DecodeBsnFlowIdle(_bsnheader, decoder)
	case 41:
		return DecodeBsnSetLacpRequest(_bsnheader, decoder)
	case 42:
		return DecodeBsnSetLacpReply(_bsnheader, decoder)
	case 43:
		return DecodeBsnLacpConvergenceNotif(_bsnheader, decoder)
	case 44:
		return DecodeBsnTimeRequest(_bsnheader, decoder)
	case 45:
		return DecodeBsnTimeReply(_bsnheader, decoder)
	case 46:
		return DecodeBsnGentableEntryAdd(_bsnheader, decoder)
	case 47:
		return DecodeBsnGentableEntryDelete(_bsnheader, decoder)
	case 48:
		return DecodeBsnGentableClearRequest(_bsnheader, decoder)
	case 49:
		return DecodeBsnGentableClearReply(_bsnheader, decoder)
	case 50:
		return DecodeBsnGentableSetBucketsSize(_bsnheader, decoder)
	case 51:
		return DecodeBsnGetSwitchPipelineRequest(_bsnheader, decoder)
	case 52:
		return DecodeBsnGetSwitchPipelineReply(_bsnheader, decoder)
	case 53:
		return DecodeBsnSetSwitchPipelineRequest(_bsnheader, decoder)
	case 54:
		return DecodeBsnSetSwitchPipelineReply(_bsnheader, decoder)
	case 56:
		return DecodeBsnControllerConnectionsRequest(_bsnheader, decoder)
	case 57:
		return DecodeBsnControllerConnectionsReply(_bsnheader, decoder)
	case 58:
		return DecodeBsnSetAuxCxnsRequest(_bsnheader, decoder)
	case 59:
		return DecodeBsnSetAuxCxnsReply(_bsnheader, decoder)
	case 60:
		return DecodeBsnArpIdle(_bsnheader, decoder)
	case 61:
		return DecodeBsnTableSetBucketsSize(_bsnheader, decoder)
	case 63:
		return DecodeBsnLog(_bsnheader, decoder)
	case 64:
		return DecodeBsnLuaUpload(_bsnheader, decoder)
	case 65:
		return DecodeBsnLuaCommandRequest(_bsnheader, decoder)
	case 66:
		return DecodeBsnLuaCommandReply(_bsnheader, decoder)
	case 67:
		return DecodeBsnLuaNotification(_bsnheader, decoder)
	case 68:
		return DecodeBsnGenericAsync(_bsnheader, decoder)
	case 69:
		return DecodeBsnTakeover(_bsnheader, decoder)
	case 70:
		return DecodeBsnVlanCounterClear(_bsnheader, decoder)
	case 71:
		return DecodeBsnGenericCommand(_bsnheader, decoder)
	default:
		return nil, fmt.Errorf("Invalid type '%d' for 'BsnHeader'", _bsnheader.Subtype)
	}
}

func NewBsnHeader(_subtype uint32) *BsnHeader {
	obj := &BsnHeader{
		Experimenter: NewExperimenter(6035143),
	}
	obj.Subtype = _subtype
	return obj
}

type BsnArpIdle struct {
	*BsnHeader
	VlanVid  uint16
	Ipv4Addr net.IP
}

type IBsnArpIdle interface {
	IBsnHeader
	GetVlanVid() uint16
	GetIpv4Addr() net.IP
}

func (self *BsnArpIdle) GetVlanVid() uint16 {
	return self.VlanVid
}

func (self *BsnArpIdle) SetVlanVid(v uint16) {
	self.VlanVid = v
}

func (self *BsnArpIdle) GetIpv4Addr() net.IP {
	return self.Ipv4Addr
}

func (self *BsnArpIdle) SetIpv4Addr(v net.IP) {
	self.Ipv4Addr = v
}

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

	encoder.PutUint16(uint16(self.VlanVid))
	encoder.Write(bytes.Repeat([]byte{0}, 2))
	encoder.Write(self.Ipv4Addr.To4())
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeBsnArpIdle(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnArpIdle, error) {
	_bsnarpidle := &BsnArpIdle{BsnHeader: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("BsnArpIdle packet too short: %d < 8", decoder.Length())
	}
	_bsnarpidle.VlanVid = uint16(decoder.ReadUint16())
	decoder.Skip(2)
	_bsnarpidle.Ipv4Addr = net.IP(decoder.Read(4))
	return _bsnarpidle, nil
}

func NewBsnArpIdle() *BsnArpIdle {
	obj := &BsnArpIdle{
		BsnHeader: NewBsnHeader(60),
	}
	return obj
}

type ExperimenterErrorMsg struct {
	*ErrorMsg
	Subtype      uint16
	Experimenter uint32
}

type IExperimenterErrorMsg interface {
	IErrorMsg
	GetSubtype() uint16
	GetExperimenter() uint32
}

func (self *ExperimenterErrorMsg) GetSubtype() uint16 {
	return self.Subtype
}

func (self *ExperimenterErrorMsg) SetSubtype(v uint16) {
	self.Subtype = v
}

func (self *ExperimenterErrorMsg) GetExperimenter() uint32 {
	return self.Experimenter
}

func (self *ExperimenterErrorMsg) SetExperimenter(v uint32) {
	self.Experimenter = v
}

func (self *ExperimenterErrorMsg) Serialize(encoder *goloxi.Encoder) error {
	if err := self.ErrorMsg.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint16(uint16(self.Subtype))
	encoder.PutUint32(uint32(self.Experimenter))

	return nil
}

func DecodeExperimenterErrorMsg(parent *ErrorMsg, decoder *goloxi.Decoder) (IExperimenterErrorMsg, error) {
	_experimentererrormsg := &ExperimenterErrorMsg{ErrorMsg: parent}
	if decoder.Length() < 6 {
		return nil, fmt.Errorf("ExperimenterErrorMsg packet too short: %d < 6", decoder.Length())
	}
	_experimentererrormsg.Subtype = uint16(decoder.ReadUint16())
	_experimentererrormsg.Experimenter = uint32(decoder.ReadUint32())

	switch _experimentererrormsg.Experimenter {
	case 6035143:
		return DecodeBsnBaseError(_experimentererrormsg, decoder)
	default:
		return nil, fmt.Errorf("Invalid type '%d' for 'ExperimenterErrorMsg'", _experimentererrormsg.Experimenter)
	}
}

func NewExperimenterErrorMsg(_experimenter uint32) *ExperimenterErrorMsg {
	obj := &ExperimenterErrorMsg{
		ErrorMsg: NewErrorMsg(65535),
	}
	obj.Experimenter = _experimenter
	return obj
}

type BsnBaseError struct {
	*ExperimenterErrorMsg
	ErrMsg string
}

type IBsnBaseError interface {
	IExperimenterErrorMsg
	GetErrMsg() string
}

func (self *BsnBaseError) GetErrMsg() string {
	return self.ErrMsg
}

func (self *BsnBaseError) SetErrMsg(v string) {
	self.ErrMsg = v
}

func (self *BsnBaseError) Serialize(encoder *goloxi.Encoder) error {
	if err := self.ExperimenterErrorMsg.Serialize(encoder); err != nil {
		return err
	}

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

	return nil
}

func DecodeBsnBaseError(parent *ExperimenterErrorMsg, decoder *goloxi.Decoder) (IBsnBaseError, error) {
	_bsnbaseerror := &BsnBaseError{ExperimenterErrorMsg: parent}
	if decoder.Length() < 256 {
		return nil, fmt.Errorf("BsnBaseError packet too short: %d < 256", decoder.Length())
	}
	_bsnbaseerror.ErrMsg = string(bytes.Trim(decoder.Read(256), "\x00"))

	switch _bsnbaseerror.Subtype {
	case 1:
		return DecodeBsnError(_bsnbaseerror, decoder)
	case 2:
		return DecodeBsnGentableError(_bsnbaseerror, decoder)
	default:
		return nil, fmt.Errorf("Invalid type '%d' for 'BsnBaseError'", _bsnbaseerror.Subtype)
	}
}

func NewBsnBaseError(_subtype uint16) *BsnBaseError {
	obj := &BsnBaseError{
		ExperimenterErrorMsg: NewExperimenterErrorMsg(6035143),
	}
	obj.Subtype = _subtype
	return obj
}

type BsnBwClearDataReply struct {
	*BsnHeader
	Status uint32
}

type IBsnBwClearDataReply interface {
	IBsnHeader
	GetStatus() uint32
}

func (self *BsnBwClearDataReply) GetStatus() uint32 {
	return self.Status
}

func (self *BsnBwClearDataReply) SetStatus(v uint32) {
	self.Status = v
}

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

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

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

	return nil
}

func DecodeBsnBwClearDataReply(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnBwClearDataReply, error) {
	_bsnbwcleardatareply := &BsnBwClearDataReply{BsnHeader: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("BsnBwClearDataReply packet too short: %d < 4", decoder.Length())
	}
	_bsnbwcleardatareply.Status = uint32(decoder.ReadUint32())
	return _bsnbwcleardatareply, nil
}

func NewBsnBwClearDataReply() *BsnBwClearDataReply {
	obj := &BsnBwClearDataReply{
		BsnHeader: NewBsnHeader(22),
	}
	return obj
}

type BsnBwClearDataRequest struct {
	*BsnHeader
}

type IBsnBwClearDataRequest interface {
	IBsnHeader
}

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

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

	return nil
}

func DecodeBsnBwClearDataRequest(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnBwClearDataRequest, error) {
	_bsnbwcleardatarequest := &BsnBwClearDataRequest{BsnHeader: parent}
	return _bsnbwcleardatarequest, nil
}

func NewBsnBwClearDataRequest() *BsnBwClearDataRequest {
	obj := &BsnBwClearDataRequest{
		BsnHeader: NewBsnHeader(21),
	}
	return obj
}

type BsnBwEnableGetReply struct {
	*BsnHeader
	Enabled uint32
}

type IBsnBwEnableGetReply interface {
	IBsnHeader
	GetEnabled() uint32
}

func (self *BsnBwEnableGetReply) GetEnabled() uint32 {
	return self.Enabled
}

func (self *BsnBwEnableGetReply) SetEnabled(v uint32) {
	self.Enabled = v
}

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

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

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

	return nil
}

func DecodeBsnBwEnableGetReply(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnBwEnableGetReply, error) {
	_bsnbwenablegetreply := &BsnBwEnableGetReply{BsnHeader: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("BsnBwEnableGetReply packet too short: %d < 4", decoder.Length())
	}
	_bsnbwenablegetreply.Enabled = uint32(decoder.ReadUint32())
	return _bsnbwenablegetreply, nil
}

func NewBsnBwEnableGetReply() *BsnBwEnableGetReply {
	obj := &BsnBwEnableGetReply{
		BsnHeader: NewBsnHeader(20),
	}
	return obj
}

type BsnBwEnableGetRequest struct {
	*BsnHeader
}

type IBsnBwEnableGetRequest interface {
	IBsnHeader
}

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

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

	return nil
}

func DecodeBsnBwEnableGetRequest(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnBwEnableGetRequest, error) {
	_bsnbwenablegetrequest := &BsnBwEnableGetRequest{BsnHeader: parent}
	return _bsnbwenablegetrequest, nil
}

func NewBsnBwEnableGetRequest() *BsnBwEnableGetRequest {
	obj := &BsnBwEnableGetRequest{
		BsnHeader: NewBsnHeader(19),
	}
	return obj
}

type BsnBwEnableSetReply struct {
	*BsnHeader
	Enable uint32
	Status uint32
}

type IBsnBwEnableSetReply interface {
	IBsnHeader
	GetEnable() uint32
	GetStatus() uint32
}

func (self *BsnBwEnableSetReply) GetEnable() uint32 {
	return self.Enable
}

func (self *BsnBwEnableSetReply) SetEnable(v uint32) {
	self.Enable = v
}

func (self *BsnBwEnableSetReply) GetStatus() uint32 {
	return self.Status
}

func (self *BsnBwEnableSetReply) SetStatus(v uint32) {
	self.Status = v
}

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

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

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

	return nil
}

func DecodeBsnBwEnableSetReply(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnBwEnableSetReply, error) {
	_bsnbwenablesetreply := &BsnBwEnableSetReply{BsnHeader: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("BsnBwEnableSetReply packet too short: %d < 8", decoder.Length())
	}
	_bsnbwenablesetreply.Enable = uint32(decoder.ReadUint32())
	_bsnbwenablesetreply.Status = uint32(decoder.ReadUint32())
	return _bsnbwenablesetreply, nil
}

func NewBsnBwEnableSetReply() *BsnBwEnableSetReply {
	obj := &BsnBwEnableSetReply{
		BsnHeader: NewBsnHeader(23),
	}
	return obj
}

type BsnBwEnableSetRequest struct {
	*BsnHeader
	Enable uint32
}

type IBsnBwEnableSetRequest interface {
	IBsnHeader
	GetEnable() uint32
}

func (self *BsnBwEnableSetRequest) GetEnable() uint32 {
	return self.Enable
}

func (self *BsnBwEnableSetRequest) SetEnable(v uint32) {
	self.Enable = v
}

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

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

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

	return nil
}

func DecodeBsnBwEnableSetRequest(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnBwEnableSetRequest, error) {
	_bsnbwenablesetrequest := &BsnBwEnableSetRequest{BsnHeader: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("BsnBwEnableSetRequest packet too short: %d < 4", decoder.Length())
	}
	_bsnbwenablesetrequest.Enable = uint32(decoder.ReadUint32())
	return _bsnbwenablesetrequest, nil
}

func NewBsnBwEnableSetRequest() *BsnBwEnableSetRequest {
	obj := &BsnBwEnableSetRequest{
		BsnHeader: NewBsnHeader(18),
	}
	return obj
}

type BsnControllerConnectionsReply struct {
	*BsnHeader
	Connections []*BsnControllerConnection
}

type IBsnControllerConnectionsReply interface {
	IBsnHeader
	GetConnections() []*BsnControllerConnection
}

func (self *BsnControllerConnectionsReply) GetConnections() []*BsnControllerConnection {
	return self.Connections
}

func (self *BsnControllerConnectionsReply) SetConnections(v []*BsnControllerConnection) {
	self.Connections = v
}

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

	for _, obj := range self.Connections {
		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 DecodeBsnControllerConnectionsReply(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnControllerConnectionsReply, error) {
	_bsncontrollerconnectionsreply := &BsnControllerConnectionsReply{BsnHeader: parent}

	for decoder.Length() >= 264 {
		item, err := DecodeBsnControllerConnection(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_bsncontrollerconnectionsreply.Connections = append(_bsncontrollerconnectionsreply.Connections, item)
		}
	}
	return _bsncontrollerconnectionsreply, nil
}

func NewBsnControllerConnectionsReply() *BsnControllerConnectionsReply {
	obj := &BsnControllerConnectionsReply{
		BsnHeader: NewBsnHeader(57),
	}
	return obj
}

type BsnControllerConnectionsRequest struct {
	*BsnHeader
}

type IBsnControllerConnectionsRequest interface {
	IBsnHeader
}

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

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

	return nil
}

func DecodeBsnControllerConnectionsRequest(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnControllerConnectionsRequest, error) {
	_bsncontrollerconnectionsrequest := &BsnControllerConnectionsRequest{BsnHeader: parent}
	return _bsncontrollerconnectionsrequest, nil
}

func NewBsnControllerConnectionsRequest() *BsnControllerConnectionsRequest {
	obj := &BsnControllerConnectionsRequest{
		BsnHeader: NewBsnHeader(56),
	}
	return obj
}

type ExperimenterStatsReply struct {
	*StatsReply
	Experimenter uint32
	Subtype      uint32
}

type IExperimenterStatsReply interface {
	IStatsReply
	GetExperimenter() uint32
	GetSubtype() uint32
}

func (self *ExperimenterStatsReply) GetExperimenter() uint32 {
	return self.Experimenter
}

func (self *ExperimenterStatsReply) SetExperimenter(v uint32) {
	self.Experimenter = v
}

func (self *ExperimenterStatsReply) GetSubtype() uint32 {
	return self.Subtype
}

func (self *ExperimenterStatsReply) SetSubtype(v uint32) {
	self.Subtype = v
}

func (self *ExperimenterStatsReply) Serialize(encoder *goloxi.Encoder) error {
	if err := self.StatsReply.Serialize(encoder); err != nil {
		return err
	}

	encoder.Write(bytes.Repeat([]byte{0}, 4))
	encoder.PutUint32(uint32(self.Experimenter))
	encoder.PutUint32(uint32(self.Subtype))

	return nil
}

func DecodeExperimenterStatsReply(parent *StatsReply, decoder *goloxi.Decoder) (IExperimenterStatsReply, error) {
	_experimenterstatsreply := &ExperimenterStatsReply{StatsReply: parent}
	if decoder.Length() < 12 {
		return nil, fmt.Errorf("ExperimenterStatsReply packet too short: %d < 12", decoder.Length())
	}
	decoder.Skip(4)
	_experimenterstatsreply.Experimenter = uint32(decoder.ReadUint32())
	_experimenterstatsreply.Subtype = uint32(decoder.ReadUint32())

	switch _experimenterstatsreply.Experimenter {
	case 8992:
		return DecodeNiciraStatsReply(_experimenterstatsreply, decoder)
	case 6035143:
		return DecodeBsnStatsReply(_experimenterstatsreply, decoder)
	default:
		return nil, fmt.Errorf("Invalid type '%d' for 'ExperimenterStatsReply'", _experimenterstatsreply.Experimenter)
	}
}

func NewExperimenterStatsReply(_experimenter uint32) *ExperimenterStatsReply {
	obj := &ExperimenterStatsReply{
		StatsReply: NewStatsReply(65535),
	}
	obj.Experimenter = _experimenter
	return obj
}

type BsnStatsReply struct {
	*ExperimenterStatsReply
}

type IBsnStatsReply interface {
	IExperimenterStatsReply
}

func (self *BsnStatsReply) Serialize(encoder *goloxi.Encoder) error {
	if err := self.ExperimenterStatsReply.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeBsnStatsReply(parent *ExperimenterStatsReply, decoder *goloxi.Decoder) (IBsnStatsReply, error) {
	_bsnstatsreply := &BsnStatsReply{ExperimenterStatsReply: parent}

	switch _bsnstatsreply.Subtype {
	case 1:
		return DecodeBsnLacpStatsReply(_bsnstatsreply, decoder)
	case 2:
		return DecodeBsnGentableEntryDescStatsReply(_bsnstatsreply, decoder)
	case 3:
		return DecodeBsnGentableEntryStatsReply(_bsnstatsreply, decoder)
	case 4:
		return DecodeBsnGentableDescStatsReply(_bsnstatsreply, decoder)
	case 5:
		return DecodeBsnGentableBucketStatsReply(_bsnstatsreply, decoder)
	case 6:
		return DecodeBsnSwitchPipelineStatsReply(_bsnstatsreply, decoder)
	case 7:
		return DecodeBsnGentableStatsReply(_bsnstatsreply, decoder)
	case 8:
		return DecodeBsnPortCounterStatsReply(_bsnstatsreply, decoder)
	case 9:
		return DecodeBsnVlanCounterStatsReply(_bsnstatsreply, decoder)
	case 10:
		return DecodeBsnFlowChecksumBucketStatsReply(_bsnstatsreply, decoder)
	case 11:
		return DecodeBsnTableChecksumStatsReply(_bsnstatsreply, decoder)
	case 12:
		return DecodeBsnDebugCounterStatsReply(_bsnstatsreply, decoder)
	case 13:
		return DecodeBsnDebugCounterDescStatsReply(_bsnstatsreply, decoder)
	case 14:
		return DecodeBsnImageDescStatsReply(_bsnstatsreply, decoder)
	case 15:
		return DecodeBsnVrfCounterStatsReply(_bsnstatsreply, decoder)
	case 16:
		return DecodeBsnGenericStatsReply(_bsnstatsreply, decoder)
	default:
		return nil, fmt.Errorf("Invalid type '%d' for 'BsnStatsReply'", _bsnstatsreply.Subtype)
	}
}

func NewBsnStatsReply(_subtype uint32) *BsnStatsReply {
	obj := &BsnStatsReply{
		ExperimenterStatsReply: NewExperimenterStatsReply(6035143),
	}
	obj.Subtype = _subtype
	return obj
}

type BsnDebugCounterDescStatsReply struct {
	*BsnStatsReply
	Entries []*BsnDebugCounterDescStatsEntry
}

type IBsnDebugCounterDescStatsReply interface {
	IBsnStatsReply
	GetEntries() []*BsnDebugCounterDescStatsEntry
}

func (self *BsnDebugCounterDescStatsReply) GetEntries() []*BsnDebugCounterDescStatsEntry {
	return self.Entries
}

func (self *BsnDebugCounterDescStatsReply) SetEntries(v []*BsnDebugCounterDescStatsEntry) {
	self.Entries = v
}

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

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

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

	return nil
}

func DecodeBsnDebugCounterDescStatsReply(parent *BsnStatsReply, decoder *goloxi.Decoder) (*BsnDebugCounterDescStatsReply, error) {
	_bsndebugcounterdescstatsreply := &BsnDebugCounterDescStatsReply{BsnStatsReply: parent}

	for decoder.Length() >= 328 {
		item, err := DecodeBsnDebugCounterDescStatsEntry(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_bsndebugcounterdescstatsreply.Entries = append(_bsndebugcounterdescstatsreply.Entries, item)
		}
	}
	return _bsndebugcounterdescstatsreply, nil
}

func NewBsnDebugCounterDescStatsReply() *BsnDebugCounterDescStatsReply {
	obj := &BsnDebugCounterDescStatsReply{
		BsnStatsReply: NewBsnStatsReply(13),
	}
	return obj
}

type ExperimenterStatsRequest struct {
	*StatsRequest
	Experimenter uint32
	Subtype      uint32
}

type IExperimenterStatsRequest interface {
	IStatsRequest
	GetExperimenter() uint32
	GetSubtype() uint32
}

func (self *ExperimenterStatsRequest) GetExperimenter() uint32 {
	return self.Experimenter
}

func (self *ExperimenterStatsRequest) SetExperimenter(v uint32) {
	self.Experimenter = v
}

func (self *ExperimenterStatsRequest) GetSubtype() uint32 {
	return self.Subtype
}

func (self *ExperimenterStatsRequest) SetSubtype(v uint32) {
	self.Subtype = v
}

func (self *ExperimenterStatsRequest) Serialize(encoder *goloxi.Encoder) error {
	if err := self.StatsRequest.Serialize(encoder); err != nil {
		return err
	}

	encoder.Write(bytes.Repeat([]byte{0}, 4))
	encoder.PutUint32(uint32(self.Experimenter))
	encoder.PutUint32(uint32(self.Subtype))

	return nil
}

func DecodeExperimenterStatsRequest(parent *StatsRequest, decoder *goloxi.Decoder) (IExperimenterStatsRequest, error) {
	_experimenterstatsrequest := &ExperimenterStatsRequest{StatsRequest: parent}
	if decoder.Length() < 12 {
		return nil, fmt.Errorf("ExperimenterStatsRequest packet too short: %d < 12", decoder.Length())
	}
	decoder.Skip(4)
	_experimenterstatsrequest.Experimenter = uint32(decoder.ReadUint32())
	_experimenterstatsrequest.Subtype = uint32(decoder.ReadUint32())

	switch _experimenterstatsrequest.Experimenter {
	case 8992:
		return DecodeNiciraFlowStatsRequest(_experimenterstatsrequest, decoder)
	case 6035143:
		return DecodeBsnStatsRequest(_experimenterstatsrequest, decoder)
	default:
		return nil, fmt.Errorf("Invalid type '%d' for 'ExperimenterStatsRequest'", _experimenterstatsrequest.Experimenter)
	}
}

func NewExperimenterStatsRequest(_experimenter uint32) *ExperimenterStatsRequest {
	obj := &ExperimenterStatsRequest{
		StatsRequest: NewStatsRequest(65535),
	}
	obj.Experimenter = _experimenter
	return obj
}

type BsnStatsRequest struct {
	*ExperimenterStatsRequest
}

type IBsnStatsRequest interface {
	IExperimenterStatsRequest
}

func (self *BsnStatsRequest) Serialize(encoder *goloxi.Encoder) error {
	if err := self.ExperimenterStatsRequest.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeBsnStatsRequest(parent *ExperimenterStatsRequest, decoder *goloxi.Decoder) (IBsnStatsRequest, error) {
	_bsnstatsrequest := &BsnStatsRequest{ExperimenterStatsRequest: parent}

	switch _bsnstatsrequest.Subtype {
	case 1:
		return DecodeBsnLacpStatsRequest(_bsnstatsrequest, decoder)
	case 2:
		return DecodeBsnGentableEntryDescStatsRequest(_bsnstatsrequest, decoder)
	case 3:
		return DecodeBsnGentableEntryStatsRequest(_bsnstatsrequest, decoder)
	case 4:
		return DecodeBsnGentableDescStatsRequest(_bsnstatsrequest, decoder)
	case 5:
		return DecodeBsnGentableBucketStatsRequest(_bsnstatsrequest, decoder)
	case 6:
		return DecodeBsnSwitchPipelineStatsRequest(_bsnstatsrequest, decoder)
	case 7:
		return DecodeBsnGentableStatsRequest(_bsnstatsrequest, decoder)
	case 8:
		return DecodeBsnPortCounterStatsRequest(_bsnstatsrequest, decoder)
	case 9:
		return DecodeBsnVlanCounterStatsRequest(_bsnstatsrequest, decoder)
	case 10:
		return DecodeBsnFlowChecksumBucketStatsRequest(_bsnstatsrequest, decoder)
	case 11:
		return DecodeBsnTableChecksumStatsRequest(_bsnstatsrequest, decoder)
	case 12:
		return DecodeBsnDebugCounterStatsRequest(_bsnstatsrequest, decoder)
	case 13:
		return DecodeBsnDebugCounterDescStatsRequest(_bsnstatsrequest, decoder)
	case 14:
		return DecodeBsnImageDescStatsRequest(_bsnstatsrequest, decoder)
	case 15:
		return DecodeBsnVrfCounterStatsRequest(_bsnstatsrequest, decoder)
	case 16:
		return DecodeBsnGenericStatsRequest(_bsnstatsrequest, decoder)
	default:
		return nil, fmt.Errorf("Invalid type '%d' for 'BsnStatsRequest'", _bsnstatsrequest.Subtype)
	}
}

func NewBsnStatsRequest(_subtype uint32) *BsnStatsRequest {
	obj := &BsnStatsRequest{
		ExperimenterStatsRequest: NewExperimenterStatsRequest(6035143),
	}
	obj.Subtype = _subtype
	return obj
}

type BsnDebugCounterDescStatsRequest struct {
	*BsnStatsRequest
}

type IBsnDebugCounterDescStatsRequest interface {
	IBsnStatsRequest
}

func (self *BsnDebugCounterDescStatsRequest) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnStatsRequest.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 DecodeBsnDebugCounterDescStatsRequest(parent *BsnStatsRequest, decoder *goloxi.Decoder) (*BsnDebugCounterDescStatsRequest, error) {
	_bsndebugcounterdescstatsrequest := &BsnDebugCounterDescStatsRequest{BsnStatsRequest: parent}
	return _bsndebugcounterdescstatsrequest, nil
}

func NewBsnDebugCounterDescStatsRequest() *BsnDebugCounterDescStatsRequest {
	obj := &BsnDebugCounterDescStatsRequest{
		BsnStatsRequest: NewBsnStatsRequest(13),
	}
	return obj
}

type BsnDebugCounterStatsReply struct {
	*BsnStatsReply
	Entries []*BsnDebugCounterStatsEntry
}

type IBsnDebugCounterStatsReply interface {
	IBsnStatsReply
	GetEntries() []*BsnDebugCounterStatsEntry
}

func (self *BsnDebugCounterStatsReply) GetEntries() []*BsnDebugCounterStatsEntry {
	return self.Entries
}

func (self *BsnDebugCounterStatsReply) SetEntries(v []*BsnDebugCounterStatsEntry) {
	self.Entries = v
}

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

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

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

	return nil
}

func DecodeBsnDebugCounterStatsReply(parent *BsnStatsReply, decoder *goloxi.Decoder) (*BsnDebugCounterStatsReply, error) {
	_bsndebugcounterstatsreply := &BsnDebugCounterStatsReply{BsnStatsReply: parent}

	for decoder.Length() >= 16 {
		item, err := DecodeBsnDebugCounterStatsEntry(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_bsndebugcounterstatsreply.Entries = append(_bsndebugcounterstatsreply.Entries, item)
		}
	}
	return _bsndebugcounterstatsreply, nil
}

func NewBsnDebugCounterStatsReply() *BsnDebugCounterStatsReply {
	obj := &BsnDebugCounterStatsReply{
		BsnStatsReply: NewBsnStatsReply(12),
	}
	return obj
}

type BsnDebugCounterStatsRequest struct {
	*BsnStatsRequest
}

type IBsnDebugCounterStatsRequest interface {
	IBsnStatsRequest
}

func (self *BsnDebugCounterStatsRequest) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnStatsRequest.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 DecodeBsnDebugCounterStatsRequest(parent *BsnStatsRequest, decoder *goloxi.Decoder) (*BsnDebugCounterStatsRequest, error) {
	_bsndebugcounterstatsrequest := &BsnDebugCounterStatsRequest{BsnStatsRequest: parent}
	return _bsndebugcounterstatsrequest, nil
}

func NewBsnDebugCounterStatsRequest() *BsnDebugCounterStatsRequest {
	obj := &BsnDebugCounterStatsRequest{
		BsnStatsRequest: NewBsnStatsRequest(12),
	}
	return obj
}

type BsnError struct {
	*BsnBaseError
}

type IBsnError interface {
	IBsnBaseError
}

func (self *BsnError) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnBaseError.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 DecodeBsnError(parent *BsnBaseError, decoder *goloxi.Decoder) (*BsnError, error) {
	_bsnerror := &BsnError{BsnBaseError: parent}
	return _bsnerror, nil
}

func NewBsnError() *BsnError {
	obj := &BsnError{
		BsnBaseError: NewBsnBaseError(1),
	}
	return obj
}

type BsnFlowChecksumBucketStatsReply struct {
	*BsnStatsReply
	Entries []*BsnFlowChecksumBucketStatsEntry
}

type IBsnFlowChecksumBucketStatsReply interface {
	IBsnStatsReply
	GetEntries() []*BsnFlowChecksumBucketStatsEntry
}

func (self *BsnFlowChecksumBucketStatsReply) GetEntries() []*BsnFlowChecksumBucketStatsEntry {
	return self.Entries
}

func (self *BsnFlowChecksumBucketStatsReply) SetEntries(v []*BsnFlowChecksumBucketStatsEntry) {
	self.Entries = v
}

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

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

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

	return nil
}

func DecodeBsnFlowChecksumBucketStatsReply(parent *BsnStatsReply, decoder *goloxi.Decoder) (*BsnFlowChecksumBucketStatsReply, error) {
	_bsnflowchecksumbucketstatsreply := &BsnFlowChecksumBucketStatsReply{BsnStatsReply: parent}

	for decoder.Length() >= 8 {
		item, err := DecodeBsnFlowChecksumBucketStatsEntry(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_bsnflowchecksumbucketstatsreply.Entries = append(_bsnflowchecksumbucketstatsreply.Entries, item)
		}
	}
	return _bsnflowchecksumbucketstatsreply, nil
}

func NewBsnFlowChecksumBucketStatsReply() *BsnFlowChecksumBucketStatsReply {
	obj := &BsnFlowChecksumBucketStatsReply{
		BsnStatsReply: NewBsnStatsReply(10),
	}
	return obj
}

type BsnFlowChecksumBucketStatsRequest struct {
	*BsnStatsRequest
	TableId uint8
}

type IBsnFlowChecksumBucketStatsRequest interface {
	IBsnStatsRequest
	GetTableId() uint8
}

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

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

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

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

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

	return nil
}

func DecodeBsnFlowChecksumBucketStatsRequest(parent *BsnStatsRequest, decoder *goloxi.Decoder) (*BsnFlowChecksumBucketStatsRequest, error) {
	_bsnflowchecksumbucketstatsrequest := &BsnFlowChecksumBucketStatsRequest{BsnStatsRequest: parent}
	if decoder.Length() < 1 {
		return nil, fmt.Errorf("BsnFlowChecksumBucketStatsRequest packet too short: %d < 1", decoder.Length())
	}
	_bsnflowchecksumbucketstatsrequest.TableId = uint8(decoder.ReadByte())
	return _bsnflowchecksumbucketstatsrequest, nil
}

func NewBsnFlowChecksumBucketStatsRequest() *BsnFlowChecksumBucketStatsRequest {
	obj := &BsnFlowChecksumBucketStatsRequest{
		BsnStatsRequest: NewBsnStatsRequest(10),
	}
	return obj
}

type BsnFlowIdle struct {
	*BsnHeader
	Cookie   uint64
	Priority uint16
	TableId  uint8
	Match    Match
}

type IBsnFlowIdle interface {
	IBsnHeader
	GetCookie() uint64
	GetPriority() uint16
	GetTableId() uint8
	GetMatch() Match
}

func (self *BsnFlowIdle) GetCookie() uint64 {
	return self.Cookie
}

func (self *BsnFlowIdle) SetCookie(v uint64) {
	self.Cookie = v
}

func (self *BsnFlowIdle) GetPriority() uint16 {
	return self.Priority
}

func (self *BsnFlowIdle) SetPriority(v uint16) {
	self.Priority = v
}

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

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

func (self *BsnFlowIdle) GetMatch() Match {
	return self.Match
}

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

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

	encoder.PutUint64(uint64(self.Cookie))
	encoder.PutUint16(uint16(self.Priority))
	encoder.PutUint8(uint8(self.TableId))
	encoder.Write(bytes.Repeat([]byte{0}, 5))
	if err := self.Match.Serialize(encoder); err != nil {
		return err
	}

	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeBsnFlowIdle(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnFlowIdle, error) {
	_bsnflowidle := &BsnFlowIdle{BsnHeader: parent}
	if decoder.Length() < 24 {
		return nil, fmt.Errorf("BsnFlowIdle packet too short: %d < 24", decoder.Length())
	}
	_bsnflowidle.Cookie = uint64(decoder.ReadUint64())
	_bsnflowidle.Priority = uint16(decoder.ReadUint16())
	_bsnflowidle.TableId = uint8(decoder.ReadByte())
	decoder.Skip(5)
	if err := _bsnflowidle.Match.Decode(decoder); err != nil {
		return nil, err
	}

	decoder.SkipAlign()
	return _bsnflowidle, nil
}

func NewBsnFlowIdle() *BsnFlowIdle {
	obj := &BsnFlowIdle{
		BsnHeader: NewBsnHeader(40),
	}
	return obj
}

type BsnFlowIdleEnableGetReply struct {
	*BsnHeader
	Enabled uint32
}

type IBsnFlowIdleEnableGetReply interface {
	IBsnHeader
	GetEnabled() uint32
}

func (self *BsnFlowIdleEnableGetReply) GetEnabled() uint32 {
	return self.Enabled
}

func (self *BsnFlowIdleEnableGetReply) SetEnabled(v uint32) {
	self.Enabled = v
}

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

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

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

	return nil
}

func DecodeBsnFlowIdleEnableGetReply(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnFlowIdleEnableGetReply, error) {
	_bsnflowidleenablegetreply := &BsnFlowIdleEnableGetReply{BsnHeader: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("BsnFlowIdleEnableGetReply packet too short: %d < 4", decoder.Length())
	}
	_bsnflowidleenablegetreply.Enabled = uint32(decoder.ReadUint32())
	return _bsnflowidleenablegetreply, nil
}

func NewBsnFlowIdleEnableGetReply() *BsnFlowIdleEnableGetReply {
	obj := &BsnFlowIdleEnableGetReply{
		BsnHeader: NewBsnHeader(39),
	}
	return obj
}

type BsnFlowIdleEnableGetRequest struct {
	*BsnHeader
}

type IBsnFlowIdleEnableGetRequest interface {
	IBsnHeader
}

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

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

	return nil
}

func DecodeBsnFlowIdleEnableGetRequest(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnFlowIdleEnableGetRequest, error) {
	_bsnflowidleenablegetrequest := &BsnFlowIdleEnableGetRequest{BsnHeader: parent}
	return _bsnflowidleenablegetrequest, nil
}

func NewBsnFlowIdleEnableGetRequest() *BsnFlowIdleEnableGetRequest {
	obj := &BsnFlowIdleEnableGetRequest{
		BsnHeader: NewBsnHeader(38),
	}
	return obj
}

type BsnFlowIdleEnableSetReply struct {
	*BsnHeader
	Enable uint32
	Status uint32
}

type IBsnFlowIdleEnableSetReply interface {
	IBsnHeader
	GetEnable() uint32
	GetStatus() uint32
}

func (self *BsnFlowIdleEnableSetReply) GetEnable() uint32 {
	return self.Enable
}

func (self *BsnFlowIdleEnableSetReply) SetEnable(v uint32) {
	self.Enable = v
}

func (self *BsnFlowIdleEnableSetReply) GetStatus() uint32 {
	return self.Status
}

func (self *BsnFlowIdleEnableSetReply) SetStatus(v uint32) {
	self.Status = v
}

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

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

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

	return nil
}

func DecodeBsnFlowIdleEnableSetReply(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnFlowIdleEnableSetReply, error) {
	_bsnflowidleenablesetreply := &BsnFlowIdleEnableSetReply{BsnHeader: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("BsnFlowIdleEnableSetReply packet too short: %d < 8", decoder.Length())
	}
	_bsnflowidleenablesetreply.Enable = uint32(decoder.ReadUint32())
	_bsnflowidleenablesetreply.Status = uint32(decoder.ReadUint32())
	return _bsnflowidleenablesetreply, nil
}

func NewBsnFlowIdleEnableSetReply() *BsnFlowIdleEnableSetReply {
	obj := &BsnFlowIdleEnableSetReply{
		BsnHeader: NewBsnHeader(37),
	}
	return obj
}

type BsnFlowIdleEnableSetRequest struct {
	*BsnHeader
	Enable uint32
}

type IBsnFlowIdleEnableSetRequest interface {
	IBsnHeader
	GetEnable() uint32
}

func (self *BsnFlowIdleEnableSetRequest) GetEnable() uint32 {
	return self.Enable
}

func (self *BsnFlowIdleEnableSetRequest) SetEnable(v uint32) {
	self.Enable = v
}

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

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

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

	return nil
}

func DecodeBsnFlowIdleEnableSetRequest(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnFlowIdleEnableSetRequest, error) {
	_bsnflowidleenablesetrequest := &BsnFlowIdleEnableSetRequest{BsnHeader: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("BsnFlowIdleEnableSetRequest packet too short: %d < 4", decoder.Length())
	}
	_bsnflowidleenablesetrequest.Enable = uint32(decoder.ReadUint32())
	return _bsnflowidleenablesetrequest, nil
}

func NewBsnFlowIdleEnableSetRequest() *BsnFlowIdleEnableSetRequest {
	obj := &BsnFlowIdleEnableSetRequest{
		BsnHeader: NewBsnHeader(36),
	}
	return obj
}

type BsnGenericAsync struct {
	*BsnHeader
	Name string
	Tlvs []IBsnTlv
}

type IBsnGenericAsync interface {
	IBsnHeader
	GetName() string
	GetTlvs() []IBsnTlv
}

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

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

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

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

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

	encoder.Write([]byte(self.Name))
	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+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnGenericAsync(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnGenericAsync, error) {
	_bsngenericasync := &BsnGenericAsync{BsnHeader: parent}
	if decoder.Length() < 64 {
		return nil, fmt.Errorf("BsnGenericAsync packet too short: %d < 64", decoder.Length())
	}
	_bsngenericasync.Name = string(bytes.Trim(decoder.Read(64), "\x00"))

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

func NewBsnGenericAsync() *BsnGenericAsync {
	obj := &BsnGenericAsync{
		BsnHeader: NewBsnHeader(68),
	}
	return obj
}

type BsnGenericCommand struct {
	*BsnHeader
	Name string
	Tlvs []IBsnTlv
}

type IBsnGenericCommand interface {
	IBsnHeader
	GetName() string
	GetTlvs() []IBsnTlv
}

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

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

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

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

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

	encoder.Write([]byte(self.Name))
	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+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnGenericCommand(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnGenericCommand, error) {
	_bsngenericcommand := &BsnGenericCommand{BsnHeader: parent}
	if decoder.Length() < 64 {
		return nil, fmt.Errorf("BsnGenericCommand packet too short: %d < 64", decoder.Length())
	}
	_bsngenericcommand.Name = string(bytes.Trim(decoder.Read(64), "\x00"))

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

func NewBsnGenericCommand() *BsnGenericCommand {
	obj := &BsnGenericCommand{
		BsnHeader: NewBsnHeader(71),
	}
	return obj
}

type BsnGenericStatsReply struct {
	*BsnStatsReply
	Entries []*BsnGenericStatsEntry
}

type IBsnGenericStatsReply interface {
	IBsnStatsReply
	GetEntries() []*BsnGenericStatsEntry
}

func (self *BsnGenericStatsReply) GetEntries() []*BsnGenericStatsEntry {
	return self.Entries
}

func (self *BsnGenericStatsReply) SetEntries(v []*BsnGenericStatsEntry) {
	self.Entries = v
}

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

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

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

	return nil
}

func DecodeBsnGenericStatsReply(parent *BsnStatsReply, decoder *goloxi.Decoder) (*BsnGenericStatsReply, error) {
	_bsngenericstatsreply := &BsnGenericStatsReply{BsnStatsReply: parent}

	for decoder.Length() >= 2 {
		item, err := DecodeBsnGenericStatsEntry(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_bsngenericstatsreply.Entries = append(_bsngenericstatsreply.Entries, item)
		}
	}
	return _bsngenericstatsreply, nil
}

func NewBsnGenericStatsReply() *BsnGenericStatsReply {
	obj := &BsnGenericStatsReply{
		BsnStatsReply: NewBsnStatsReply(16),
	}
	return obj
}

type BsnGenericStatsRequest struct {
	*BsnStatsRequest
	Name string
	Tlvs []IBsnTlv
}

type IBsnGenericStatsRequest interface {
	IBsnStatsRequest
	GetName() string
	GetTlvs() []IBsnTlv
}

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

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

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

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

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

	encoder.Write([]byte(self.Name))
	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+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnGenericStatsRequest(parent *BsnStatsRequest, decoder *goloxi.Decoder) (*BsnGenericStatsRequest, error) {
	_bsngenericstatsrequest := &BsnGenericStatsRequest{BsnStatsRequest: parent}
	if decoder.Length() < 64 {
		return nil, fmt.Errorf("BsnGenericStatsRequest packet too short: %d < 64", decoder.Length())
	}
	_bsngenericstatsrequest.Name = string(bytes.Trim(decoder.Read(64), "\x00"))

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

func NewBsnGenericStatsRequest() *BsnGenericStatsRequest {
	obj := &BsnGenericStatsRequest{
		BsnStatsRequest: NewBsnStatsRequest(16),
	}
	return obj
}

type BsnGentableBucketStatsReply struct {
	*BsnStatsReply
	Entries []*BsnGentableBucketStatsEntry
}

type IBsnGentableBucketStatsReply interface {
	IBsnStatsReply
	GetEntries() []*BsnGentableBucketStatsEntry
}

func (self *BsnGentableBucketStatsReply) GetEntries() []*BsnGentableBucketStatsEntry {
	return self.Entries
}

func (self *BsnGentableBucketStatsReply) SetEntries(v []*BsnGentableBucketStatsEntry) {
	self.Entries = v
}

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

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

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

	return nil
}

func DecodeBsnGentableBucketStatsReply(parent *BsnStatsReply, decoder *goloxi.Decoder) (*BsnGentableBucketStatsReply, error) {
	_bsngentablebucketstatsreply := &BsnGentableBucketStatsReply{BsnStatsReply: parent}

	for decoder.Length() >= 16 {
		item, err := DecodeBsnGentableBucketStatsEntry(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_bsngentablebucketstatsreply.Entries = append(_bsngentablebucketstatsreply.Entries, item)
		}
	}
	return _bsngentablebucketstatsreply, nil
}

func NewBsnGentableBucketStatsReply() *BsnGentableBucketStatsReply {
	obj := &BsnGentableBucketStatsReply{
		BsnStatsReply: NewBsnStatsReply(5),
	}
	return obj
}

type BsnGentableBucketStatsRequest struct {
	*BsnStatsRequest
	TableId uint16
}

type IBsnGentableBucketStatsRequest interface {
	IBsnStatsRequest
	GetTableId() uint16
}

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

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

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

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

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

	return nil
}

func DecodeBsnGentableBucketStatsRequest(parent *BsnStatsRequest, decoder *goloxi.Decoder) (*BsnGentableBucketStatsRequest, error) {
	_bsngentablebucketstatsrequest := &BsnGentableBucketStatsRequest{BsnStatsRequest: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("BsnGentableBucketStatsRequest packet too short: %d < 2", decoder.Length())
	}
	_bsngentablebucketstatsrequest.TableId = uint16(decoder.ReadUint16())
	return _bsngentablebucketstatsrequest, nil
}

func NewBsnGentableBucketStatsRequest() *BsnGentableBucketStatsRequest {
	obj := &BsnGentableBucketStatsRequest{
		BsnStatsRequest: NewBsnStatsRequest(5),
	}
	return obj
}

type BsnGentableClearReply struct {
	*BsnHeader
	TableId      uint16
	DeletedCount uint32
	ErrorCount   uint32
}

type IBsnGentableClearReply interface {
	IBsnHeader
	GetTableId() uint16
	GetDeletedCount() uint32
	GetErrorCount() uint32
}

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

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

func (self *BsnGentableClearReply) GetDeletedCount() uint32 {
	return self.DeletedCount
}

func (self *BsnGentableClearReply) SetDeletedCount(v uint32) {
	self.DeletedCount = v
}

func (self *BsnGentableClearReply) GetErrorCount() uint32 {
	return self.ErrorCount
}

func (self *BsnGentableClearReply) SetErrorCount(v uint32) {
	self.ErrorCount = v
}

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

	encoder.PutUint16(uint16(self.TableId))
	encoder.Write(bytes.Repeat([]byte{0}, 2))
	encoder.PutUint32(uint32(self.DeletedCount))
	encoder.PutUint32(uint32(self.ErrorCount))
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeBsnGentableClearReply(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnGentableClearReply, error) {
	_bsngentableclearreply := &BsnGentableClearReply{BsnHeader: parent}
	if decoder.Length() < 12 {
		return nil, fmt.Errorf("BsnGentableClearReply packet too short: %d < 12", decoder.Length())
	}
	_bsngentableclearreply.TableId = uint16(decoder.ReadUint16())
	decoder.Skip(2)
	_bsngentableclearreply.DeletedCount = uint32(decoder.ReadUint32())
	_bsngentableclearreply.ErrorCount = uint32(decoder.ReadUint32())
	return _bsngentableclearreply, nil
}

func NewBsnGentableClearReply() *BsnGentableClearReply {
	obj := &BsnGentableClearReply{
		BsnHeader: NewBsnHeader(49),
	}
	return obj
}

type BsnGentableClearRequest struct {
	*BsnHeader
	TableId      uint16
	Checksum     Checksum128
	ChecksumMask Checksum128
}

type IBsnGentableClearRequest interface {
	IBsnHeader
	GetTableId() uint16
	GetChecksum() Checksum128
	GetChecksumMask() Checksum128
}

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

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

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

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

func (self *BsnGentableClearRequest) GetChecksumMask() Checksum128 {
	return self.ChecksumMask
}

func (self *BsnGentableClearRequest) SetChecksumMask(v Checksum128) {
	self.ChecksumMask = v
}

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

	encoder.PutUint16(uint16(self.TableId))
	encoder.Write(bytes.Repeat([]byte{0}, 2))
	self.Checksum.Serialize(encoder)
	self.ChecksumMask.Serialize(encoder)
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeBsnGentableClearRequest(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnGentableClearRequest, error) {
	_bsngentableclearrequest := &BsnGentableClearRequest{BsnHeader: parent}
	if decoder.Length() < 36 {
		return nil, fmt.Errorf("BsnGentableClearRequest packet too short: %d < 36", decoder.Length())
	}
	_bsngentableclearrequest.TableId = uint16(decoder.ReadUint16())
	decoder.Skip(2)
	_bsngentableclearrequest.Checksum.Decode(decoder)
	_bsngentableclearrequest.ChecksumMask.Decode(decoder)
	return _bsngentableclearrequest, nil
}

func NewBsnGentableClearRequest() *BsnGentableClearRequest {
	obj := &BsnGentableClearRequest{
		BsnHeader: NewBsnHeader(48),
	}
	return obj
}

type BsnGentableDescStatsReply struct {
	*BsnStatsReply
	Entries []*BsnGentableDescStatsEntry
}

type IBsnGentableDescStatsReply interface {
	IBsnStatsReply
	GetEntries() []*BsnGentableDescStatsEntry
}

func (self *BsnGentableDescStatsReply) GetEntries() []*BsnGentableDescStatsEntry {
	return self.Entries
}

func (self *BsnGentableDescStatsReply) SetEntries(v []*BsnGentableDescStatsEntry) {
	self.Entries = v
}

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

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

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

	return nil
}

func DecodeBsnGentableDescStatsReply(parent *BsnStatsReply, decoder *goloxi.Decoder) (*BsnGentableDescStatsReply, error) {
	_bsngentabledescstatsreply := &BsnGentableDescStatsReply{BsnStatsReply: parent}

	for decoder.Length() >= 48 {
		item, err := DecodeBsnGentableDescStatsEntry(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_bsngentabledescstatsreply.Entries = append(_bsngentabledescstatsreply.Entries, item)
		}
	}
	return _bsngentabledescstatsreply, nil
}

func NewBsnGentableDescStatsReply() *BsnGentableDescStatsReply {
	obj := &BsnGentableDescStatsReply{
		BsnStatsReply: NewBsnStatsReply(4),
	}
	return obj
}

type BsnGentableDescStatsRequest struct {
	*BsnStatsRequest
}

type IBsnGentableDescStatsRequest interface {
	IBsnStatsRequest
}

func (self *BsnGentableDescStatsRequest) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnStatsRequest.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 DecodeBsnGentableDescStatsRequest(parent *BsnStatsRequest, decoder *goloxi.Decoder) (*BsnGentableDescStatsRequest, error) {
	_bsngentabledescstatsrequest := &BsnGentableDescStatsRequest{BsnStatsRequest: parent}
	return _bsngentabledescstatsrequest, nil
}

func NewBsnGentableDescStatsRequest() *BsnGentableDescStatsRequest {
	obj := &BsnGentableDescStatsRequest{
		BsnStatsRequest: NewBsnStatsRequest(4),
	}
	return obj
}

type BsnGentableEntryAdd struct {
	*BsnHeader
	TableId   uint16
	KeyLength uint16
	Checksum  Checksum128
	Key       []IBsnTlv
	Value     []IBsnTlv
}

type IBsnGentableEntryAdd interface {
	IBsnHeader
	GetTableId() uint16
	GetKeyLength() uint16
	GetChecksum() Checksum128
	GetKey() []IBsnTlv
	GetValue() []IBsnTlv
}

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

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

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

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

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

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

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

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

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

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

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

	encoder.PutUint16(uint16(self.TableId))
	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+2:startIndex+4], uint16(length))

	return nil
}

func DecodeBsnGentableEntryAdd(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnGentableEntryAdd, error) {
	_bsngentableentryadd := &BsnGentableEntryAdd{BsnHeader: parent}
	if decoder.Length() < 20 {
		return nil, fmt.Errorf("BsnGentableEntryAdd packet too short: %d < 20", decoder.Length())
	}
	_bsngentableentryadd.TableId = uint16(decoder.ReadUint16())
	_bsngentableentryadd.KeyLength = uint16(decoder.ReadUint16())
	_bsngentableentryadd.Checksum.Decode(decoder)

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

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

func NewBsnGentableEntryAdd() *BsnGentableEntryAdd {
	obj := &BsnGentableEntryAdd{
		BsnHeader: NewBsnHeader(46),
	}
	return obj
}

type BsnGentableEntryDelete struct {
	*BsnHeader
	TableId uint16
	Key     []IBsnTlv
}

type IBsnGentableEntryDelete interface {
	IBsnHeader
	GetTableId() uint16
	GetKey() []IBsnTlv
}

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

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

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

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

func (self *BsnGentableEntryDelete) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnHeader.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 DecodeBsnGentableEntryDelete(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnGentableEntryDelete, error) {
	_bsngentableentrydelete := &BsnGentableEntryDelete{BsnHeader: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("BsnGentableEntryDelete packet too short: %d < 2", decoder.Length())
	}
	_bsngentableentrydelete.TableId = uint16(decoder.ReadUint16())

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

func NewBsnGentableEntryDelete() *BsnGentableEntryDelete {
	obj := &BsnGentableEntryDelete{
		BsnHeader: NewBsnHeader(47),
	}
	return obj
}

type BsnGentableEntryDescStatsReply struct {
	*BsnStatsReply
	Entries []*BsnGentableEntryDescStatsEntry
}

type IBsnGentableEntryDescStatsReply interface {
	IBsnStatsReply
	GetEntries() []*BsnGentableEntryDescStatsEntry
}

func (self *BsnGentableEntryDescStatsReply) GetEntries() []*BsnGentableEntryDescStatsEntry {
	return self.Entries
}

func (self *BsnGentableEntryDescStatsReply) SetEntries(v []*BsnGentableEntryDescStatsEntry) {
	self.Entries = v
}

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

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

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

	return nil
}

func DecodeBsnGentableEntryDescStatsReply(parent *BsnStatsReply, decoder *goloxi.Decoder) (*BsnGentableEntryDescStatsReply, error) {
	_bsngentableentrydescstatsreply := &BsnGentableEntryDescStatsReply{BsnStatsReply: parent}

	for decoder.Length() >= 20 {
		item, err := DecodeBsnGentableEntryDescStatsEntry(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_bsngentableentrydescstatsreply.Entries = append(_bsngentableentrydescstatsreply.Entries, item)
		}
	}
	return _bsngentableentrydescstatsreply, nil
}

func NewBsnGentableEntryDescStatsReply() *BsnGentableEntryDescStatsReply {
	obj := &BsnGentableEntryDescStatsReply{
		BsnStatsReply: NewBsnStatsReply(2),
	}
	return obj
}

type BsnGentableEntryDescStatsRequest struct {
	*BsnStatsRequest
	TableId      uint16
	Checksum     Checksum128
	ChecksumMask Checksum128
}

type IBsnGentableEntryDescStatsRequest interface {
	IBsnStatsRequest
	GetTableId() uint16
	GetChecksum() Checksum128
	GetChecksumMask() Checksum128
}

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

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

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

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

func (self *BsnGentableEntryDescStatsRequest) GetChecksumMask() Checksum128 {
	return self.ChecksumMask
}

func (self *BsnGentableEntryDescStatsRequest) SetChecksumMask(v Checksum128) {
	self.ChecksumMask = v
}

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

	encoder.PutUint16(uint16(self.TableId))
	encoder.Write(bytes.Repeat([]byte{0}, 2))
	self.Checksum.Serialize(encoder)
	self.ChecksumMask.Serialize(encoder)
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeBsnGentableEntryDescStatsRequest(parent *BsnStatsRequest, decoder *goloxi.Decoder) (*BsnGentableEntryDescStatsRequest, error) {
	_bsngentableentrydescstatsrequest := &BsnGentableEntryDescStatsRequest{BsnStatsRequest: parent}
	if decoder.Length() < 36 {
		return nil, fmt.Errorf("BsnGentableEntryDescStatsRequest packet too short: %d < 36", decoder.Length())
	}
	_bsngentableentrydescstatsrequest.TableId = uint16(decoder.ReadUint16())
	decoder.Skip(2)
	_bsngentableentrydescstatsrequest.Checksum.Decode(decoder)
	_bsngentableentrydescstatsrequest.ChecksumMask.Decode(decoder)
	return _bsngentableentrydescstatsrequest, nil
}

func NewBsnGentableEntryDescStatsRequest() *BsnGentableEntryDescStatsRequest {
	obj := &BsnGentableEntryDescStatsRequest{
		BsnStatsRequest: NewBsnStatsRequest(2),
	}
	return obj
}

type BsnGentableEntryStatsReply struct {
	*BsnStatsReply
	Entries []*BsnGentableEntryStatsEntry
}

type IBsnGentableEntryStatsReply interface {
	IBsnStatsReply
	GetEntries() []*BsnGentableEntryStatsEntry
}

func (self *BsnGentableEntryStatsReply) GetEntries() []*BsnGentableEntryStatsEntry {
	return self.Entries
}

func (self *BsnGentableEntryStatsReply) SetEntries(v []*BsnGentableEntryStatsEntry) {
	self.Entries = v
}

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

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

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

	return nil
}

func DecodeBsnGentableEntryStatsReply(parent *BsnStatsReply, decoder *goloxi.Decoder) (*BsnGentableEntryStatsReply, error) {
	_bsngentableentrystatsreply := &BsnGentableEntryStatsReply{BsnStatsReply: parent}

	for decoder.Length() >= 4 {
		item, err := DecodeBsnGentableEntryStatsEntry(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_bsngentableentrystatsreply.Entries = append(_bsngentableentrystatsreply.Entries, item)
		}
	}
	return _bsngentableentrystatsreply, nil
}

func NewBsnGentableEntryStatsReply() *BsnGentableEntryStatsReply {
	obj := &BsnGentableEntryStatsReply{
		BsnStatsReply: NewBsnStatsReply(3),
	}
	return obj
}

type BsnGentableEntryStatsRequest struct {
	*BsnStatsRequest
	TableId      uint16
	Checksum     Checksum128
	ChecksumMask Checksum128
}

type IBsnGentableEntryStatsRequest interface {
	IBsnStatsRequest
	GetTableId() uint16
	GetChecksum() Checksum128
	GetChecksumMask() Checksum128
}

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

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

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

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

func (self *BsnGentableEntryStatsRequest) GetChecksumMask() Checksum128 {
	return self.ChecksumMask
}

func (self *BsnGentableEntryStatsRequest) SetChecksumMask(v Checksum128) {
	self.ChecksumMask = v
}

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

	encoder.PutUint16(uint16(self.TableId))
	encoder.Write(bytes.Repeat([]byte{0}, 2))
	self.Checksum.Serialize(encoder)
	self.ChecksumMask.Serialize(encoder)
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeBsnGentableEntryStatsRequest(parent *BsnStatsRequest, decoder *goloxi.Decoder) (*BsnGentableEntryStatsRequest, error) {
	_bsngentableentrystatsrequest := &BsnGentableEntryStatsRequest{BsnStatsRequest: parent}
	if decoder.Length() < 36 {
		return nil, fmt.Errorf("BsnGentableEntryStatsRequest packet too short: %d < 36", decoder.Length())
	}
	_bsngentableentrystatsrequest.TableId = uint16(decoder.ReadUint16())
	decoder.Skip(2)
	_bsngentableentrystatsrequest.Checksum.Decode(decoder)
	_bsngentableentrystatsrequest.ChecksumMask.Decode(decoder)
	return _bsngentableentrystatsrequest, nil
}

func NewBsnGentableEntryStatsRequest() *BsnGentableEntryStatsRequest {
	obj := &BsnGentableEntryStatsRequest{
		BsnStatsRequest: NewBsnStatsRequest(3),
	}
	return obj
}

type BsnGentableError struct {
	*BsnBaseError
	ErrorCode BsnGentableErrorCode
	TableId   uint16
}

type IBsnGentableError interface {
	IBsnBaseError
	GetErrorCode() BsnGentableErrorCode
	GetTableId() uint16
}

func (self *BsnGentableError) GetErrorCode() BsnGentableErrorCode {
	return self.ErrorCode
}

func (self *BsnGentableError) SetErrorCode(v BsnGentableErrorCode) {
	self.ErrorCode = v
}

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

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

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

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

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

	return nil
}

func DecodeBsnGentableError(parent *BsnBaseError, decoder *goloxi.Decoder) (*BsnGentableError, error) {
	_bsngentableerror := &BsnGentableError{BsnBaseError: parent}
	if decoder.Length() < 260 {
		return nil, fmt.Errorf("BsnGentableError packet too short: %d < 260", decoder.Length())
	}
	_bsngentableerror.ErrorCode = BsnGentableErrorCode(decoder.ReadUint16())
	_bsngentableerror.TableId = uint16(decoder.ReadUint16())
	return _bsngentableerror, nil
}

func NewBsnGentableError() *BsnGentableError {
	obj := &BsnGentableError{
		BsnBaseError: NewBsnBaseError(2),
	}
	return obj
}

type BsnGentableSetBucketsSize struct {
	*BsnHeader
	TableId     uint16
	BucketsSize uint32
}

type IBsnGentableSetBucketsSize interface {
	IBsnHeader
	GetTableId() uint16
	GetBucketsSize() uint32
}

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

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

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

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

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

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

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

	return nil
}

func DecodeBsnGentableSetBucketsSize(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnGentableSetBucketsSize, error) {
	_bsngentablesetbucketssize := &BsnGentableSetBucketsSize{BsnHeader: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("BsnGentableSetBucketsSize packet too short: %d < 8", decoder.Length())
	}
	_bsngentablesetbucketssize.TableId = uint16(decoder.ReadUint16())
	decoder.Skip(2)
	_bsngentablesetbucketssize.BucketsSize = uint32(decoder.ReadUint32())
	return _bsngentablesetbucketssize, nil
}

func NewBsnGentableSetBucketsSize() *BsnGentableSetBucketsSize {
	obj := &BsnGentableSetBucketsSize{
		BsnHeader: NewBsnHeader(50),
	}
	return obj
}

type BsnGentableStatsReply struct {
	*BsnStatsReply
	Entries []*BsnGentableStatsEntry
}

type IBsnGentableStatsReply interface {
	IBsnStatsReply
	GetEntries() []*BsnGentableStatsEntry
}

func (self *BsnGentableStatsReply) GetEntries() []*BsnGentableStatsEntry {
	return self.Entries
}

func (self *BsnGentableStatsReply) SetEntries(v []*BsnGentableStatsEntry) {
	self.Entries = v
}

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

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

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

	return nil
}

func DecodeBsnGentableStatsReply(parent *BsnStatsReply, decoder *goloxi.Decoder) (*BsnGentableStatsReply, error) {
	_bsngentablestatsreply := &BsnGentableStatsReply{BsnStatsReply: parent}

	for decoder.Length() >= 24 {
		item, err := DecodeBsnGentableStatsEntry(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_bsngentablestatsreply.Entries = append(_bsngentablestatsreply.Entries, item)
		}
	}
	return _bsngentablestatsreply, nil
}

func NewBsnGentableStatsReply() *BsnGentableStatsReply {
	obj := &BsnGentableStatsReply{
		BsnStatsReply: NewBsnStatsReply(7),
	}
	return obj
}

type BsnGentableStatsRequest struct {
	*BsnStatsRequest
}

type IBsnGentableStatsRequest interface {
	IBsnStatsRequest
}

func (self *BsnGentableStatsRequest) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnStatsRequest.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 DecodeBsnGentableStatsRequest(parent *BsnStatsRequest, decoder *goloxi.Decoder) (*BsnGentableStatsRequest, error) {
	_bsngentablestatsrequest := &BsnGentableStatsRequest{BsnStatsRequest: parent}
	return _bsngentablestatsrequest, nil
}

func NewBsnGentableStatsRequest() *BsnGentableStatsRequest {
	obj := &BsnGentableStatsRequest{
		BsnStatsRequest: NewBsnStatsRequest(7),
	}
	return obj
}

type BsnGetInterfacesReply struct {
	*BsnHeader
	Interfaces []*BsnInterface
}

type IBsnGetInterfacesReply interface {
	IBsnHeader
	GetInterfaces() []*BsnInterface
}

func (self *BsnGetInterfacesReply) GetInterfaces() []*BsnInterface {
	return self.Interfaces
}

func (self *BsnGetInterfacesReply) SetInterfaces(v []*BsnInterface) {
	self.Interfaces = v
}

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

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

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

	return nil
}

func DecodeBsnGetInterfacesReply(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnGetInterfacesReply, error) {
	_bsngetinterfacesreply := &BsnGetInterfacesReply{BsnHeader: parent}

	for decoder.Length() >= 32 {
		item, err := DecodeBsnInterface(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_bsngetinterfacesreply.Interfaces = append(_bsngetinterfacesreply.Interfaces, item)
		}
	}
	return _bsngetinterfacesreply, nil
}

func NewBsnGetInterfacesReply() *BsnGetInterfacesReply {
	obj := &BsnGetInterfacesReply{
		BsnHeader: NewBsnHeader(10),
	}
	return obj
}

type BsnGetInterfacesRequest struct {
	*BsnHeader
}

type IBsnGetInterfacesRequest interface {
	IBsnHeader
}

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

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

	return nil
}

func DecodeBsnGetInterfacesRequest(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnGetInterfacesRequest, error) {
	_bsngetinterfacesrequest := &BsnGetInterfacesRequest{BsnHeader: parent}
	return _bsngetinterfacesrequest, nil
}

func NewBsnGetInterfacesRequest() *BsnGetInterfacesRequest {
	obj := &BsnGetInterfacesRequest{
		BsnHeader: NewBsnHeader(9),
	}
	return obj
}

type BsnGetMirroringReply struct {
	*BsnHeader
	ReportMirrorPorts uint8
}

type IBsnGetMirroringReply interface {
	IBsnHeader
	GetReportMirrorPorts() uint8
}

func (self *BsnGetMirroringReply) GetReportMirrorPorts() uint8 {
	return self.ReportMirrorPorts
}

func (self *BsnGetMirroringReply) SetReportMirrorPorts(v uint8) {
	self.ReportMirrorPorts = v
}

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

	encoder.PutUint8(uint8(self.ReportMirrorPorts))
	encoder.Write(bytes.Repeat([]byte{0}, 3))
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeBsnGetMirroringReply(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnGetMirroringReply, error) {
	_bsngetmirroringreply := &BsnGetMirroringReply{BsnHeader: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("BsnGetMirroringReply packet too short: %d < 4", decoder.Length())
	}
	_bsngetmirroringreply.ReportMirrorPorts = uint8(decoder.ReadByte())
	decoder.Skip(3)
	return _bsngetmirroringreply, nil
}

func NewBsnGetMirroringReply() *BsnGetMirroringReply {
	obj := &BsnGetMirroringReply{
		BsnHeader: NewBsnHeader(5),
	}
	return obj
}

type BsnGetMirroringRequest struct {
	*BsnHeader
	ReportMirrorPorts uint8
}

type IBsnGetMirroringRequest interface {
	IBsnHeader
	GetReportMirrorPorts() uint8
}

func (self *BsnGetMirroringRequest) GetReportMirrorPorts() uint8 {
	return self.ReportMirrorPorts
}

func (self *BsnGetMirroringRequest) SetReportMirrorPorts(v uint8) {
	self.ReportMirrorPorts = v
}

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

	encoder.PutUint8(uint8(self.ReportMirrorPorts))
	encoder.Write(bytes.Repeat([]byte{0}, 3))
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeBsnGetMirroringRequest(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnGetMirroringRequest, error) {
	_bsngetmirroringrequest := &BsnGetMirroringRequest{BsnHeader: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("BsnGetMirroringRequest packet too short: %d < 4", decoder.Length())
	}
	_bsngetmirroringrequest.ReportMirrorPorts = uint8(decoder.ReadByte())
	decoder.Skip(3)
	return _bsngetmirroringrequest, nil
}

func NewBsnGetMirroringRequest() *BsnGetMirroringRequest {
	obj := &BsnGetMirroringRequest{
		BsnHeader: NewBsnHeader(4),
	}
	return obj
}

type BsnGetSwitchPipelineReply struct {
	*BsnHeader
	Pipeline string
}

type IBsnGetSwitchPipelineReply interface {
	IBsnHeader
	GetPipeline() string
}

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

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

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

	encoder.Write([]byte(self.Pipeline))
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

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

func NewBsnGetSwitchPipelineReply() *BsnGetSwitchPipelineReply {
	obj := &BsnGetSwitchPipelineReply{
		BsnHeader: NewBsnHeader(52),
	}
	return obj
}

type BsnGetSwitchPipelineRequest struct {
	*BsnHeader
}

type IBsnGetSwitchPipelineRequest interface {
	IBsnHeader
}

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

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

	return nil
}

func DecodeBsnGetSwitchPipelineRequest(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnGetSwitchPipelineRequest, error) {
	_bsngetswitchpipelinerequest := &BsnGetSwitchPipelineRequest{BsnHeader: parent}
	return _bsngetswitchpipelinerequest, nil
}

func NewBsnGetSwitchPipelineRequest() *BsnGetSwitchPipelineRequest {
	obj := &BsnGetSwitchPipelineRequest{
		BsnHeader: NewBsnHeader(51),
	}
	return obj
}

type BsnImageDescStatsReply struct {
	*BsnStatsReply
	ImageChecksum         string
	StartupConfigChecksum string
}

type IBsnImageDescStatsReply interface {
	IBsnStatsReply
	GetImageChecksum() string
	GetStartupConfigChecksum() string
}

func (self *BsnImageDescStatsReply) GetImageChecksum() string {
	return self.ImageChecksum
}

func (self *BsnImageDescStatsReply) SetImageChecksum(v string) {
	self.ImageChecksum = v
}

func (self *BsnImageDescStatsReply) GetStartupConfigChecksum() string {
	return self.StartupConfigChecksum
}

func (self *BsnImageDescStatsReply) SetStartupConfigChecksum(v string) {
	self.StartupConfigChecksum = v
}

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

	encoder.Write([]byte(self.ImageChecksum))
	encoder.Write([]byte(self.StartupConfigChecksum))
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeBsnImageDescStatsReply(parent *BsnStatsReply, decoder *goloxi.Decoder) (*BsnImageDescStatsReply, error) {
	_bsnimagedescstatsreply := &BsnImageDescStatsReply{BsnStatsReply: parent}
	if decoder.Length() < 512 {
		return nil, fmt.Errorf("BsnImageDescStatsReply packet too short: %d < 512", decoder.Length())
	}
	_bsnimagedescstatsreply.ImageChecksum = string(bytes.Trim(decoder.Read(256), "\x00"))
	_bsnimagedescstatsreply.StartupConfigChecksum = string(bytes.Trim(decoder.Read(256), "\x00"))
	return _bsnimagedescstatsreply, nil
}

func NewBsnImageDescStatsReply() *BsnImageDescStatsReply {
	obj := &BsnImageDescStatsReply{
		BsnStatsReply: NewBsnStatsReply(14),
	}
	return obj
}

type BsnImageDescStatsRequest struct {
	*BsnStatsRequest
}

type IBsnImageDescStatsRequest interface {
	IBsnStatsRequest
}

func (self *BsnImageDescStatsRequest) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnStatsRequest.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 DecodeBsnImageDescStatsRequest(parent *BsnStatsRequest, decoder *goloxi.Decoder) (*BsnImageDescStatsRequest, error) {
	_bsnimagedescstatsrequest := &BsnImageDescStatsRequest{BsnStatsRequest: parent}
	return _bsnimagedescstatsrequest, nil
}

func NewBsnImageDescStatsRequest() *BsnImageDescStatsRequest {
	obj := &BsnImageDescStatsRequest{
		BsnStatsRequest: NewBsnStatsRequest(14),
	}
	return obj
}

type BsnLacpConvergenceNotif struct {
	*BsnHeader
	ConvergenceStatus   uint8
	PortNo              Port
	ActorSysPriority    uint16
	ActorSysMac         net.HardwareAddr
	ActorPortPriority   uint16
	ActorPortNum        uint16
	ActorKey            uint16
	PartnerSysPriority  uint16
	PartnerSysMac       net.HardwareAddr
	PartnerPortPriority uint16
	PartnerPortNum      uint16
	PartnerKey          uint16
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	encoder.PutUint8(uint8(self.ConvergenceStatus))
	encoder.Write(bytes.Repeat([]byte{0}, 3))
	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.PutUint16(uint16(self.PartnerSysPriority))
	encoder.Write(self.PartnerSysMac)
	encoder.PutUint16(uint16(self.PartnerPortPriority))
	encoder.PutUint16(uint16(self.PartnerPortNum))
	encoder.PutUint16(uint16(self.PartnerKey))
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

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

func NewBsnLacpConvergenceNotif() *BsnLacpConvergenceNotif {
	obj := &BsnLacpConvergenceNotif{
		BsnHeader: NewBsnHeader(43),
	}
	return obj
}

type BsnLacpStatsReply struct {
	*BsnStatsReply
	Entries []*BsnLacpStatsEntry
}

type IBsnLacpStatsReply interface {
	IBsnStatsReply
	GetEntries() []*BsnLacpStatsEntry
}

func (self *BsnLacpStatsReply) GetEntries() []*BsnLacpStatsEntry {
	return self.Entries
}

func (self *BsnLacpStatsReply) SetEntries(v []*BsnLacpStatsEntry) {
	self.Entries = v
}

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

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

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

	return nil
}

func DecodeBsnLacpStatsReply(parent *BsnStatsReply, decoder *goloxi.Decoder) (*BsnLacpStatsReply, error) {
	_bsnlacpstatsreply := &BsnLacpStatsReply{BsnStatsReply: parent}

	for decoder.Length() >= 36 {
		item, err := DecodeBsnLacpStatsEntry(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_bsnlacpstatsreply.Entries = append(_bsnlacpstatsreply.Entries, item)
		}
	}
	return _bsnlacpstatsreply, nil
}

func NewBsnLacpStatsReply() *BsnLacpStatsReply {
	obj := &BsnLacpStatsReply{
		BsnStatsReply: NewBsnStatsReply(1),
	}
	return obj
}

type BsnLacpStatsRequest struct {
	*BsnStatsRequest
}

type IBsnLacpStatsRequest interface {
	IBsnStatsRequest
}

func (self *BsnLacpStatsRequest) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnStatsRequest.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 DecodeBsnLacpStatsRequest(parent *BsnStatsRequest, decoder *goloxi.Decoder) (*BsnLacpStatsRequest, error) {
	_bsnlacpstatsrequest := &BsnLacpStatsRequest{BsnStatsRequest: parent}
	return _bsnlacpstatsrequest, nil
}

func NewBsnLacpStatsRequest() *BsnLacpStatsRequest {
	obj := &BsnLacpStatsRequest{
		BsnStatsRequest: NewBsnStatsRequest(1),
	}
	return obj
}

type BsnLog struct {
	*BsnHeader
	Loglevel BsnLoglevel
	Data     []byte
}

type IBsnLog interface {
	IBsnHeader
	GetLoglevel() BsnLoglevel
	GetData() []byte
}

func (self *BsnLog) GetLoglevel() BsnLoglevel {
	return self.Loglevel
}

func (self *BsnLog) SetLoglevel(v BsnLoglevel) {
	self.Loglevel = v
}

func (self *BsnLog) GetData() []byte {
	return self.Data
}

func (self *BsnLog) SetData(v []byte) {
	self.Data = v
}

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

	encoder.PutUint8(uint8(self.Loglevel))
	encoder.Write(self.Data)
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeBsnLog(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnLog, error) {
	_bsnlog := &BsnLog{BsnHeader: parent}
	if decoder.Length() < 1 {
		return nil, fmt.Errorf("BsnLog packet too short: %d < 1", decoder.Length())
	}
	_bsnlog.Loglevel = BsnLoglevel(decoder.ReadByte())
	_bsnlog.Data = decoder.Read(int(decoder.Length()))
	return _bsnlog, nil
}

func NewBsnLog() *BsnLog {
	obj := &BsnLog{
		BsnHeader: NewBsnHeader(63),
	}
	return obj
}

type BsnLuaCommandReply struct {
	*BsnHeader
	Data []byte
}

type IBsnLuaCommandReply interface {
	IBsnHeader
	GetData() []byte
}

func (self *BsnLuaCommandReply) GetData() []byte {
	return self.Data
}

func (self *BsnLuaCommandReply) SetData(v []byte) {
	self.Data = v
}

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

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

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

	return nil
}

func DecodeBsnLuaCommandReply(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnLuaCommandReply, error) {
	_bsnluacommandreply := &BsnLuaCommandReply{BsnHeader: parent}
	_bsnluacommandreply.Data = decoder.Read(int(decoder.Length()))
	return _bsnluacommandreply, nil
}

func NewBsnLuaCommandReply() *BsnLuaCommandReply {
	obj := &BsnLuaCommandReply{
		BsnHeader: NewBsnHeader(66),
	}
	return obj
}

type BsnLuaCommandRequest struct {
	*BsnHeader
	Data []byte
}

type IBsnLuaCommandRequest interface {
	IBsnHeader
	GetData() []byte
}

func (self *BsnLuaCommandRequest) GetData() []byte {
	return self.Data
}

func (self *BsnLuaCommandRequest) SetData(v []byte) {
	self.Data = v
}

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

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

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

	return nil
}

func DecodeBsnLuaCommandRequest(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnLuaCommandRequest, error) {
	_bsnluacommandrequest := &BsnLuaCommandRequest{BsnHeader: parent}
	_bsnluacommandrequest.Data = decoder.Read(int(decoder.Length()))
	return _bsnluacommandrequest, nil
}

func NewBsnLuaCommandRequest() *BsnLuaCommandRequest {
	obj := &BsnLuaCommandRequest{
		BsnHeader: NewBsnHeader(65),
	}
	return obj
}

type BsnLuaNotification struct {
	*BsnHeader
	Data []byte
}

type IBsnLuaNotification interface {
	IBsnHeader
	GetData() []byte
}

func (self *BsnLuaNotification) GetData() []byte {
	return self.Data
}

func (self *BsnLuaNotification) SetData(v []byte) {
	self.Data = v
}

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

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

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

	return nil
}

func DecodeBsnLuaNotification(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnLuaNotification, error) {
	_bsnluanotification := &BsnLuaNotification{BsnHeader: parent}
	_bsnluanotification.Data = decoder.Read(int(decoder.Length()))
	return _bsnluanotification, nil
}

func NewBsnLuaNotification() *BsnLuaNotification {
	obj := &BsnLuaNotification{
		BsnHeader: NewBsnHeader(67),
	}
	return obj
}

type BsnLuaUpload struct {
	*BsnHeader
	Flags    BsnLuaUploadFlags
	Filename string
	Data     []byte
}

type IBsnLuaUpload interface {
	IBsnHeader
	GetFlags() BsnLuaUploadFlags
	GetFilename() string
	GetData() []byte
}

func (self *BsnLuaUpload) GetFlags() BsnLuaUploadFlags {
	return self.Flags
}

func (self *BsnLuaUpload) SetFlags(v BsnLuaUploadFlags) {
	self.Flags = v
}

func (self *BsnLuaUpload) GetFilename() string {
	return self.Filename
}

func (self *BsnLuaUpload) SetFilename(v string) {
	self.Filename = v
}

func (self *BsnLuaUpload) GetData() []byte {
	return self.Data
}

func (self *BsnLuaUpload) SetData(v []byte) {
	self.Data = v
}

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

	encoder.PutUint16(uint16(self.Flags))
	encoder.Write([]byte(self.Filename))
	encoder.Write(self.Data)
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeBsnLuaUpload(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnLuaUpload, error) {
	_bsnluaupload := &BsnLuaUpload{BsnHeader: parent}
	if decoder.Length() < 66 {
		return nil, fmt.Errorf("BsnLuaUpload packet too short: %d < 66", decoder.Length())
	}
	_bsnluaupload.Flags = BsnLuaUploadFlags(decoder.ReadUint16())
	_bsnluaupload.Filename = string(bytes.Trim(decoder.Read(64), "\x00"))
	_bsnluaupload.Data = decoder.Read(int(decoder.Length()))
	return _bsnluaupload, nil
}

func NewBsnLuaUpload() *BsnLuaUpload {
	obj := &BsnLuaUpload{
		BsnHeader: NewBsnHeader(64),
	}
	return obj
}

type BsnPduRxReply struct {
	*BsnHeader
	Status  uint32
	PortNo  Port
	SlotNum uint8
}

type IBsnPduRxReply interface {
	IBsnHeader
	GetStatus() uint32
	GetPortNo() Port
	GetSlotNum() uint8
}

func (self *BsnPduRxReply) GetStatus() uint32 {
	return self.Status
}

func (self *BsnPduRxReply) SetStatus(v uint32) {
	self.Status = v
}

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

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

func (self *BsnPduRxReply) GetSlotNum() uint8 {
	return self.SlotNum
}

func (self *BsnPduRxReply) SetSlotNum(v uint8) {
	self.SlotNum = v
}

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

	encoder.PutUint32(uint32(self.Status))
	self.PortNo.Serialize(encoder)
	encoder.PutUint8(uint8(self.SlotNum))
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeBsnPduRxReply(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnPduRxReply, error) {
	_bsnpdurxreply := &BsnPduRxReply{BsnHeader: parent}
	if decoder.Length() < 9 {
		return nil, fmt.Errorf("BsnPduRxReply packet too short: %d < 9", decoder.Length())
	}
	_bsnpdurxreply.Status = uint32(decoder.ReadUint32())
	_bsnpdurxreply.PortNo.Decode(decoder)
	_bsnpdurxreply.SlotNum = uint8(decoder.ReadByte())
	return _bsnpdurxreply, nil
}

func NewBsnPduRxReply() *BsnPduRxReply {
	obj := &BsnPduRxReply{
		BsnHeader: NewBsnHeader(34),
	}
	return obj
}

type BsnPduRxRequest struct {
	*BsnHeader
	TimeoutMs uint32
	PortNo    Port
	SlotNum   uint8
	Data      []byte
}

type IBsnPduRxRequest interface {
	IBsnHeader
	GetTimeoutMs() uint32
	GetPortNo() Port
	GetSlotNum() uint8
	GetData() []byte
}

func (self *BsnPduRxRequest) GetTimeoutMs() uint32 {
	return self.TimeoutMs
}

func (self *BsnPduRxRequest) SetTimeoutMs(v uint32) {
	self.TimeoutMs = v
}

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

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

func (self *BsnPduRxRequest) GetSlotNum() uint8 {
	return self.SlotNum
}

func (self *BsnPduRxRequest) SetSlotNum(v uint8) {
	self.SlotNum = v
}

func (self *BsnPduRxRequest) GetData() []byte {
	return self.Data
}

func (self *BsnPduRxRequest) SetData(v []byte) {
	self.Data = v
}

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

	encoder.PutUint32(uint32(self.TimeoutMs))
	self.PortNo.Serialize(encoder)
	encoder.PutUint8(uint8(self.SlotNum))
	encoder.Write(bytes.Repeat([]byte{0}, 3))
	encoder.Write(self.Data)
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeBsnPduRxRequest(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnPduRxRequest, error) {
	_bsnpdurxrequest := &BsnPduRxRequest{BsnHeader: parent}
	if decoder.Length() < 12 {
		return nil, fmt.Errorf("BsnPduRxRequest packet too short: %d < 12", decoder.Length())
	}
	_bsnpdurxrequest.TimeoutMs = uint32(decoder.ReadUint32())
	_bsnpdurxrequest.PortNo.Decode(decoder)
	_bsnpdurxrequest.SlotNum = uint8(decoder.ReadByte())
	decoder.Skip(3)
	_bsnpdurxrequest.Data = decoder.Read(int(decoder.Length()))
	return _bsnpdurxrequest, nil
}

func NewBsnPduRxRequest() *BsnPduRxRequest {
	obj := &BsnPduRxRequest{
		BsnHeader: NewBsnHeader(33),
	}
	return obj
}

type BsnPduRxTimeout struct {
	*BsnHeader
	PortNo  Port
	SlotNum uint8
}

type IBsnPduRxTimeout interface {
	IBsnHeader
	GetPortNo() Port
	GetSlotNum() uint8
}

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

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

func (self *BsnPduRxTimeout) GetSlotNum() uint8 {
	return self.SlotNum
}

func (self *BsnPduRxTimeout) SetSlotNum(v uint8) {
	self.SlotNum = v
}

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

	self.PortNo.Serialize(encoder)
	encoder.PutUint8(uint8(self.SlotNum))
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeBsnPduRxTimeout(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnPduRxTimeout, error) {
	_bsnpdurxtimeout := &BsnPduRxTimeout{BsnHeader: parent}
	if decoder.Length() < 5 {
		return nil, fmt.Errorf("BsnPduRxTimeout packet too short: %d < 5", decoder.Length())
	}
	_bsnpdurxtimeout.PortNo.Decode(decoder)
	_bsnpdurxtimeout.SlotNum = uint8(decoder.ReadByte())
	return _bsnpdurxtimeout, nil
}

func NewBsnPduRxTimeout() *BsnPduRxTimeout {
	obj := &BsnPduRxTimeout{
		BsnHeader: NewBsnHeader(35),
	}
	return obj
}

type BsnPduTxReply struct {
	*BsnHeader
	Status  uint32
	PortNo  Port
	SlotNum uint8
}

type IBsnPduTxReply interface {
	IBsnHeader
	GetStatus() uint32
	GetPortNo() Port
	GetSlotNum() uint8
}

func (self *BsnPduTxReply) GetStatus() uint32 {
	return self.Status
}

func (self *BsnPduTxReply) SetStatus(v uint32) {
	self.Status = v
}

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

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

func (self *BsnPduTxReply) GetSlotNum() uint8 {
	return self.SlotNum
}

func (self *BsnPduTxReply) SetSlotNum(v uint8) {
	self.SlotNum = v
}

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

	encoder.PutUint32(uint32(self.Status))
	self.PortNo.Serialize(encoder)
	encoder.PutUint8(uint8(self.SlotNum))
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeBsnPduTxReply(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnPduTxReply, error) {
	_bsnpdutxreply := &BsnPduTxReply{BsnHeader: parent}
	if decoder.Length() < 9 {
		return nil, fmt.Errorf("BsnPduTxReply packet too short: %d < 9", decoder.Length())
	}
	_bsnpdutxreply.Status = uint32(decoder.ReadUint32())
	_bsnpdutxreply.PortNo.Decode(decoder)
	_bsnpdutxreply.SlotNum = uint8(decoder.ReadByte())
	return _bsnpdutxreply, nil
}

func NewBsnPduTxReply() *BsnPduTxReply {
	obj := &BsnPduTxReply{
		BsnHeader: NewBsnHeader(32),
	}
	return obj
}

type BsnPduTxRequest struct {
	*BsnHeader
	TxIntervalMs uint32
	PortNo       Port
	SlotNum      uint8
	Data         []byte
}

type IBsnPduTxRequest interface {
	IBsnHeader
	GetTxIntervalMs() uint32
	GetPortNo() Port
	GetSlotNum() uint8
	GetData() []byte
}

func (self *BsnPduTxRequest) GetTxIntervalMs() uint32 {
	return self.TxIntervalMs
}

func (self *BsnPduTxRequest) SetTxIntervalMs(v uint32) {
	self.TxIntervalMs = v
}

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

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

func (self *BsnPduTxRequest) GetSlotNum() uint8 {
	return self.SlotNum
}

func (self *BsnPduTxRequest) SetSlotNum(v uint8) {
	self.SlotNum = v
}

func (self *BsnPduTxRequest) GetData() []byte {
	return self.Data
}

func (self *BsnPduTxRequest) SetData(v []byte) {
	self.Data = v
}

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

	encoder.PutUint32(uint32(self.TxIntervalMs))
	self.PortNo.Serialize(encoder)
	encoder.PutUint8(uint8(self.SlotNum))
	encoder.Write(bytes.Repeat([]byte{0}, 3))
	encoder.Write(self.Data)
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeBsnPduTxRequest(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnPduTxRequest, error) {
	_bsnpdutxrequest := &BsnPduTxRequest{BsnHeader: parent}
	if decoder.Length() < 12 {
		return nil, fmt.Errorf("BsnPduTxRequest packet too short: %d < 12", decoder.Length())
	}
	_bsnpdutxrequest.TxIntervalMs = uint32(decoder.ReadUint32())
	_bsnpdutxrequest.PortNo.Decode(decoder)
	_bsnpdutxrequest.SlotNum = uint8(decoder.ReadByte())
	decoder.Skip(3)
	_bsnpdutxrequest.Data = decoder.Read(int(decoder.Length()))
	return _bsnpdutxrequest, nil
}

func NewBsnPduTxRequest() *BsnPduTxRequest {
	obj := &BsnPduTxRequest{
		BsnHeader: NewBsnHeader(31),
	}
	return obj
}

type BsnPortCounterStatsReply struct {
	*BsnStatsReply
	Entries []*BsnPortCounterStatsEntry
}

type IBsnPortCounterStatsReply interface {
	IBsnStatsReply
	GetEntries() []*BsnPortCounterStatsEntry
}

func (self *BsnPortCounterStatsReply) GetEntries() []*BsnPortCounterStatsEntry {
	return self.Entries
}

func (self *BsnPortCounterStatsReply) SetEntries(v []*BsnPortCounterStatsEntry) {
	self.Entries = v
}

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

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

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

	return nil
}

func DecodeBsnPortCounterStatsReply(parent *BsnStatsReply, decoder *goloxi.Decoder) (*BsnPortCounterStatsReply, error) {
	_bsnportcounterstatsreply := &BsnPortCounterStatsReply{BsnStatsReply: parent}

	for decoder.Length() >= 8 {
		item, err := DecodeBsnPortCounterStatsEntry(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_bsnportcounterstatsreply.Entries = append(_bsnportcounterstatsreply.Entries, item)
		}
	}
	return _bsnportcounterstatsreply, nil
}

func NewBsnPortCounterStatsReply() *BsnPortCounterStatsReply {
	obj := &BsnPortCounterStatsReply{
		BsnStatsReply: NewBsnStatsReply(8),
	}
	return obj
}

type BsnPortCounterStatsRequest struct {
	*BsnStatsRequest
	PortNo Port
}

type IBsnPortCounterStatsRequest interface {
	IBsnStatsRequest
	GetPortNo() Port
}

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

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

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

	self.PortNo.Serialize(encoder)
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeBsnPortCounterStatsRequest(parent *BsnStatsRequest, decoder *goloxi.Decoder) (*BsnPortCounterStatsRequest, error) {
	_bsnportcounterstatsrequest := &BsnPortCounterStatsRequest{BsnStatsRequest: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("BsnPortCounterStatsRequest packet too short: %d < 4", decoder.Length())
	}
	_bsnportcounterstatsrequest.PortNo.Decode(decoder)
	return _bsnportcounterstatsrequest, nil
}

func NewBsnPortCounterStatsRequest() *BsnPortCounterStatsRequest {
	obj := &BsnPortCounterStatsRequest{
		BsnStatsRequest: NewBsnStatsRequest(8),
	}
	return obj
}

type BsnSetAuxCxnsReply struct {
	*BsnHeader
	NumAux uint32
	Status uint32
}

type IBsnSetAuxCxnsReply interface {
	IBsnHeader
	GetNumAux() uint32
	GetStatus() uint32
}

func (self *BsnSetAuxCxnsReply) GetNumAux() uint32 {
	return self.NumAux
}

func (self *BsnSetAuxCxnsReply) SetNumAux(v uint32) {
	self.NumAux = v
}

func (self *BsnSetAuxCxnsReply) GetStatus() uint32 {
	return self.Status
}

func (self *BsnSetAuxCxnsReply) SetStatus(v uint32) {
	self.Status = v
}

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

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

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

	return nil
}

func DecodeBsnSetAuxCxnsReply(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnSetAuxCxnsReply, error) {
	_bsnsetauxcxnsreply := &BsnSetAuxCxnsReply{BsnHeader: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("BsnSetAuxCxnsReply packet too short: %d < 8", decoder.Length())
	}
	_bsnsetauxcxnsreply.NumAux = uint32(decoder.ReadUint32())
	_bsnsetauxcxnsreply.Status = uint32(decoder.ReadUint32())
	return _bsnsetauxcxnsreply, nil
}

func NewBsnSetAuxCxnsReply() *BsnSetAuxCxnsReply {
	obj := &BsnSetAuxCxnsReply{
		BsnHeader: NewBsnHeader(59),
	}
	return obj
}

type BsnSetAuxCxnsRequest struct {
	*BsnHeader
	NumAux uint32
}

type IBsnSetAuxCxnsRequest interface {
	IBsnHeader
	GetNumAux() uint32
}

func (self *BsnSetAuxCxnsRequest) GetNumAux() uint32 {
	return self.NumAux
}

func (self *BsnSetAuxCxnsRequest) SetNumAux(v uint32) {
	self.NumAux = v
}

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

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

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

	return nil
}

func DecodeBsnSetAuxCxnsRequest(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnSetAuxCxnsRequest, error) {
	_bsnsetauxcxnsrequest := &BsnSetAuxCxnsRequest{BsnHeader: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("BsnSetAuxCxnsRequest packet too short: %d < 4", decoder.Length())
	}
	_bsnsetauxcxnsrequest.NumAux = uint32(decoder.ReadUint32())
	return _bsnsetauxcxnsrequest, nil
}

func NewBsnSetAuxCxnsRequest() *BsnSetAuxCxnsRequest {
	obj := &BsnSetAuxCxnsRequest{
		BsnHeader: NewBsnHeader(58),
	}
	return obj
}

type BsnSetLacpReply struct {
	*BsnHeader
	Status uint32
	PortNo Port
}

type IBsnSetLacpReply interface {
	IBsnHeader
	GetStatus() uint32
	GetPortNo() Port
}

func (self *BsnSetLacpReply) GetStatus() uint32 {
	return self.Status
}

func (self *BsnSetLacpReply) SetStatus(v uint32) {
	self.Status = v
}

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

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

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

	encoder.PutUint32(uint32(self.Status))
	self.PortNo.Serialize(encoder)
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeBsnSetLacpReply(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnSetLacpReply, error) {
	_bsnsetlacpreply := &BsnSetLacpReply{BsnHeader: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("BsnSetLacpReply packet too short: %d < 8", decoder.Length())
	}
	_bsnsetlacpreply.Status = uint32(decoder.ReadUint32())
	_bsnsetlacpreply.PortNo.Decode(decoder)
	return _bsnsetlacpreply, nil
}

func NewBsnSetLacpReply() *BsnSetLacpReply {
	obj := &BsnSetLacpReply{
		BsnHeader: NewBsnHeader(42),
	}
	return obj
}

type BsnSetLacpRequest struct {
	*BsnHeader
	Enabled           uint8
	PortNo            Port
	ActorSysPriority  uint16
	ActorSysMac       net.HardwareAddr
	ActorPortPriority uint16
	ActorPortNum      uint16
	ActorKey          uint16
}

type IBsnSetLacpRequest interface {
	IBsnHeader
	GetEnabled() uint8
	GetPortNo() Port
	GetActorSysPriority() uint16
	GetActorSysMac() net.HardwareAddr
	GetActorPortPriority() uint16
	GetActorPortNum() uint16
	GetActorKey() uint16
}

func (self *BsnSetLacpRequest) GetEnabled() uint8 {
	return self.Enabled
}

func (self *BsnSetLacpRequest) SetEnabled(v uint8) {
	self.Enabled = v
}

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

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

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

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

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

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

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

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

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

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

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

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

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

	encoder.PutUint8(uint8(self.Enabled))
	encoder.Write(bytes.Repeat([]byte{0}, 3))
	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))
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeBsnSetLacpRequest(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnSetLacpRequest, error) {
	_bsnsetlacprequest := &BsnSetLacpRequest{BsnHeader: parent}
	if decoder.Length() < 22 {
		return nil, fmt.Errorf("BsnSetLacpRequest packet too short: %d < 22", decoder.Length())
	}
	_bsnsetlacprequest.Enabled = uint8(decoder.ReadByte())
	decoder.Skip(3)
	_bsnsetlacprequest.PortNo.Decode(decoder)
	_bsnsetlacprequest.ActorSysPriority = uint16(decoder.ReadUint16())
	_bsnsetlacprequest.ActorSysMac = net.HardwareAddr(decoder.Read(6))
	_bsnsetlacprequest.ActorPortPriority = uint16(decoder.ReadUint16())
	_bsnsetlacprequest.ActorPortNum = uint16(decoder.ReadUint16())
	_bsnsetlacprequest.ActorKey = uint16(decoder.ReadUint16())
	return _bsnsetlacprequest, nil
}

func NewBsnSetLacpRequest() *BsnSetLacpRequest {
	obj := &BsnSetLacpRequest{
		BsnHeader: NewBsnHeader(41),
	}
	return obj
}

type BsnSetMirroring struct {
	*BsnHeader
	ReportMirrorPorts uint8
}

type IBsnSetMirroring interface {
	IBsnHeader
	GetReportMirrorPorts() uint8
}

func (self *BsnSetMirroring) GetReportMirrorPorts() uint8 {
	return self.ReportMirrorPorts
}

func (self *BsnSetMirroring) SetReportMirrorPorts(v uint8) {
	self.ReportMirrorPorts = v
}

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

	encoder.PutUint8(uint8(self.ReportMirrorPorts))
	encoder.Write(bytes.Repeat([]byte{0}, 3))
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeBsnSetMirroring(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnSetMirroring, error) {
	_bsnsetmirroring := &BsnSetMirroring{BsnHeader: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("BsnSetMirroring packet too short: %d < 4", decoder.Length())
	}
	_bsnsetmirroring.ReportMirrorPorts = uint8(decoder.ReadByte())
	decoder.Skip(3)
	return _bsnsetmirroring, nil
}

func NewBsnSetMirroring() *BsnSetMirroring {
	obj := &BsnSetMirroring{
		BsnHeader: NewBsnHeader(3),
	}
	return obj
}

type BsnSetPktinSuppressionReply struct {
	*BsnHeader
	Status uint32
}

type IBsnSetPktinSuppressionReply interface {
	IBsnHeader
	GetStatus() uint32
}

func (self *BsnSetPktinSuppressionReply) GetStatus() uint32 {
	return self.Status
}

func (self *BsnSetPktinSuppressionReply) SetStatus(v uint32) {
	self.Status = v
}

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

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

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

	return nil
}

func DecodeBsnSetPktinSuppressionReply(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnSetPktinSuppressionReply, error) {
	_bsnsetpktinsuppressionreply := &BsnSetPktinSuppressionReply{BsnHeader: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("BsnSetPktinSuppressionReply packet too short: %d < 4", decoder.Length())
	}
	_bsnsetpktinsuppressionreply.Status = uint32(decoder.ReadUint32())
	return _bsnsetpktinsuppressionreply, nil
}

func NewBsnSetPktinSuppressionReply() *BsnSetPktinSuppressionReply {
	obj := &BsnSetPktinSuppressionReply{
		BsnHeader: NewBsnHeader(25),
	}
	return obj
}

type BsnSetPktinSuppressionRequest struct {
	*BsnHeader
	Enabled     uint8
	IdleTimeout uint16
	HardTimeout uint16
	Priority    uint16
	Cookie      uint64
}

type IBsnSetPktinSuppressionRequest interface {
	IBsnHeader
	GetEnabled() uint8
	GetIdleTimeout() uint16
	GetHardTimeout() uint16
	GetPriority() uint16
	GetCookie() uint64
}

func (self *BsnSetPktinSuppressionRequest) GetEnabled() uint8 {
	return self.Enabled
}

func (self *BsnSetPktinSuppressionRequest) SetEnabled(v uint8) {
	self.Enabled = v
}

func (self *BsnSetPktinSuppressionRequest) GetIdleTimeout() uint16 {
	return self.IdleTimeout
}

func (self *BsnSetPktinSuppressionRequest) SetIdleTimeout(v uint16) {
	self.IdleTimeout = v
}

func (self *BsnSetPktinSuppressionRequest) GetHardTimeout() uint16 {
	return self.HardTimeout
}

func (self *BsnSetPktinSuppressionRequest) SetHardTimeout(v uint16) {
	self.HardTimeout = v
}

func (self *BsnSetPktinSuppressionRequest) GetPriority() uint16 {
	return self.Priority
}

func (self *BsnSetPktinSuppressionRequest) SetPriority(v uint16) {
	self.Priority = v
}

func (self *BsnSetPktinSuppressionRequest) GetCookie() uint64 {
	return self.Cookie
}

func (self *BsnSetPktinSuppressionRequest) SetCookie(v uint64) {
	self.Cookie = v
}

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

	encoder.PutUint8(uint8(self.Enabled))
	encoder.Write(bytes.Repeat([]byte{0}, 1))
	encoder.PutUint16(uint16(self.IdleTimeout))
	encoder.PutUint16(uint16(self.HardTimeout))
	encoder.PutUint16(uint16(self.Priority))
	encoder.PutUint64(uint64(self.Cookie))
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeBsnSetPktinSuppressionRequest(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnSetPktinSuppressionRequest, error) {
	_bsnsetpktinsuppressionrequest := &BsnSetPktinSuppressionRequest{BsnHeader: parent}
	if decoder.Length() < 16 {
		return nil, fmt.Errorf("BsnSetPktinSuppressionRequest packet too short: %d < 16", decoder.Length())
	}
	_bsnsetpktinsuppressionrequest.Enabled = uint8(decoder.ReadByte())
	decoder.Skip(1)
	_bsnsetpktinsuppressionrequest.IdleTimeout = uint16(decoder.ReadUint16())
	_bsnsetpktinsuppressionrequest.HardTimeout = uint16(decoder.ReadUint16())
	_bsnsetpktinsuppressionrequest.Priority = uint16(decoder.ReadUint16())
	_bsnsetpktinsuppressionrequest.Cookie = uint64(decoder.ReadUint64())
	return _bsnsetpktinsuppressionrequest, nil
}

func NewBsnSetPktinSuppressionRequest() *BsnSetPktinSuppressionRequest {
	obj := &BsnSetPktinSuppressionRequest{
		BsnHeader: NewBsnHeader(11),
	}
	return obj
}

type BsnSetSwitchPipelineReply struct {
	*BsnHeader
	Status uint32
}

type IBsnSetSwitchPipelineReply interface {
	IBsnHeader
	GetStatus() uint32
}

func (self *BsnSetSwitchPipelineReply) GetStatus() uint32 {
	return self.Status
}

func (self *BsnSetSwitchPipelineReply) SetStatus(v uint32) {
	self.Status = v
}

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

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

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

	return nil
}

func DecodeBsnSetSwitchPipelineReply(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnSetSwitchPipelineReply, error) {
	_bsnsetswitchpipelinereply := &BsnSetSwitchPipelineReply{BsnHeader: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("BsnSetSwitchPipelineReply packet too short: %d < 4", decoder.Length())
	}
	_bsnsetswitchpipelinereply.Status = uint32(decoder.ReadUint32())
	return _bsnsetswitchpipelinereply, nil
}

func NewBsnSetSwitchPipelineReply() *BsnSetSwitchPipelineReply {
	obj := &BsnSetSwitchPipelineReply{
		BsnHeader: NewBsnHeader(54),
	}
	return obj
}

type BsnSetSwitchPipelineRequest struct {
	*BsnHeader
	Pipeline string
}

type IBsnSetSwitchPipelineRequest interface {
	IBsnHeader
	GetPipeline() string
}

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

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

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

	encoder.Write([]byte(self.Pipeline))
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

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

func NewBsnSetSwitchPipelineRequest() *BsnSetSwitchPipelineRequest {
	obj := &BsnSetSwitchPipelineRequest{
		BsnHeader: NewBsnHeader(53),
	}
	return obj
}

type BsnSwitchPipelineStatsReply struct {
	*BsnStatsReply
	Entries []*BsnSwitchPipelineStatsEntry
}

type IBsnSwitchPipelineStatsReply interface {
	IBsnStatsReply
	GetEntries() []*BsnSwitchPipelineStatsEntry
}

func (self *BsnSwitchPipelineStatsReply) GetEntries() []*BsnSwitchPipelineStatsEntry {
	return self.Entries
}

func (self *BsnSwitchPipelineStatsReply) SetEntries(v []*BsnSwitchPipelineStatsEntry) {
	self.Entries = v
}

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

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

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

	return nil
}

func DecodeBsnSwitchPipelineStatsReply(parent *BsnStatsReply, decoder *goloxi.Decoder) (*BsnSwitchPipelineStatsReply, error) {
	_bsnswitchpipelinestatsreply := &BsnSwitchPipelineStatsReply{BsnStatsReply: parent}

	for decoder.Length() >= 256 {
		item, err := DecodeBsnSwitchPipelineStatsEntry(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_bsnswitchpipelinestatsreply.Entries = append(_bsnswitchpipelinestatsreply.Entries, item)
		}
	}
	return _bsnswitchpipelinestatsreply, nil
}

func NewBsnSwitchPipelineStatsReply() *BsnSwitchPipelineStatsReply {
	obj := &BsnSwitchPipelineStatsReply{
		BsnStatsReply: NewBsnStatsReply(6),
	}
	return obj
}

type BsnSwitchPipelineStatsRequest struct {
	*BsnStatsRequest
}

type IBsnSwitchPipelineStatsRequest interface {
	IBsnStatsRequest
}

func (self *BsnSwitchPipelineStatsRequest) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnStatsRequest.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 DecodeBsnSwitchPipelineStatsRequest(parent *BsnStatsRequest, decoder *goloxi.Decoder) (*BsnSwitchPipelineStatsRequest, error) {
	_bsnswitchpipelinestatsrequest := &BsnSwitchPipelineStatsRequest{BsnStatsRequest: parent}
	return _bsnswitchpipelinestatsrequest, nil
}

func NewBsnSwitchPipelineStatsRequest() *BsnSwitchPipelineStatsRequest {
	obj := &BsnSwitchPipelineStatsRequest{
		BsnStatsRequest: NewBsnStatsRequest(6),
	}
	return obj
}

type BsnTableChecksumStatsReply struct {
	*BsnStatsReply
	Entries []*BsnTableChecksumStatsEntry
}

type IBsnTableChecksumStatsReply interface {
	IBsnStatsReply
	GetEntries() []*BsnTableChecksumStatsEntry
}

func (self *BsnTableChecksumStatsReply) GetEntries() []*BsnTableChecksumStatsEntry {
	return self.Entries
}

func (self *BsnTableChecksumStatsReply) SetEntries(v []*BsnTableChecksumStatsEntry) {
	self.Entries = v
}

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

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

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

	return nil
}

func DecodeBsnTableChecksumStatsReply(parent *BsnStatsReply, decoder *goloxi.Decoder) (*BsnTableChecksumStatsReply, error) {
	_bsntablechecksumstatsreply := &BsnTableChecksumStatsReply{BsnStatsReply: parent}

	for decoder.Length() >= 9 {
		item, err := DecodeBsnTableChecksumStatsEntry(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_bsntablechecksumstatsreply.Entries = append(_bsntablechecksumstatsreply.Entries, item)
		}
	}
	return _bsntablechecksumstatsreply, nil
}

func NewBsnTableChecksumStatsReply() *BsnTableChecksumStatsReply {
	obj := &BsnTableChecksumStatsReply{
		BsnStatsReply: NewBsnStatsReply(11),
	}
	return obj
}

type BsnTableChecksumStatsRequest struct {
	*BsnStatsRequest
}

type IBsnTableChecksumStatsRequest interface {
	IBsnStatsRequest
}

func (self *BsnTableChecksumStatsRequest) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.BsnStatsRequest.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 DecodeBsnTableChecksumStatsRequest(parent *BsnStatsRequest, decoder *goloxi.Decoder) (*BsnTableChecksumStatsRequest, error) {
	_bsntablechecksumstatsrequest := &BsnTableChecksumStatsRequest{BsnStatsRequest: parent}
	return _bsntablechecksumstatsrequest, nil
}

func NewBsnTableChecksumStatsRequest() *BsnTableChecksumStatsRequest {
	obj := &BsnTableChecksumStatsRequest{
		BsnStatsRequest: NewBsnStatsRequest(11),
	}
	return obj
}

type BsnTableSetBucketsSize struct {
	*BsnHeader
	TableId     uint8
	BucketsSize uint32
}

type IBsnTableSetBucketsSize interface {
	IBsnHeader
	GetTableId() uint8
	GetBucketsSize() uint32
}

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

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

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

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

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

	encoder.Write(bytes.Repeat([]byte{0}, 1))
	encoder.PutUint8(uint8(self.TableId))
	encoder.Write(bytes.Repeat([]byte{0}, 2))
	encoder.PutUint32(uint32(self.BucketsSize))
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeBsnTableSetBucketsSize(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnTableSetBucketsSize, error) {
	_bsntablesetbucketssize := &BsnTableSetBucketsSize{BsnHeader: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("BsnTableSetBucketsSize packet too short: %d < 8", decoder.Length())
	}
	decoder.Skip(1)
	_bsntablesetbucketssize.TableId = uint8(decoder.ReadByte())
	decoder.Skip(2)
	_bsntablesetbucketssize.BucketsSize = uint32(decoder.ReadUint32())
	return _bsntablesetbucketssize, nil
}

func NewBsnTableSetBucketsSize() *BsnTableSetBucketsSize {
	obj := &BsnTableSetBucketsSize{
		BsnHeader: NewBsnHeader(61),
	}
	return obj
}

type BsnTakeover struct {
	*BsnHeader
}

type IBsnTakeover interface {
	IBsnHeader
}

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

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

	return nil
}

func DecodeBsnTakeover(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnTakeover, error) {
	_bsntakeover := &BsnTakeover{BsnHeader: parent}
	return _bsntakeover, nil
}

func NewBsnTakeover() *BsnTakeover {
	obj := &BsnTakeover{
		BsnHeader: NewBsnHeader(69),
	}
	return obj
}

type BsnTimeReply struct {
	*BsnHeader
	TimeMs uint64
}

type IBsnTimeReply interface {
	IBsnHeader
	GetTimeMs() uint64
}

func (self *BsnTimeReply) GetTimeMs() uint64 {
	return self.TimeMs
}

func (self *BsnTimeReply) SetTimeMs(v uint64) {
	self.TimeMs = v
}

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

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

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

	return nil
}

func DecodeBsnTimeReply(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnTimeReply, error) {
	_bsntimereply := &BsnTimeReply{BsnHeader: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("BsnTimeReply packet too short: %d < 8", decoder.Length())
	}
	_bsntimereply.TimeMs = uint64(decoder.ReadUint64())
	return _bsntimereply, nil
}

func NewBsnTimeReply() *BsnTimeReply {
	obj := &BsnTimeReply{
		BsnHeader: NewBsnHeader(45),
	}
	return obj
}

type BsnTimeRequest struct {
	*BsnHeader
}

type IBsnTimeRequest interface {
	IBsnHeader
}

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

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

	return nil
}

func DecodeBsnTimeRequest(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnTimeRequest, error) {
	_bsntimerequest := &BsnTimeRequest{BsnHeader: parent}
	return _bsntimerequest, nil
}

func NewBsnTimeRequest() *BsnTimeRequest {
	obj := &BsnTimeRequest{
		BsnHeader: NewBsnHeader(44),
	}
	return obj
}

type BsnVirtualPortCreateReply struct {
	*BsnHeader
	Status  uint32
	VportNo uint32
}

type IBsnVirtualPortCreateReply interface {
	IBsnHeader
	GetStatus() uint32
	GetVportNo() uint32
}

func (self *BsnVirtualPortCreateReply) GetStatus() uint32 {
	return self.Status
}

func (self *BsnVirtualPortCreateReply) SetStatus(v uint32) {
	self.Status = v
}

func (self *BsnVirtualPortCreateReply) GetVportNo() uint32 {
	return self.VportNo
}

func (self *BsnVirtualPortCreateReply) SetVportNo(v uint32) {
	self.VportNo = v
}

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

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

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

	return nil
}

func DecodeBsnVirtualPortCreateReply(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnVirtualPortCreateReply, error) {
	_bsnvirtualportcreatereply := &BsnVirtualPortCreateReply{BsnHeader: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("BsnVirtualPortCreateReply packet too short: %d < 8", decoder.Length())
	}
	_bsnvirtualportcreatereply.Status = uint32(decoder.ReadUint32())
	_bsnvirtualportcreatereply.VportNo = uint32(decoder.ReadUint32())
	return _bsnvirtualportcreatereply, nil
}

func NewBsnVirtualPortCreateReply() *BsnVirtualPortCreateReply {
	obj := &BsnVirtualPortCreateReply{
		BsnHeader: NewBsnHeader(16),
	}
	return obj
}

type BsnVirtualPortCreateRequest struct {
	*BsnHeader
	Vport BSNVport
}

type IBsnVirtualPortCreateRequest interface {
	IBsnHeader
	GetVport() BSNVport
}

func (self *BsnVirtualPortCreateRequest) GetVport() BSNVport {
	return self.Vport
}

func (self *BsnVirtualPortCreateRequest) SetVport(v BSNVport) {
	self.Vport = v
}

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

	if err := self.Vport.Serialize(encoder); err != nil {
		return err
	}

	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeBsnVirtualPortCreateRequest(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnVirtualPortCreateRequest, error) {
	_bsnvirtualportcreaterequest := &BsnVirtualPortCreateRequest{BsnHeader: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("BsnVirtualPortCreateRequest packet too short: %d < 4", decoder.Length())
	}
	if err := _bsnvirtualportcreaterequest.Vport.Decode(decoder); err != nil {
		return nil, err
	}

	return _bsnvirtualportcreaterequest, nil
}

func NewBsnVirtualPortCreateRequest() *BsnVirtualPortCreateRequest {
	obj := &BsnVirtualPortCreateRequest{
		BsnHeader: NewBsnHeader(15),
	}
	return obj
}

type BsnVirtualPortRemoveReply struct {
	*BsnHeader
	Status uint32
}

type IBsnVirtualPortRemoveReply interface {
	IBsnHeader
	GetStatus() uint32
}

func (self *BsnVirtualPortRemoveReply) GetStatus() uint32 {
	return self.Status
}

func (self *BsnVirtualPortRemoveReply) SetStatus(v uint32) {
	self.Status = v
}

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

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

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

	return nil
}

func DecodeBsnVirtualPortRemoveReply(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnVirtualPortRemoveReply, error) {
	_bsnvirtualportremovereply := &BsnVirtualPortRemoveReply{BsnHeader: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("BsnVirtualPortRemoveReply packet too short: %d < 4", decoder.Length())
	}
	_bsnvirtualportremovereply.Status = uint32(decoder.ReadUint32())
	return _bsnvirtualportremovereply, nil
}

func NewBsnVirtualPortRemoveReply() *BsnVirtualPortRemoveReply {
	obj := &BsnVirtualPortRemoveReply{
		BsnHeader: NewBsnHeader(26),
	}
	return obj
}

type BsnVirtualPortRemoveRequest struct {
	*BsnHeader
	VportNo uint32
}

type IBsnVirtualPortRemoveRequest interface {
	IBsnHeader
	GetVportNo() uint32
}

func (self *BsnVirtualPortRemoveRequest) GetVportNo() uint32 {
	return self.VportNo
}

func (self *BsnVirtualPortRemoveRequest) SetVportNo(v uint32) {
	self.VportNo = v
}

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

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

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

	return nil
}

func DecodeBsnVirtualPortRemoveRequest(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnVirtualPortRemoveRequest, error) {
	_bsnvirtualportremoverequest := &BsnVirtualPortRemoveRequest{BsnHeader: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("BsnVirtualPortRemoveRequest packet too short: %d < 4", decoder.Length())
	}
	_bsnvirtualportremoverequest.VportNo = uint32(decoder.ReadUint32())
	return _bsnvirtualportremoverequest, nil
}

func NewBsnVirtualPortRemoveRequest() *BsnVirtualPortRemoveRequest {
	obj := &BsnVirtualPortRemoveRequest{
		BsnHeader: NewBsnHeader(17),
	}
	return obj
}

type BsnVlanCounterClear struct {
	*BsnHeader
	VlanVid uint16
}

type IBsnVlanCounterClear interface {
	IBsnHeader
	GetVlanVid() uint16
}

func (self *BsnVlanCounterClear) GetVlanVid() uint16 {
	return self.VlanVid
}

func (self *BsnVlanCounterClear) SetVlanVid(v uint16) {
	self.VlanVid = v
}

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

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

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

	return nil
}

func DecodeBsnVlanCounterClear(parent *BsnHeader, decoder *goloxi.Decoder) (*BsnVlanCounterClear, error) {
	_bsnvlancounterclear := &BsnVlanCounterClear{BsnHeader: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("BsnVlanCounterClear packet too short: %d < 2", decoder.Length())
	}
	_bsnvlancounterclear.VlanVid = uint16(decoder.ReadUint16())
	return _bsnvlancounterclear, nil
}

func NewBsnVlanCounterClear() *BsnVlanCounterClear {
	obj := &BsnVlanCounterClear{
		BsnHeader: NewBsnHeader(70),
	}
	return obj
}

type BsnVlanCounterStatsReply struct {
	*BsnStatsReply
	Entries []*BsnVlanCounterStatsEntry
}

type IBsnVlanCounterStatsReply interface {
	IBsnStatsReply
	GetEntries() []*BsnVlanCounterStatsEntry
}

func (self *BsnVlanCounterStatsReply) GetEntries() []*BsnVlanCounterStatsEntry {
	return self.Entries
}

func (self *BsnVlanCounterStatsReply) SetEntries(v []*BsnVlanCounterStatsEntry) {
	self.Entries = v
}

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

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

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

	return nil
}

func DecodeBsnVlanCounterStatsReply(parent *BsnStatsReply, decoder *goloxi.Decoder) (*BsnVlanCounterStatsReply, error) {
	_bsnvlancounterstatsreply := &BsnVlanCounterStatsReply{BsnStatsReply: parent}

	for decoder.Length() >= 8 {
		item, err := DecodeBsnVlanCounterStatsEntry(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_bsnvlancounterstatsreply.Entries = append(_bsnvlancounterstatsreply.Entries, item)
		}
	}
	return _bsnvlancounterstatsreply, nil
}

func NewBsnVlanCounterStatsReply() *BsnVlanCounterStatsReply {
	obj := &BsnVlanCounterStatsReply{
		BsnStatsReply: NewBsnStatsReply(9),
	}
	return obj
}

type BsnVlanCounterStatsRequest struct {
	*BsnStatsRequest
	VlanVid uint16
}

type IBsnVlanCounterStatsRequest interface {
	IBsnStatsRequest
	GetVlanVid() uint16
}

func (self *BsnVlanCounterStatsRequest) GetVlanVid() uint16 {
	return self.VlanVid
}

func (self *BsnVlanCounterStatsRequest) SetVlanVid(v uint16) {
	self.VlanVid = v
}

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

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

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

	return nil
}

func DecodeBsnVlanCounterStatsRequest(parent *BsnStatsRequest, decoder *goloxi.Decoder) (*BsnVlanCounterStatsRequest, error) {
	_bsnvlancounterstatsrequest := &BsnVlanCounterStatsRequest{BsnStatsRequest: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("BsnVlanCounterStatsRequest packet too short: %d < 2", decoder.Length())
	}
	_bsnvlancounterstatsrequest.VlanVid = uint16(decoder.ReadUint16())
	return _bsnvlancounterstatsrequest, nil
}

func NewBsnVlanCounterStatsRequest() *BsnVlanCounterStatsRequest {
	obj := &BsnVlanCounterStatsRequest{
		BsnStatsRequest: NewBsnStatsRequest(9),
	}
	return obj
}

type BsnVrfCounterStatsReply struct {
	*BsnStatsReply
	Entries []*BsnVrfCounterStatsEntry
}

type IBsnVrfCounterStatsReply interface {
	IBsnStatsReply
	GetEntries() []*BsnVrfCounterStatsEntry
}

func (self *BsnVrfCounterStatsReply) GetEntries() []*BsnVrfCounterStatsEntry {
	return self.Entries
}

func (self *BsnVrfCounterStatsReply) SetEntries(v []*BsnVrfCounterStatsEntry) {
	self.Entries = v
}

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

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

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

	return nil
}

func DecodeBsnVrfCounterStatsReply(parent *BsnStatsReply, decoder *goloxi.Decoder) (*BsnVrfCounterStatsReply, error) {
	_bsnvrfcounterstatsreply := &BsnVrfCounterStatsReply{BsnStatsReply: parent}

	for decoder.Length() >= 8 {
		item, err := DecodeBsnVrfCounterStatsEntry(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_bsnvrfcounterstatsreply.Entries = append(_bsnvrfcounterstatsreply.Entries, item)
		}
	}
	return _bsnvrfcounterstatsreply, nil
}

func NewBsnVrfCounterStatsReply() *BsnVrfCounterStatsReply {
	obj := &BsnVrfCounterStatsReply{
		BsnStatsReply: NewBsnStatsReply(15),
	}
	return obj
}

type BsnVrfCounterStatsRequest struct {
	*BsnStatsRequest
	Vrf uint32
}

type IBsnVrfCounterStatsRequest interface {
	IBsnStatsRequest
	GetVrf() uint32
}

func (self *BsnVrfCounterStatsRequest) GetVrf() uint32 {
	return self.Vrf
}

func (self *BsnVrfCounterStatsRequest) SetVrf(v uint32) {
	self.Vrf = v
}

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

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

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

	return nil
}

func DecodeBsnVrfCounterStatsRequest(parent *BsnStatsRequest, decoder *goloxi.Decoder) (*BsnVrfCounterStatsRequest, error) {
	_bsnvrfcounterstatsrequest := &BsnVrfCounterStatsRequest{BsnStatsRequest: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("BsnVrfCounterStatsRequest packet too short: %d < 4", decoder.Length())
	}
	_bsnvrfcounterstatsrequest.Vrf = uint32(decoder.ReadUint32())
	return _bsnvrfcounterstatsrequest, nil
}

func NewBsnVrfCounterStatsRequest() *BsnVrfCounterStatsRequest {
	obj := &BsnVrfCounterStatsRequest{
		BsnStatsRequest: NewBsnStatsRequest(15),
	}
	return obj
}

type BundleAddMsg struct {
	*Header
	BundleId uint32
	Flags    BundleFlags
	Data     []byte
}

type IBundleAddMsg interface {
	IHeader
	GetBundleId() uint32
	GetFlags() BundleFlags
	GetData() []byte
}

func (self *BundleAddMsg) GetBundleId() uint32 {
	return self.BundleId
}

func (self *BundleAddMsg) SetBundleId(v uint32) {
	self.BundleId = v
}

func (self *BundleAddMsg) GetFlags() BundleFlags {
	return self.Flags
}

func (self *BundleAddMsg) SetFlags(v BundleFlags) {
	self.Flags = v
}

func (self *BundleAddMsg) GetData() []byte {
	return self.Data
}

func (self *BundleAddMsg) SetData(v []byte) {
	self.Data = v
}

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

	encoder.PutUint32(uint32(self.BundleId))
	encoder.Write(bytes.Repeat([]byte{0}, 2))
	encoder.PutUint16(uint16(self.Flags))
	encoder.Write(self.Data)
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeBundleAddMsg(parent *Header, decoder *goloxi.Decoder) (*BundleAddMsg, error) {
	_bundleaddmsg := &BundleAddMsg{Header: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("BundleAddMsg packet too short: %d < 8", decoder.Length())
	}
	_bundleaddmsg.BundleId = uint32(decoder.ReadUint32())
	decoder.Skip(2)
	_bundleaddmsg.Flags = BundleFlags(decoder.ReadUint16())
	_bundleaddmsg.Data = decoder.Read(int(decoder.Length()))
	return _bundleaddmsg, nil
}

func NewBundleAddMsg() *BundleAddMsg {
	obj := &BundleAddMsg{
		Header: NewHeader(34),
	}
	return obj
}

type BundleCtrlMsg struct {
	*Header
	BundleId       uint32
	BundleCtrlType BundleCtrlType
	Flags          BundleFlags
	Properties     []IBundleProp
}

type IBundleCtrlMsg interface {
	IHeader
	GetBundleId() uint32
	GetBundleCtrlType() BundleCtrlType
	GetFlags() BundleFlags
	GetProperties() []IBundleProp
}

func (self *BundleCtrlMsg) GetBundleId() uint32 {
	return self.BundleId
}

func (self *BundleCtrlMsg) SetBundleId(v uint32) {
	self.BundleId = v
}

func (self *BundleCtrlMsg) GetBundleCtrlType() BundleCtrlType {
	return self.BundleCtrlType
}

func (self *BundleCtrlMsg) SetBundleCtrlType(v BundleCtrlType) {
	self.BundleCtrlType = v
}

func (self *BundleCtrlMsg) GetFlags() BundleFlags {
	return self.Flags
}

func (self *BundleCtrlMsg) SetFlags(v BundleFlags) {
	self.Flags = v
}

func (self *BundleCtrlMsg) GetProperties() []IBundleProp {
	return self.Properties
}

func (self *BundleCtrlMsg) SetProperties(v []IBundleProp) {
	self.Properties = v
}

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

	encoder.PutUint32(uint32(self.BundleId))
	encoder.PutUint16(uint16(self.BundleCtrlType))
	encoder.PutUint16(uint16(self.Flags))
	for _, obj := range self.Properties {
		if err := obj.Serialize(encoder); err != nil {
			return err
		}
	}
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeBundleCtrlMsg(parent *Header, decoder *goloxi.Decoder) (*BundleCtrlMsg, error) {
	_bundlectrlmsg := &BundleCtrlMsg{Header: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("BundleCtrlMsg packet too short: %d < 8", decoder.Length())
	}
	_bundlectrlmsg.BundleId = uint32(decoder.ReadUint32())
	_bundlectrlmsg.BundleCtrlType = BundleCtrlType(decoder.ReadUint16())
	_bundlectrlmsg.Flags = BundleFlags(decoder.ReadUint16())

	for decoder.Length() >= 4 {
		item, err := DecodeBundleProp(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_bundlectrlmsg.Properties = append(_bundlectrlmsg.Properties, item)
		}
	}
	return _bundlectrlmsg, nil
}

func NewBundleCtrlMsg() *BundleCtrlMsg {
	obj := &BundleCtrlMsg{
		Header: NewHeader(33),
	}
	return obj
}

type BundleFailedErrorMsg struct {
	*ErrorMsg
	Code BundleFailedCode
	Data []byte
}

type IBundleFailedErrorMsg interface {
	IErrorMsg
	GetCode() BundleFailedCode
	GetData() []byte
}

func (self *BundleFailedErrorMsg) GetCode() BundleFailedCode {
	return self.Code
}

func (self *BundleFailedErrorMsg) SetCode(v BundleFailedCode) {
	self.Code = v
}

func (self *BundleFailedErrorMsg) GetData() []byte {
	return self.Data
}

func (self *BundleFailedErrorMsg) SetData(v []byte) {
	self.Data = v
}

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

	encoder.PutUint16(uint16(self.Code))
	encoder.Write(self.Data)
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeBundleFailedErrorMsg(parent *ErrorMsg, decoder *goloxi.Decoder) (*BundleFailedErrorMsg, error) {
	_bundlefailederrormsg := &BundleFailedErrorMsg{ErrorMsg: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("BundleFailedErrorMsg packet too short: %d < 2", decoder.Length())
	}
	_bundlefailederrormsg.Code = BundleFailedCode(decoder.ReadUint16())
	_bundlefailederrormsg.Data = decoder.Read(int(decoder.Length()))
	return _bundlefailederrormsg, nil
}

func NewBundleFailedErrorMsg() *BundleFailedErrorMsg {
	obj := &BundleFailedErrorMsg{
		ErrorMsg: NewErrorMsg(17),
	}
	return obj
}

type DescStatsReply struct {
	*StatsReply
	MfrDesc   string
	HwDesc    string
	SwDesc    string
	SerialNum string
	DpDesc    string
}

type IDescStatsReply interface {
	IStatsReply
	GetMfrDesc() string
	GetHwDesc() string
	GetSwDesc() string
	GetSerialNum() string
	GetDpDesc() string
}

func (self *DescStatsReply) GetMfrDesc() string {
	return self.MfrDesc
}

func (self *DescStatsReply) SetMfrDesc(v string) {
	self.MfrDesc = v
}

func (self *DescStatsReply) GetHwDesc() string {
	return self.HwDesc
}

func (self *DescStatsReply) SetHwDesc(v string) {
	self.HwDesc = v
}

func (self *DescStatsReply) GetSwDesc() string {
	return self.SwDesc
}

func (self *DescStatsReply) SetSwDesc(v string) {
	self.SwDesc = v
}

func (self *DescStatsReply) GetSerialNum() string {
	return self.SerialNum
}

func (self *DescStatsReply) SetSerialNum(v string) {
	self.SerialNum = v
}

func (self *DescStatsReply) GetDpDesc() string {
	return self.DpDesc
}

func (self *DescStatsReply) SetDpDesc(v string) {
	self.DpDesc = v
}

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

	encoder.Write(bytes.Repeat([]byte{0}, 4))
	encoder.Write([]byte(self.MfrDesc))
	encoder.Write([]byte(self.HwDesc))
	encoder.Write([]byte(self.SwDesc))
	encoder.Write([]byte(self.SerialNum))
	encoder.Write([]byte(self.DpDesc))
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeDescStatsReply(parent *StatsReply, decoder *goloxi.Decoder) (*DescStatsReply, error) {
	_descstatsreply := &DescStatsReply{StatsReply: parent}
	if decoder.Length() < 1060 {
		return nil, fmt.Errorf("DescStatsReply packet too short: %d < 1060", decoder.Length())
	}
	decoder.Skip(4)
	_descstatsreply.MfrDesc = string(bytes.Trim(decoder.Read(256), "\x00"))
	_descstatsreply.HwDesc = string(bytes.Trim(decoder.Read(256), "\x00"))
	_descstatsreply.SwDesc = string(bytes.Trim(decoder.Read(256), "\x00"))
	_descstatsreply.SerialNum = string(bytes.Trim(decoder.Read(32), "\x00"))
	_descstatsreply.DpDesc = string(bytes.Trim(decoder.Read(256), "\x00"))
	return _descstatsreply, nil
}

func NewDescStatsReply() *DescStatsReply {
	obj := &DescStatsReply{
		StatsReply: NewStatsReply(0),
	}
	return obj
}

type DescStatsRequest struct {
	*StatsRequest
}

type IDescStatsRequest interface {
	IStatsRequest
}

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

	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 DecodeDescStatsRequest(parent *StatsRequest, decoder *goloxi.Decoder) (*DescStatsRequest, error) {
	_descstatsrequest := &DescStatsRequest{StatsRequest: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("DescStatsRequest packet too short: %d < 4", decoder.Length())
	}
	decoder.Skip(4)
	return _descstatsrequest, nil
}

func NewDescStatsRequest() *DescStatsRequest {
	obj := &DescStatsRequest{
		StatsRequest: NewStatsRequest(0),
	}
	return obj
}

type EchoReply struct {
	*Header
	Data []byte
}

type IEchoReply interface {
	IHeader
	GetData() []byte
}

func (self *EchoReply) GetData() []byte {
	return self.Data
}

func (self *EchoReply) SetData(v []byte) {
	self.Data = v
}

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

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

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

	return nil
}

func DecodeEchoReply(parent *Header, decoder *goloxi.Decoder) (*EchoReply, error) {
	_echoreply := &EchoReply{Header: parent}
	_echoreply.Data = decoder.Read(int(decoder.Length()))
	return _echoreply, nil
}

func NewEchoReply() *EchoReply {
	obj := &EchoReply{
		Header: NewHeader(3),
	}
	return obj
}

type EchoRequest struct {
	*Header
	Data []byte
}

type IEchoRequest interface {
	IHeader
	GetData() []byte
}

func (self *EchoRequest) GetData() []byte {
	return self.Data
}

func (self *EchoRequest) SetData(v []byte) {
	self.Data = v
}

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

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

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

	return nil
}

func DecodeEchoRequest(parent *Header, decoder *goloxi.Decoder) (*EchoRequest, error) {
	_echorequest := &EchoRequest{Header: parent}
	_echorequest.Data = decoder.Read(int(decoder.Length()))
	return _echorequest, nil
}

func NewEchoRequest() *EchoRequest {
	obj := &EchoRequest{
		Header: NewHeader(2),
	}
	return obj
}

type FeaturesReply struct {
	*Header
	DatapathId   uint64
	NBuffers     uint32
	NTables      uint8
	AuxiliaryId  uint8
	Capabilities Capabilities
	Reserved     uint32
}

type IFeaturesReply interface {
	IHeader
	GetDatapathId() uint64
	GetNBuffers() uint32
	GetNTables() uint8
	GetAuxiliaryId() uint8
	GetCapabilities() Capabilities
	GetReserved() uint32
}

func (self *FeaturesReply) GetDatapathId() uint64 {
	return self.DatapathId
}

func (self *FeaturesReply) SetDatapathId(v uint64) {
	self.DatapathId = v
}

func (self *FeaturesReply) GetNBuffers() uint32 {
	return self.NBuffers
}

func (self *FeaturesReply) SetNBuffers(v uint32) {
	self.NBuffers = v
}

func (self *FeaturesReply) GetNTables() uint8 {
	return self.NTables
}

func (self *FeaturesReply) SetNTables(v uint8) {
	self.NTables = v
}

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

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

func (self *FeaturesReply) GetCapabilities() Capabilities {
	return self.Capabilities
}

func (self *FeaturesReply) SetCapabilities(v Capabilities) {
	self.Capabilities = v
}

func (self *FeaturesReply) GetReserved() uint32 {
	return self.Reserved
}

func (self *FeaturesReply) SetReserved(v uint32) {
	self.Reserved = v
}

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

	encoder.PutUint64(uint64(self.DatapathId))
	encoder.PutUint32(uint32(self.NBuffers))
	encoder.PutUint8(uint8(self.NTables))
	encoder.PutUint8(uint8(self.AuxiliaryId))
	encoder.Write(bytes.Repeat([]byte{0}, 2))
	encoder.PutUint32(uint32(self.Capabilities))
	encoder.PutUint32(uint32(self.Reserved))
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeFeaturesReply(parent *Header, decoder *goloxi.Decoder) (*FeaturesReply, error) {
	_featuresreply := &FeaturesReply{Header: parent}
	if decoder.Length() < 24 {
		return nil, fmt.Errorf("FeaturesReply packet too short: %d < 24", decoder.Length())
	}
	_featuresreply.DatapathId = uint64(decoder.ReadUint64())
	_featuresreply.NBuffers = uint32(decoder.ReadUint32())
	_featuresreply.NTables = uint8(decoder.ReadByte())
	_featuresreply.AuxiliaryId = uint8(decoder.ReadByte())
	decoder.Skip(2)
	_featuresreply.Capabilities = Capabilities(decoder.ReadUint32())
	_featuresreply.Reserved = uint32(decoder.ReadUint32())
	return _featuresreply, nil
}

func NewFeaturesReply() *FeaturesReply {
	obj := &FeaturesReply{
		Header: NewHeader(6),
	}
	return obj
}

type FeaturesRequest struct {
	*Header
}

type IFeaturesRequest interface {
	IHeader
}

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

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

	return nil
}

func DecodeFeaturesRequest(parent *Header, decoder *goloxi.Decoder) (*FeaturesRequest, error) {
	_featuresrequest := &FeaturesRequest{Header: parent}
	return _featuresrequest, nil
}

func NewFeaturesRequest() *FeaturesRequest {
	obj := &FeaturesRequest{
		Header: NewHeader(5),
	}
	return obj
}

type FlowMod struct {
	*Header
	Cookie       uint64
	CookieMask   uint64
	TableId      uint8
	Command      FmCmd
	IdleTimeout  uint16
	HardTimeout  uint16
	Priority     uint16
	BufferId     uint32
	OutPort      Port
	OutGroup     uint32
	Flags        FlowModFlags
	Match        Match
	Instructions []IInstruction
}

type IFlowMod interface {
	IHeader
	GetCookie() uint64
	GetCookieMask() uint64
	GetTableId() uint8
	GetCommand() FmCmd
	GetIdleTimeout() uint16
	GetHardTimeout() uint16
	GetPriority() uint16
	GetBufferId() uint32
	GetOutPort() Port
	GetOutGroup() uint32
	GetFlags() FlowModFlags
	GetMatch() Match
	GetInstructions() []IInstruction
}

func (self *FlowMod) GetCookie() uint64 {
	return self.Cookie
}

func (self *FlowMod) SetCookie(v uint64) {
	self.Cookie = v
}

func (self *FlowMod) GetCookieMask() uint64 {
	return self.CookieMask
}

func (self *FlowMod) SetCookieMask(v uint64) {
	self.CookieMask = v
}

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

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

func (self *FlowMod) GetCommand() FmCmd {
	return self.Command
}

func (self *FlowMod) SetCommand(v FmCmd) {
	self.Command = v
}

func (self *FlowMod) GetIdleTimeout() uint16 {
	return self.IdleTimeout
}

func (self *FlowMod) SetIdleTimeout(v uint16) {
	self.IdleTimeout = v
}

func (self *FlowMod) GetHardTimeout() uint16 {
	return self.HardTimeout
}

func (self *FlowMod) SetHardTimeout(v uint16) {
	self.HardTimeout = v
}

func (self *FlowMod) GetPriority() uint16 {
	return self.Priority
}

func (self *FlowMod) SetPriority(v uint16) {
	self.Priority = v
}

func (self *FlowMod) GetBufferId() uint32 {
	return self.BufferId
}

func (self *FlowMod) SetBufferId(v uint32) {
	self.BufferId = v
}

func (self *FlowMod) GetOutPort() Port {
	return self.OutPort
}

func (self *FlowMod) SetOutPort(v Port) {
	self.OutPort = v
}

func (self *FlowMod) GetOutGroup() uint32 {
	return self.OutGroup
}

func (self *FlowMod) SetOutGroup(v uint32) {
	self.OutGroup = v
}

func (self *FlowMod) GetFlags() FlowModFlags {
	return self.Flags
}

func (self *FlowMod) SetFlags(v FlowModFlags) {
	self.Flags = v
}

func (self *FlowMod) GetMatch() Match {
	return self.Match
}

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

func (self *FlowMod) GetInstructions() []IInstruction {
	return self.Instructions
}

func (self *FlowMod) SetInstructions(v []IInstruction) {
	self.Instructions = v
}

func (self *FlowMod) Serialize(encoder *goloxi.Encoder) error {
	if err := self.Header.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint64(uint64(self.Cookie))
	encoder.PutUint64(uint64(self.CookieMask))
	encoder.PutUint8(uint8(self.TableId))
	self.Command.Serialize(encoder)
	encoder.PutUint16(uint16(self.IdleTimeout))
	encoder.PutUint16(uint16(self.HardTimeout))
	encoder.PutUint16(uint16(self.Priority))
	encoder.PutUint32(uint32(self.BufferId))
	self.OutPort.Serialize(encoder)
	encoder.PutUint32(uint32(self.OutGroup))
	encoder.PutUint16(uint16(self.Flags))
	encoder.Write(bytes.Repeat([]byte{0}, 2))
	if err := self.Match.Serialize(encoder); err != nil {
		return err
	}

	for _, obj := range self.Instructions {
		if err := obj.Serialize(encoder); err != nil {
			return err
		}
	}

	return nil
}

func DecodeFlowMod(parent *Header, decoder *goloxi.Decoder) (IFlowMod, error) {
	_flowmod := &FlowMod{Header: parent}
	if decoder.Length() < 48 {
		return nil, fmt.Errorf("FlowMod packet too short: %d < 48", decoder.Length())
	}
	_flowmod.Cookie = uint64(decoder.ReadUint64())
	_flowmod.CookieMask = uint64(decoder.ReadUint64())
	_flowmod.TableId = uint8(decoder.ReadByte())
	_flowmod.Command.Decode(decoder)
	_flowmod.IdleTimeout = uint16(decoder.ReadUint16())
	_flowmod.HardTimeout = uint16(decoder.ReadUint16())
	_flowmod.Priority = uint16(decoder.ReadUint16())
	_flowmod.BufferId = uint32(decoder.ReadUint32())
	_flowmod.OutPort.Decode(decoder)
	_flowmod.OutGroup = uint32(decoder.ReadUint32())
	_flowmod.Flags = FlowModFlags(decoder.ReadUint16())
	decoder.Skip(2)
	if err := _flowmod.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 {
			_flowmod.Instructions = append(_flowmod.Instructions, item)
		}
	}

	switch _flowmod.Command {
	case 0:
		return DecodeFlowAdd(_flowmod, decoder)
	case 1:
		return DecodeFlowModify(_flowmod, decoder)
	case 2:
		return DecodeFlowModifyStrict(_flowmod, decoder)
	case 3:
		return DecodeFlowDelete(_flowmod, decoder)
	case 4:
		return DecodeFlowDeleteStrict(_flowmod, decoder)
	default:
		return nil, fmt.Errorf("Invalid type '%d' for 'FlowMod'", _flowmod.Command)
	}
}

func NewFlowMod(__command FmCmd) *FlowMod {
	obj := &FlowMod{
		Header: NewHeader(14),
	}
	obj.Command = __command
	return obj
}

type FlowAdd struct {
	*FlowMod
	Importance uint16
}

type IFlowAdd interface {
	IFlowMod
	GetImportance() uint16
}

func (self *FlowAdd) GetImportance() uint16 {
	return self.Importance
}

func (self *FlowAdd) SetImportance(v uint16) {
	self.Importance = v
}

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

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

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

	return nil
}

func DecodeFlowAdd(parent *FlowMod, decoder *goloxi.Decoder) (*FlowAdd, error) {
	_flowadd := &FlowAdd{FlowMod: parent}
	if decoder.Length() < 10 {
		return nil, fmt.Errorf("FlowAdd packet too short: %d < 10", decoder.Length())
	}
	_flowadd.Importance = uint16(decoder.ReadUint16())
	return _flowadd, nil
}

func NewFlowAdd() *FlowAdd {
	obj := &FlowAdd{
		FlowMod: NewFlowMod(0),
	}
	return obj
}

type FlowDelete struct {
	*FlowMod
	Importance uint16
}

type IFlowDelete interface {
	IFlowMod
	GetImportance() uint16
}

func (self *FlowDelete) GetImportance() uint16 {
	return self.Importance
}

func (self *FlowDelete) SetImportance(v uint16) {
	self.Importance = v
}

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

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

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

	return nil
}

func DecodeFlowDelete(parent *FlowMod, decoder *goloxi.Decoder) (*FlowDelete, error) {
	_flowdelete := &FlowDelete{FlowMod: parent}
	if decoder.Length() < 10 {
		return nil, fmt.Errorf("FlowDelete packet too short: %d < 10", decoder.Length())
	}
	_flowdelete.Importance = uint16(decoder.ReadUint16())
	return _flowdelete, nil
}

func NewFlowDelete() *FlowDelete {
	obj := &FlowDelete{
		FlowMod: NewFlowMod(3),
	}
	return obj
}

type FlowDeleteStrict struct {
	*FlowMod
	Importance uint16
}

type IFlowDeleteStrict interface {
	IFlowMod
	GetImportance() uint16
}

func (self *FlowDeleteStrict) GetImportance() uint16 {
	return self.Importance
}

func (self *FlowDeleteStrict) SetImportance(v uint16) {
	self.Importance = v
}

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

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

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

	return nil
}

func DecodeFlowDeleteStrict(parent *FlowMod, decoder *goloxi.Decoder) (*FlowDeleteStrict, error) {
	_flowdeletestrict := &FlowDeleteStrict{FlowMod: parent}
	if decoder.Length() < 10 {
		return nil, fmt.Errorf("FlowDeleteStrict packet too short: %d < 10", decoder.Length())
	}
	_flowdeletestrict.Importance = uint16(decoder.ReadUint16())
	return _flowdeletestrict, nil
}

func NewFlowDeleteStrict() *FlowDeleteStrict {
	obj := &FlowDeleteStrict{
		FlowMod: NewFlowMod(4),
	}
	return obj
}

type FlowModFailedErrorMsg struct {
	*ErrorMsg
	Code FlowModFailedCode
	Data []byte
}

type IFlowModFailedErrorMsg interface {
	IErrorMsg
	GetCode() FlowModFailedCode
	GetData() []byte
}

func (self *FlowModFailedErrorMsg) GetCode() FlowModFailedCode {
	return self.Code
}

func (self *FlowModFailedErrorMsg) SetCode(v FlowModFailedCode) {
	self.Code = v
}

func (self *FlowModFailedErrorMsg) GetData() []byte {
	return self.Data
}

func (self *FlowModFailedErrorMsg) SetData(v []byte) {
	self.Data = v
}

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

	encoder.PutUint16(uint16(self.Code))
	encoder.Write(self.Data)
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeFlowModFailedErrorMsg(parent *ErrorMsg, decoder *goloxi.Decoder) (*FlowModFailedErrorMsg, error) {
	_flowmodfailederrormsg := &FlowModFailedErrorMsg{ErrorMsg: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("FlowModFailedErrorMsg packet too short: %d < 2", decoder.Length())
	}
	_flowmodfailederrormsg.Code = FlowModFailedCode(decoder.ReadUint16())
	_flowmodfailederrormsg.Data = decoder.Read(int(decoder.Length()))
	return _flowmodfailederrormsg, nil
}

func NewFlowModFailedErrorMsg() *FlowModFailedErrorMsg {
	obj := &FlowModFailedErrorMsg{
		ErrorMsg: NewErrorMsg(5),
	}
	return obj
}

type FlowModify struct {
	*FlowMod
	Importance uint16
}

type IFlowModify interface {
	IFlowMod
	GetImportance() uint16
}

func (self *FlowModify) GetImportance() uint16 {
	return self.Importance
}

func (self *FlowModify) SetImportance(v uint16) {
	self.Importance = v
}

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

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

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

	return nil
}

func DecodeFlowModify(parent *FlowMod, decoder *goloxi.Decoder) (*FlowModify, error) {
	_flowmodify := &FlowModify{FlowMod: parent}
	if decoder.Length() < 10 {
		return nil, fmt.Errorf("FlowModify packet too short: %d < 10", decoder.Length())
	}
	_flowmodify.Importance = uint16(decoder.ReadUint16())
	return _flowmodify, nil
}

func NewFlowModify() *FlowModify {
	obj := &FlowModify{
		FlowMod: NewFlowMod(1),
	}
	return obj
}

type FlowModifyStrict struct {
	*FlowMod
	Importance uint16
}

type IFlowModifyStrict interface {
	IFlowMod
	GetImportance() uint16
}

func (self *FlowModifyStrict) GetImportance() uint16 {
	return self.Importance
}

func (self *FlowModifyStrict) SetImportance(v uint16) {
	self.Importance = v
}

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

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

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

	return nil
}

func DecodeFlowModifyStrict(parent *FlowMod, decoder *goloxi.Decoder) (*FlowModifyStrict, error) {
	_flowmodifystrict := &FlowModifyStrict{FlowMod: parent}
	if decoder.Length() < 10 {
		return nil, fmt.Errorf("FlowModifyStrict packet too short: %d < 10", decoder.Length())
	}
	_flowmodifystrict.Importance = uint16(decoder.ReadUint16())
	return _flowmodifystrict, nil
}

func NewFlowModifyStrict() *FlowModifyStrict {
	obj := &FlowModifyStrict{
		FlowMod: NewFlowMod(2),
	}
	return obj
}

type FlowMonitorFailedErrorMsg struct {
	*ErrorMsg
	Code FlowMonitorFailedCode
	Data []byte
}

type IFlowMonitorFailedErrorMsg interface {
	IErrorMsg
	GetCode() FlowMonitorFailedCode
	GetData() []byte
}

func (self *FlowMonitorFailedErrorMsg) GetCode() FlowMonitorFailedCode {
	return self.Code
}

func (self *FlowMonitorFailedErrorMsg) SetCode(v FlowMonitorFailedCode) {
	self.Code = v
}

func (self *FlowMonitorFailedErrorMsg) GetData() []byte {
	return self.Data
}

func (self *FlowMonitorFailedErrorMsg) SetData(v []byte) {
	self.Data = v
}

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

	encoder.PutUint16(uint16(self.Code))
	encoder.Write(self.Data)
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeFlowMonitorFailedErrorMsg(parent *ErrorMsg, decoder *goloxi.Decoder) (*FlowMonitorFailedErrorMsg, error) {
	_flowmonitorfailederrormsg := &FlowMonitorFailedErrorMsg{ErrorMsg: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("FlowMonitorFailedErrorMsg packet too short: %d < 2", decoder.Length())
	}
	_flowmonitorfailederrormsg.Code = FlowMonitorFailedCode(decoder.ReadUint16())
	_flowmonitorfailederrormsg.Data = decoder.Read(int(decoder.Length()))
	return _flowmonitorfailederrormsg, nil
}

func NewFlowMonitorFailedErrorMsg() *FlowMonitorFailedErrorMsg {
	obj := &FlowMonitorFailedErrorMsg{
		ErrorMsg: NewErrorMsg(16),
	}
	return obj
}

type FlowMonitorReply struct {
	*StatsReply
	Entries []IFlowMonitorReplyEntry
}

type IFlowMonitorReply interface {
	IStatsReply
	GetEntries() []IFlowMonitorReplyEntry
}

func (self *FlowMonitorReply) GetEntries() []IFlowMonitorReplyEntry {
	return self.Entries
}

func (self *FlowMonitorReply) SetEntries(v []IFlowMonitorReplyEntry) {
	self.Entries = v
}

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

	encoder.Write(bytes.Repeat([]byte{0}, 4))
	for _, obj := range self.Entries {
		if err := obj.Serialize(encoder); err != nil {
			return err
		}
	}
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeFlowMonitorReply(parent *StatsReply, decoder *goloxi.Decoder) (*FlowMonitorReply, error) {
	_flowmonitorreply := &FlowMonitorReply{StatsReply: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("FlowMonitorReply packet too short: %d < 4", decoder.Length())
	}
	decoder.Skip(4)

	for decoder.Length() >= 4 {
		item, err := DecodeFlowMonitorReplyEntry(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_flowmonitorreply.Entries = append(_flowmonitorreply.Entries, item)
		}
	}
	return _flowmonitorreply, nil
}

func NewFlowMonitorReply() *FlowMonitorReply {
	obj := &FlowMonitorReply{
		StatsReply: NewStatsReply(16),
	}
	return obj
}

type FlowMonitorRequest struct {
	*StatsRequest
	Entries []*FlowMonitorEntry
}

type IFlowMonitorRequest interface {
	IStatsRequest
	GetEntries() []*FlowMonitorEntry
}

func (self *FlowMonitorRequest) GetEntries() []*FlowMonitorEntry {
	return self.Entries
}

func (self *FlowMonitorRequest) SetEntries(v []*FlowMonitorEntry) {
	self.Entries = v
}

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

	encoder.Write(bytes.Repeat([]byte{0}, 4))
	for _, obj := range self.Entries {
		if err := obj.Serialize(encoder); err != nil {
			return err
		}
	}
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeFlowMonitorRequest(parent *StatsRequest, decoder *goloxi.Decoder) (*FlowMonitorRequest, error) {
	_flowmonitorrequest := &FlowMonitorRequest{StatsRequest: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("FlowMonitorRequest packet too short: %d < 4", decoder.Length())
	}
	decoder.Skip(4)

	for decoder.Length() >= 24 {
		item, err := DecodeFlowMonitorEntry(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_flowmonitorrequest.Entries = append(_flowmonitorrequest.Entries, item)
		}
	}
	return _flowmonitorrequest, nil
}

func NewFlowMonitorRequest() *FlowMonitorRequest {
	obj := &FlowMonitorRequest{
		StatsRequest: NewStatsRequest(16),
	}
	return obj
}

type FlowRemoved struct {
	*Header
	Cookie       uint64
	Priority     uint16
	Reason       FlowRemovedReason
	TableId      uint8
	DurationSec  uint32
	DurationNsec uint32
	IdleTimeout  uint16
	HardTimeout  uint16
	PacketCount  uint64
	ByteCount    uint64
	Match        Match
}

type IFlowRemoved interface {
	IHeader
	GetCookie() uint64
	GetPriority() uint16
	GetReason() FlowRemovedReason
	GetTableId() uint8
	GetDurationSec() uint32
	GetDurationNsec() uint32
	GetIdleTimeout() uint16
	GetHardTimeout() uint16
	GetPacketCount() uint64
	GetByteCount() uint64
	GetMatch() Match
}

func (self *FlowRemoved) GetCookie() uint64 {
	return self.Cookie
}

func (self *FlowRemoved) SetCookie(v uint64) {
	self.Cookie = v
}

func (self *FlowRemoved) GetPriority() uint16 {
	return self.Priority
}

func (self *FlowRemoved) SetPriority(v uint16) {
	self.Priority = v
}

func (self *FlowRemoved) GetReason() FlowRemovedReason {
	return self.Reason
}

func (self *FlowRemoved) SetReason(v FlowRemovedReason) {
	self.Reason = v
}

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

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

func (self *FlowRemoved) GetDurationSec() uint32 {
	return self.DurationSec
}

func (self *FlowRemoved) SetDurationSec(v uint32) {
	self.DurationSec = v
}

func (self *FlowRemoved) GetDurationNsec() uint32 {
	return self.DurationNsec
}

func (self *FlowRemoved) SetDurationNsec(v uint32) {
	self.DurationNsec = v
}

func (self *FlowRemoved) GetIdleTimeout() uint16 {
	return self.IdleTimeout
}

func (self *FlowRemoved) SetIdleTimeout(v uint16) {
	self.IdleTimeout = v
}

func (self *FlowRemoved) GetHardTimeout() uint16 {
	return self.HardTimeout
}

func (self *FlowRemoved) SetHardTimeout(v uint16) {
	self.HardTimeout = v
}

func (self *FlowRemoved) GetPacketCount() uint64 {
	return self.PacketCount
}

func (self *FlowRemoved) SetPacketCount(v uint64) {
	self.PacketCount = v
}

func (self *FlowRemoved) GetByteCount() uint64 {
	return self.ByteCount
}

func (self *FlowRemoved) SetByteCount(v uint64) {
	self.ByteCount = v
}

func (self *FlowRemoved) GetMatch() Match {
	return self.Match
}

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

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

	encoder.PutUint64(uint64(self.Cookie))
	encoder.PutUint16(uint16(self.Priority))
	encoder.PutUint8(uint8(self.Reason))
	encoder.PutUint8(uint8(self.TableId))
	encoder.PutUint32(uint32(self.DurationSec))
	encoder.PutUint32(uint32(self.DurationNsec))
	encoder.PutUint16(uint16(self.IdleTimeout))
	encoder.PutUint16(uint16(self.HardTimeout))
	encoder.PutUint64(uint64(self.PacketCount))
	encoder.PutUint64(uint64(self.ByteCount))
	if err := self.Match.Serialize(encoder); err != nil {
		return err
	}

	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeFlowRemoved(parent *Header, decoder *goloxi.Decoder) (*FlowRemoved, error) {
	_flowremoved := &FlowRemoved{Header: parent}
	if decoder.Length() < 48 {
		return nil, fmt.Errorf("FlowRemoved packet too short: %d < 48", decoder.Length())
	}
	_flowremoved.Cookie = uint64(decoder.ReadUint64())
	_flowremoved.Priority = uint16(decoder.ReadUint16())
	_flowremoved.Reason = FlowRemovedReason(decoder.ReadByte())
	_flowremoved.TableId = uint8(decoder.ReadByte())
	_flowremoved.DurationSec = uint32(decoder.ReadUint32())
	_flowremoved.DurationNsec = uint32(decoder.ReadUint32())
	_flowremoved.IdleTimeout = uint16(decoder.ReadUint16())
	_flowremoved.HardTimeout = uint16(decoder.ReadUint16())
	_flowremoved.PacketCount = uint64(decoder.ReadUint64())
	_flowremoved.ByteCount = uint64(decoder.ReadUint64())
	if err := _flowremoved.Match.Decode(decoder); err != nil {
		return nil, err
	}

	decoder.SkipAlign()
	return _flowremoved, nil
}

func NewFlowRemoved() *FlowRemoved {
	obj := &FlowRemoved{
		Header: NewHeader(11),
	}
	return obj
}

type FlowStatsReply struct {
	*StatsReply
	Entries []*FlowStatsEntry
}

type IFlowStatsReply interface {
	IStatsReply
	GetEntries() []*FlowStatsEntry
}

func (self *FlowStatsReply) GetEntries() []*FlowStatsEntry {
	return self.Entries
}

func (self *FlowStatsReply) SetEntries(v []*FlowStatsEntry) {
	self.Entries = v
}

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

	encoder.Write(bytes.Repeat([]byte{0}, 4))
	for _, obj := range self.Entries {
		if err := obj.Serialize(encoder); err != nil {
			return err
		}
	}
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeFlowStatsReply(parent *StatsReply, decoder *goloxi.Decoder) (*FlowStatsReply, error) {
	_flowstatsreply := &FlowStatsReply{StatsReply: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("FlowStatsReply packet too short: %d < 4", decoder.Length())
	}
	decoder.Skip(4)

	for decoder.Length() >= 56 {
		item, err := DecodeFlowStatsEntry(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_flowstatsreply.Entries = append(_flowstatsreply.Entries, item)
		}
	}
	return _flowstatsreply, nil
}

func NewFlowStatsReply() *FlowStatsReply {
	obj := &FlowStatsReply{
		StatsReply: NewStatsReply(1),
	}
	return obj
}

type FlowStatsRequest struct {
	*StatsRequest
	TableId    uint8
	OutPort    Port
	OutGroup   uint32
	Cookie     uint64
	CookieMask uint64
	Match      Match
}

type IFlowStatsRequest interface {
	IStatsRequest
	GetTableId() uint8
	GetOutPort() Port
	GetOutGroup() uint32
	GetCookie() uint64
	GetCookieMask() uint64
	GetMatch() Match
}

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

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

func (self *FlowStatsRequest) GetOutPort() Port {
	return self.OutPort
}

func (self *FlowStatsRequest) SetOutPort(v Port) {
	self.OutPort = v
}

func (self *FlowStatsRequest) GetOutGroup() uint32 {
	return self.OutGroup
}

func (self *FlowStatsRequest) SetOutGroup(v uint32) {
	self.OutGroup = v
}

func (self *FlowStatsRequest) GetCookie() uint64 {
	return self.Cookie
}

func (self *FlowStatsRequest) SetCookie(v uint64) {
	self.Cookie = v
}

func (self *FlowStatsRequest) GetCookieMask() uint64 {
	return self.CookieMask
}

func (self *FlowStatsRequest) SetCookieMask(v uint64) {
	self.CookieMask = v
}

func (self *FlowStatsRequest) GetMatch() Match {
	return self.Match
}

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

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

	encoder.Write(bytes.Repeat([]byte{0}, 4))
	encoder.PutUint8(uint8(self.TableId))
	encoder.Write(bytes.Repeat([]byte{0}, 3))
	self.OutPort.Serialize(encoder)
	encoder.PutUint32(uint32(self.OutGroup))
	encoder.Write(bytes.Repeat([]byte{0}, 4))
	encoder.PutUint64(uint64(self.Cookie))
	encoder.PutUint64(uint64(self.CookieMask))
	if err := self.Match.Serialize(encoder); err != nil {
		return err
	}

	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeFlowStatsRequest(parent *StatsRequest, decoder *goloxi.Decoder) (*FlowStatsRequest, error) {
	_flowstatsrequest := &FlowStatsRequest{StatsRequest: parent}
	if decoder.Length() < 28 {
		return nil, fmt.Errorf("FlowStatsRequest packet too short: %d < 28", decoder.Length())
	}
	decoder.Skip(4)
	_flowstatsrequest.TableId = uint8(decoder.ReadByte())
	decoder.Skip(3)
	_flowstatsrequest.OutPort.Decode(decoder)
	_flowstatsrequest.OutGroup = uint32(decoder.ReadUint32())
	decoder.Skip(4)
	_flowstatsrequest.Cookie = uint64(decoder.ReadUint64())
	_flowstatsrequest.CookieMask = uint64(decoder.ReadUint64())
	if err := _flowstatsrequest.Match.Decode(decoder); err != nil {
		return nil, err
	}

	decoder.SkipAlign()
	return _flowstatsrequest, nil
}

func NewFlowStatsRequest() *FlowStatsRequest {
	obj := &FlowStatsRequest{
		StatsRequest: NewStatsRequest(1),
	}
	return obj
}

type GetConfigReply struct {
	*Header
	Flags       ConfigFlags
	MissSendLen uint16
}

type IGetConfigReply interface {
	IHeader
	GetFlags() ConfigFlags
	GetMissSendLen() uint16
}

func (self *GetConfigReply) GetFlags() ConfigFlags {
	return self.Flags
}

func (self *GetConfigReply) SetFlags(v ConfigFlags) {
	self.Flags = v
}

func (self *GetConfigReply) GetMissSendLen() uint16 {
	return self.MissSendLen
}

func (self *GetConfigReply) SetMissSendLen(v uint16) {
	self.MissSendLen = v
}

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

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

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

	return nil
}

func DecodeGetConfigReply(parent *Header, decoder *goloxi.Decoder) (*GetConfigReply, error) {
	_getconfigreply := &GetConfigReply{Header: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("GetConfigReply packet too short: %d < 4", decoder.Length())
	}
	_getconfigreply.Flags = ConfigFlags(decoder.ReadUint16())
	_getconfigreply.MissSendLen = uint16(decoder.ReadUint16())
	return _getconfigreply, nil
}

func NewGetConfigReply() *GetConfigReply {
	obj := &GetConfigReply{
		Header: NewHeader(8),
	}
	return obj
}

type GetConfigRequest struct {
	*Header
}

type IGetConfigRequest interface {
	IHeader
}

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

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

	return nil
}

func DecodeGetConfigRequest(parent *Header, decoder *goloxi.Decoder) (*GetConfigRequest, error) {
	_getconfigrequest := &GetConfigRequest{Header: parent}
	return _getconfigrequest, nil
}

func NewGetConfigRequest() *GetConfigRequest {
	obj := &GetConfigRequest{
		Header: NewHeader(7),
	}
	return obj
}

type GroupMod struct {
	*Header
	Command   GroupModCommand
	GroupType GroupType
	GroupId   uint32
	Buckets   []*Bucket
}

type IGroupMod interface {
	IHeader
	GetCommand() GroupModCommand
	GetGroupType() GroupType
	GetGroupId() uint32
	GetBuckets() []*Bucket
}

func (self *GroupMod) GetCommand() GroupModCommand {
	return self.Command
}

func (self *GroupMod) SetCommand(v GroupModCommand) {
	self.Command = v
}

func (self *GroupMod) GetGroupType() GroupType {
	return self.GroupType
}

func (self *GroupMod) SetGroupType(v GroupType) {
	self.GroupType = v
}

func (self *GroupMod) GetGroupId() uint32 {
	return self.GroupId
}

func (self *GroupMod) SetGroupId(v uint32) {
	self.GroupId = v
}

func (self *GroupMod) GetBuckets() []*Bucket {
	return self.Buckets
}

func (self *GroupMod) SetBuckets(v []*Bucket) {
	self.Buckets = v
}

func (self *GroupMod) Serialize(encoder *goloxi.Encoder) error {
	if err := self.Header.Serialize(encoder); err != nil {
		return err
	}

	encoder.PutUint16(uint16(self.Command))
	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
		}
	}

	return nil
}

func DecodeGroupMod(parent *Header, decoder *goloxi.Decoder) (IGroupMod, error) {
	_groupmod := &GroupMod{Header: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("GroupMod packet too short: %d < 8", decoder.Length())
	}
	_groupmod.Command = GroupModCommand(decoder.ReadUint16())
	_groupmod.GroupType = GroupType(decoder.ReadByte())
	decoder.Skip(1)
	_groupmod.GroupId = uint32(decoder.ReadUint32())

	for decoder.Length() >= 16 {
		item, err := DecodeBucket(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_groupmod.Buckets = append(_groupmod.Buckets, item)
		}
	}

	switch _groupmod.Command {
	case 0:
		return DecodeGroupAdd(_groupmod, decoder)
	case 1:
		return DecodeGroupModify(_groupmod, decoder)
	case 2:
		return DecodeGroupDelete(_groupmod, decoder)
	default:
		return nil, fmt.Errorf("Invalid type '%d' for 'GroupMod'", _groupmod.Command)
	}
}

func NewGroupMod(_command GroupModCommand) *GroupMod {
	obj := &GroupMod{
		Header: NewHeader(15),
	}
	obj.Command = _command
	return obj
}

type GroupAdd struct {
	*GroupMod
}

type IGroupAdd interface {
	IGroupMod
}

func (self *GroupAdd) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.GroupMod.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 DecodeGroupAdd(parent *GroupMod, decoder *goloxi.Decoder) (*GroupAdd, error) {
	_groupadd := &GroupAdd{GroupMod: parent}
	return _groupadd, nil
}

func NewGroupAdd() *GroupAdd {
	obj := &GroupAdd{
		GroupMod: NewGroupMod(0),
	}
	return obj
}

type GroupDelete struct {
	*GroupMod
}

type IGroupDelete interface {
	IGroupMod
}

func (self *GroupDelete) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.GroupMod.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 DecodeGroupDelete(parent *GroupMod, decoder *goloxi.Decoder) (*GroupDelete, error) {
	_groupdelete := &GroupDelete{GroupMod: parent}
	return _groupdelete, nil
}

func NewGroupDelete() *GroupDelete {
	obj := &GroupDelete{
		GroupMod: NewGroupMod(2),
	}
	return obj
}

type GroupDescStatsReply struct {
	*StatsReply
	Entries []*GroupDescStatsEntry
}

type IGroupDescStatsReply interface {
	IStatsReply
	GetEntries() []*GroupDescStatsEntry
}

func (self *GroupDescStatsReply) GetEntries() []*GroupDescStatsEntry {
	return self.Entries
}

func (self *GroupDescStatsReply) SetEntries(v []*GroupDescStatsEntry) {
	self.Entries = v
}

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

	encoder.Write(bytes.Repeat([]byte{0}, 4))
	for _, obj := range self.Entries {
		if err := obj.Serialize(encoder); err != nil {
			return err
		}
	}
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeGroupDescStatsReply(parent *StatsReply, decoder *goloxi.Decoder) (*GroupDescStatsReply, error) {
	_groupdescstatsreply := &GroupDescStatsReply{StatsReply: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("GroupDescStatsReply packet too short: %d < 4", decoder.Length())
	}
	decoder.Skip(4)

	for decoder.Length() >= 8 {
		item, err := DecodeGroupDescStatsEntry(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_groupdescstatsreply.Entries = append(_groupdescstatsreply.Entries, item)
		}
	}
	return _groupdescstatsreply, nil
}

func NewGroupDescStatsReply() *GroupDescStatsReply {
	obj := &GroupDescStatsReply{
		StatsReply: NewStatsReply(7),
	}
	return obj
}

type GroupDescStatsRequest struct {
	*StatsRequest
}

type IGroupDescStatsRequest interface {
	IStatsRequest
}

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

	encoder.Write(bytes.Repeat([]byte{0}, 4))
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeGroupDescStatsRequest(parent *StatsRequest, decoder *goloxi.Decoder) (*GroupDescStatsRequest, error) {
	_groupdescstatsrequest := &GroupDescStatsRequest{StatsRequest: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("GroupDescStatsRequest packet too short: %d < 4", decoder.Length())
	}
	decoder.Skip(4)
	return _groupdescstatsrequest, nil
}

func NewGroupDescStatsRequest() *GroupDescStatsRequest {
	obj := &GroupDescStatsRequest{
		StatsRequest: NewStatsRequest(7),
	}
	return obj
}

type GroupFeaturesStatsReply struct {
	*StatsReply
	Types             uint32
	Capabilities      GroupCapabilities
	MaxGroupsAll      uint32
	MaxGroupsSelect   uint32
	MaxGroupsIndirect uint32
	MaxGroupsFf       uint32
	ActionsAll        uint32
	ActionsSelect     uint32
	ActionsIndirect   uint32
	ActionsFf         uint32
}

type IGroupFeaturesStatsReply interface {
	IStatsReply
	GetTypes() uint32
	GetCapabilities() GroupCapabilities
	GetMaxGroupsAll() uint32
	GetMaxGroupsSelect() uint32
	GetMaxGroupsIndirect() uint32
	GetMaxGroupsFf() uint32
	GetActionsAll() uint32
	GetActionsSelect() uint32
	GetActionsIndirect() uint32
	GetActionsFf() uint32
}

func (self *GroupFeaturesStatsReply) GetTypes() uint32 {
	return self.Types
}

func (self *GroupFeaturesStatsReply) SetTypes(v uint32) {
	self.Types = v
}

func (self *GroupFeaturesStatsReply) GetCapabilities() GroupCapabilities {
	return self.Capabilities
}

func (self *GroupFeaturesStatsReply) SetCapabilities(v GroupCapabilities) {
	self.Capabilities = v
}

func (self *GroupFeaturesStatsReply) GetMaxGroupsAll() uint32 {
	return self.MaxGroupsAll
}

func (self *GroupFeaturesStatsReply) SetMaxGroupsAll(v uint32) {
	self.MaxGroupsAll = v
}

func (self *GroupFeaturesStatsReply) GetMaxGroupsSelect() uint32 {
	return self.MaxGroupsSelect
}

func (self *GroupFeaturesStatsReply) SetMaxGroupsSelect(v uint32) {
	self.MaxGroupsSelect = v
}

func (self *GroupFeaturesStatsReply) GetMaxGroupsIndirect() uint32 {
	return self.MaxGroupsIndirect
}

func (self *GroupFeaturesStatsReply) SetMaxGroupsIndirect(v uint32) {
	self.MaxGroupsIndirect = v
}

func (self *GroupFeaturesStatsReply) GetMaxGroupsFf() uint32 {
	return self.MaxGroupsFf
}

func (self *GroupFeaturesStatsReply) SetMaxGroupsFf(v uint32) {
	self.MaxGroupsFf = v
}

func (self *GroupFeaturesStatsReply) GetActionsAll() uint32 {
	return self.ActionsAll
}

func (self *GroupFeaturesStatsReply) SetActionsAll(v uint32) {
	self.ActionsAll = v
}

func (self *GroupFeaturesStatsReply) GetActionsSelect() uint32 {
	return self.ActionsSelect
}

func (self *GroupFeaturesStatsReply) SetActionsSelect(v uint32) {
	self.ActionsSelect = v
}

func (self *GroupFeaturesStatsReply) GetActionsIndirect() uint32 {
	return self.ActionsIndirect
}

func (self *GroupFeaturesStatsReply) SetActionsIndirect(v uint32) {
	self.ActionsIndirect = v
}

func (self *GroupFeaturesStatsReply) GetActionsFf() uint32 {
	return self.ActionsFf
}

func (self *GroupFeaturesStatsReply) SetActionsFf(v uint32) {
	self.ActionsFf = v
}

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

	encoder.Write(bytes.Repeat([]byte{0}, 4))
	encoder.PutUint32(uint32(self.Types))
	encoder.PutUint32(uint32(self.Capabilities))
	encoder.PutUint32(uint32(self.MaxGroupsAll))
	encoder.PutUint32(uint32(self.MaxGroupsSelect))
	encoder.PutUint32(uint32(self.MaxGroupsIndirect))
	encoder.PutUint32(uint32(self.MaxGroupsFf))
	encoder.PutUint32(uint32(self.ActionsAll))
	encoder.PutUint32(uint32(self.ActionsSelect))
	encoder.PutUint32(uint32(self.ActionsIndirect))
	encoder.PutUint32(uint32(self.ActionsFf))
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeGroupFeaturesStatsReply(parent *StatsReply, decoder *goloxi.Decoder) (*GroupFeaturesStatsReply, error) {
	_groupfeaturesstatsreply := &GroupFeaturesStatsReply{StatsReply: parent}
	if decoder.Length() < 44 {
		return nil, fmt.Errorf("GroupFeaturesStatsReply packet too short: %d < 44", decoder.Length())
	}
	decoder.Skip(4)
	_groupfeaturesstatsreply.Types = uint32(decoder.ReadUint32())
	_groupfeaturesstatsreply.Capabilities = GroupCapabilities(decoder.ReadUint32())
	_groupfeaturesstatsreply.MaxGroupsAll = uint32(decoder.ReadUint32())
	_groupfeaturesstatsreply.MaxGroupsSelect = uint32(decoder.ReadUint32())
	_groupfeaturesstatsreply.MaxGroupsIndirect = uint32(decoder.ReadUint32())
	_groupfeaturesstatsreply.MaxGroupsFf = uint32(decoder.ReadUint32())
	_groupfeaturesstatsreply.ActionsAll = uint32(decoder.ReadUint32())
	_groupfeaturesstatsreply.ActionsSelect = uint32(decoder.ReadUint32())
	_groupfeaturesstatsreply.ActionsIndirect = uint32(decoder.ReadUint32())
	_groupfeaturesstatsreply.ActionsFf = uint32(decoder.ReadUint32())
	return _groupfeaturesstatsreply, nil
}

func NewGroupFeaturesStatsReply() *GroupFeaturesStatsReply {
	obj := &GroupFeaturesStatsReply{
		StatsReply: NewStatsReply(8),
	}
	return obj
}

type GroupFeaturesStatsRequest struct {
	*StatsRequest
}

type IGroupFeaturesStatsRequest interface {
	IStatsRequest
}

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

	encoder.Write(bytes.Repeat([]byte{0}, 4))
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeGroupFeaturesStatsRequest(parent *StatsRequest, decoder *goloxi.Decoder) (*GroupFeaturesStatsRequest, error) {
	_groupfeaturesstatsrequest := &GroupFeaturesStatsRequest{StatsRequest: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("GroupFeaturesStatsRequest packet too short: %d < 4", decoder.Length())
	}
	decoder.Skip(4)
	return _groupfeaturesstatsrequest, nil
}

func NewGroupFeaturesStatsRequest() *GroupFeaturesStatsRequest {
	obj := &GroupFeaturesStatsRequest{
		StatsRequest: NewStatsRequest(8),
	}
	return obj
}

type GroupModFailedErrorMsg struct {
	*ErrorMsg
	Code GroupModFailedCode
	Data []byte
}

type IGroupModFailedErrorMsg interface {
	IErrorMsg
	GetCode() GroupModFailedCode
	GetData() []byte
}

func (self *GroupModFailedErrorMsg) GetCode() GroupModFailedCode {
	return self.Code
}

func (self *GroupModFailedErrorMsg) SetCode(v GroupModFailedCode) {
	self.Code = v
}

func (self *GroupModFailedErrorMsg) GetData() []byte {
	return self.Data
}

func (self *GroupModFailedErrorMsg) SetData(v []byte) {
	self.Data = v
}

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

	encoder.PutUint16(uint16(self.Code))
	encoder.Write(self.Data)
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeGroupModFailedErrorMsg(parent *ErrorMsg, decoder *goloxi.Decoder) (*GroupModFailedErrorMsg, error) {
	_groupmodfailederrormsg := &GroupModFailedErrorMsg{ErrorMsg: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("GroupModFailedErrorMsg packet too short: %d < 2", decoder.Length())
	}
	_groupmodfailederrormsg.Code = GroupModFailedCode(decoder.ReadUint16())
	_groupmodfailederrormsg.Data = decoder.Read(int(decoder.Length()))
	return _groupmodfailederrormsg, nil
}

func NewGroupModFailedErrorMsg() *GroupModFailedErrorMsg {
	obj := &GroupModFailedErrorMsg{
		ErrorMsg: NewErrorMsg(6),
	}
	return obj
}

type GroupModify struct {
	*GroupMod
}

type IGroupModify interface {
	IGroupMod
}

func (self *GroupModify) Serialize(encoder *goloxi.Encoder) error {
	startIndex := len(encoder.Bytes())
	if err := self.GroupMod.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 DecodeGroupModify(parent *GroupMod, decoder *goloxi.Decoder) (*GroupModify, error) {
	_groupmodify := &GroupModify{GroupMod: parent}
	return _groupmodify, nil
}

func NewGroupModify() *GroupModify {
	obj := &GroupModify{
		GroupMod: NewGroupMod(1),
	}
	return obj
}

type GroupStatsReply struct {
	*StatsReply
	Entries []*GroupStatsEntry
}

type IGroupStatsReply interface {
	IStatsReply
	GetEntries() []*GroupStatsEntry
}

func (self *GroupStatsReply) GetEntries() []*GroupStatsEntry {
	return self.Entries
}

func (self *GroupStatsReply) SetEntries(v []*GroupStatsEntry) {
	self.Entries = v
}

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

	encoder.Write(bytes.Repeat([]byte{0}, 4))
	for _, obj := range self.Entries {
		if err := obj.Serialize(encoder); err != nil {
			return err
		}
	}
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeGroupStatsReply(parent *StatsReply, decoder *goloxi.Decoder) (*GroupStatsReply, error) {
	_groupstatsreply := &GroupStatsReply{StatsReply: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("GroupStatsReply packet too short: %d < 4", decoder.Length())
	}
	decoder.Skip(4)

	for decoder.Length() >= 40 {
		item, err := DecodeGroupStatsEntry(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_groupstatsreply.Entries = append(_groupstatsreply.Entries, item)
		}
	}
	return _groupstatsreply, nil
}

func NewGroupStatsReply() *GroupStatsReply {
	obj := &GroupStatsReply{
		StatsReply: NewStatsReply(6),
	}
	return obj
}

type GroupStatsRequest struct {
	*StatsRequest
	GroupId uint32
}

type IGroupStatsRequest interface {
	IStatsRequest
	GetGroupId() uint32
}

func (self *GroupStatsRequest) GetGroupId() uint32 {
	return self.GroupId
}

func (self *GroupStatsRequest) SetGroupId(v uint32) {
	self.GroupId = v
}

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

	encoder.Write(bytes.Repeat([]byte{0}, 4))
	encoder.PutUint32(uint32(self.GroupId))
	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 DecodeGroupStatsRequest(parent *StatsRequest, decoder *goloxi.Decoder) (*GroupStatsRequest, error) {
	_groupstatsrequest := &GroupStatsRequest{StatsRequest: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("GroupStatsRequest packet too short: %d < 4", decoder.Length())
	}
	decoder.Skip(4)
	_groupstatsrequest.GroupId = uint32(decoder.ReadUint32())
	decoder.Skip(4)
	return _groupstatsrequest, nil
}

func NewGroupStatsRequest() *GroupStatsRequest {
	obj := &GroupStatsRequest{
		StatsRequest: NewStatsRequest(6),
	}
	return obj
}

type Hello struct {
	*Header
	Elements []IHelloElem
}

type IHello interface {
	IHeader
	GetElements() []IHelloElem
}

func (self *Hello) GetElements() []IHelloElem {
	return self.Elements
}

func (self *Hello) SetElements(v []IHelloElem) {
	self.Elements = v
}

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

	for _, obj := range self.Elements {
		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 DecodeHello(parent *Header, decoder *goloxi.Decoder) (*Hello, error) {
	_hello := &Hello{Header: parent}

	for decoder.Length() >= 4 {
		item, err := DecodeHelloElem(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_hello.Elements = append(_hello.Elements, item)
		}
	}
	return _hello, nil
}

func NewHello() *Hello {
	obj := &Hello{
		Header: NewHeader(0),
	}
	return obj
}

type HelloFailedErrorMsg struct {
	*ErrorMsg
	Code HelloFailedCode
	Data []byte
}

type IHelloFailedErrorMsg interface {
	IErrorMsg
	GetCode() HelloFailedCode
	GetData() []byte
}

func (self *HelloFailedErrorMsg) GetCode() HelloFailedCode {
	return self.Code
}

func (self *HelloFailedErrorMsg) SetCode(v HelloFailedCode) {
	self.Code = v
}

func (self *HelloFailedErrorMsg) GetData() []byte {
	return self.Data
}

func (self *HelloFailedErrorMsg) SetData(v []byte) {
	self.Data = v
}

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

	encoder.PutUint16(uint16(self.Code))
	encoder.Write(self.Data)
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeHelloFailedErrorMsg(parent *ErrorMsg, decoder *goloxi.Decoder) (*HelloFailedErrorMsg, error) {
	_hellofailederrormsg := &HelloFailedErrorMsg{ErrorMsg: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("HelloFailedErrorMsg packet too short: %d < 2", decoder.Length())
	}
	_hellofailederrormsg.Code = HelloFailedCode(decoder.ReadUint16())
	_hellofailederrormsg.Data = decoder.Read(int(decoder.Length()))
	return _hellofailederrormsg, nil
}

func NewHelloFailedErrorMsg() *HelloFailedErrorMsg {
	obj := &HelloFailedErrorMsg{
		ErrorMsg: NewErrorMsg(0),
	}
	return obj
}

type MeterConfigStatsReply struct {
	*StatsReply
	Entries []*MeterConfig
}

type IMeterConfigStatsReply interface {
	IStatsReply
	GetEntries() []*MeterConfig
}

func (self *MeterConfigStatsReply) GetEntries() []*MeterConfig {
	return self.Entries
}

func (self *MeterConfigStatsReply) SetEntries(v []*MeterConfig) {
	self.Entries = v
}

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

	encoder.Write(bytes.Repeat([]byte{0}, 4))
	for _, obj := range self.Entries {
		if err := obj.Serialize(encoder); err != nil {
			return err
		}
	}
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeMeterConfigStatsReply(parent *StatsReply, decoder *goloxi.Decoder) (*MeterConfigStatsReply, error) {
	_meterconfigstatsreply := &MeterConfigStatsReply{StatsReply: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("MeterConfigStatsReply packet too short: %d < 4", decoder.Length())
	}
	decoder.Skip(4)

	for decoder.Length() >= 8 {
		item, err := DecodeMeterConfig(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_meterconfigstatsreply.Entries = append(_meterconfigstatsreply.Entries, item)
		}
	}
	return _meterconfigstatsreply, nil
}

func NewMeterConfigStatsReply() *MeterConfigStatsReply {
	obj := &MeterConfigStatsReply{
		StatsReply: NewStatsReply(10),
	}
	return obj
}

type MeterConfigStatsRequest struct {
	*StatsRequest
	MeterId uint32
}

type IMeterConfigStatsRequest interface {
	IStatsRequest
	GetMeterId() uint32
}

func (self *MeterConfigStatsRequest) GetMeterId() uint32 {
	return self.MeterId
}

func (self *MeterConfigStatsRequest) SetMeterId(v uint32) {
	self.MeterId = v
}

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

	encoder.Write(bytes.Repeat([]byte{0}, 4))
	encoder.PutUint32(uint32(self.MeterId))
	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 DecodeMeterConfigStatsRequest(parent *StatsRequest, decoder *goloxi.Decoder) (*MeterConfigStatsRequest, error) {
	_meterconfigstatsrequest := &MeterConfigStatsRequest{StatsRequest: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("MeterConfigStatsRequest packet too short: %d < 4", decoder.Length())
	}
	decoder.Skip(4)
	_meterconfigstatsrequest.MeterId = uint32(decoder.ReadUint32())
	decoder.Skip(4)
	return _meterconfigstatsrequest, nil
}

func NewMeterConfigStatsRequest() *MeterConfigStatsRequest {
	obj := &MeterConfigStatsRequest{
		StatsRequest: NewStatsRequest(10),
	}
	return obj
}

type MeterFeaturesStatsReply struct {
	*StatsReply
	Features MeterFeatures
}

type IMeterFeaturesStatsReply interface {
	IStatsReply
	GetFeatures() MeterFeatures
}

func (self *MeterFeaturesStatsReply) GetFeatures() MeterFeatures {
	return self.Features
}

func (self *MeterFeaturesStatsReply) SetFeatures(v MeterFeatures) {
	self.Features = v
}

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

	encoder.Write(bytes.Repeat([]byte{0}, 4))
	if err := self.Features.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 DecodeMeterFeaturesStatsReply(parent *StatsReply, decoder *goloxi.Decoder) (*MeterFeaturesStatsReply, error) {
	_meterfeaturesstatsreply := &MeterFeaturesStatsReply{StatsReply: parent}
	if decoder.Length() < 20 {
		return nil, fmt.Errorf("MeterFeaturesStatsReply packet too short: %d < 20", decoder.Length())
	}
	decoder.Skip(4)
	if err := _meterfeaturesstatsreply.Features.Decode(decoder); err != nil {
		return nil, err
	}

	return _meterfeaturesstatsreply, nil
}

func NewMeterFeaturesStatsReply() *MeterFeaturesStatsReply {
	obj := &MeterFeaturesStatsReply{
		StatsReply: NewStatsReply(11),
	}
	return obj
}

type MeterFeaturesStatsRequest struct {
	*StatsRequest
}

type IMeterFeaturesStatsRequest interface {
	IStatsRequest
}

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

	encoder.Write(bytes.Repeat([]byte{0}, 4))
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeMeterFeaturesStatsRequest(parent *StatsRequest, decoder *goloxi.Decoder) (*MeterFeaturesStatsRequest, error) {
	_meterfeaturesstatsrequest := &MeterFeaturesStatsRequest{StatsRequest: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("MeterFeaturesStatsRequest packet too short: %d < 4", decoder.Length())
	}
	decoder.Skip(4)
	return _meterfeaturesstatsrequest, nil
}

func NewMeterFeaturesStatsRequest() *MeterFeaturesStatsRequest {
	obj := &MeterFeaturesStatsRequest{
		StatsRequest: NewStatsRequest(11),
	}
	return obj
}

type MeterMod struct {
	*Header
	Command MeterModCommand
	Flags   MeterFlags
	MeterId uint32
	Bands   []IMeterBand
}

type IMeterMod interface {
	IHeader
	GetCommand() MeterModCommand
	GetFlags() MeterFlags
	GetMeterId() uint32
	GetBands() []IMeterBand
}

func (self *MeterMod) GetCommand() MeterModCommand {
	return self.Command
}

func (self *MeterMod) SetCommand(v MeterModCommand) {
	self.Command = v
}

func (self *MeterMod) GetFlags() MeterFlags {
	return self.Flags
}

func (self *MeterMod) SetFlags(v MeterFlags) {
	self.Flags = v
}

func (self *MeterMod) GetMeterId() uint32 {
	return self.MeterId
}

func (self *MeterMod) SetMeterId(v uint32) {
	self.MeterId = v
}

func (self *MeterMod) GetBands() []IMeterBand {
	return self.Bands
}

func (self *MeterMod) SetBands(v []IMeterBand) {
	self.Bands = v
}

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

	encoder.PutUint16(uint16(self.Command))
	encoder.PutUint16(uint16(self.Flags))
	encoder.PutUint32(uint32(self.MeterId))
	for _, obj := range self.Bands {
		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 DecodeMeterMod(parent *Header, decoder *goloxi.Decoder) (*MeterMod, error) {
	_metermod := &MeterMod{Header: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("MeterMod packet too short: %d < 8", decoder.Length())
	}
	_metermod.Command = MeterModCommand(decoder.ReadUint16())
	_metermod.Flags = MeterFlags(decoder.ReadUint16())
	_metermod.MeterId = uint32(decoder.ReadUint32())

	for decoder.Length() >= 4 {
		item, err := DecodeMeterBand(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_metermod.Bands = append(_metermod.Bands, item)
		}
	}
	return _metermod, nil
}

func NewMeterMod() *MeterMod {
	obj := &MeterMod{
		Header: NewHeader(29),
	}
	return obj
}

type MeterModFailedErrorMsg struct {
	*ErrorMsg
	Code MeterModFailedCode
	Data []byte
}

type IMeterModFailedErrorMsg interface {
	IErrorMsg
	GetCode() MeterModFailedCode
	GetData() []byte
}

func (self *MeterModFailedErrorMsg) GetCode() MeterModFailedCode {
	return self.Code
}

func (self *MeterModFailedErrorMsg) SetCode(v MeterModFailedCode) {
	self.Code = v
}

func (self *MeterModFailedErrorMsg) GetData() []byte {
	return self.Data
}

func (self *MeterModFailedErrorMsg) SetData(v []byte) {
	self.Data = v
}

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

	encoder.PutUint16(uint16(self.Code))
	encoder.Write(self.Data)
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeMeterModFailedErrorMsg(parent *ErrorMsg, decoder *goloxi.Decoder) (*MeterModFailedErrorMsg, error) {
	_metermodfailederrormsg := &MeterModFailedErrorMsg{ErrorMsg: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("MeterModFailedErrorMsg packet too short: %d < 2", decoder.Length())
	}
	_metermodfailederrormsg.Code = MeterModFailedCode(decoder.ReadUint16())
	_metermodfailederrormsg.Data = decoder.Read(int(decoder.Length()))
	return _metermodfailederrormsg, nil
}

func NewMeterModFailedErrorMsg() *MeterModFailedErrorMsg {
	obj := &MeterModFailedErrorMsg{
		ErrorMsg: NewErrorMsg(12),
	}
	return obj
}

type MeterStatsReply struct {
	*StatsReply
	Entries []*MeterStats
}

type IMeterStatsReply interface {
	IStatsReply
	GetEntries() []*MeterStats
}

func (self *MeterStatsReply) GetEntries() []*MeterStats {
	return self.Entries
}

func (self *MeterStatsReply) SetEntries(v []*MeterStats) {
	self.Entries = v
}

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

	encoder.Write(bytes.Repeat([]byte{0}, 4))
	for _, obj := range self.Entries {
		if err := obj.Serialize(encoder); err != nil {
			return err
		}
	}
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeMeterStatsReply(parent *StatsReply, decoder *goloxi.Decoder) (*MeterStatsReply, error) {
	_meterstatsreply := &MeterStatsReply{StatsReply: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("MeterStatsReply packet too short: %d < 4", decoder.Length())
	}
	decoder.Skip(4)

	for decoder.Length() >= 40 {
		item, err := DecodeMeterStats(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_meterstatsreply.Entries = append(_meterstatsreply.Entries, item)
		}
	}
	return _meterstatsreply, nil
}

func NewMeterStatsReply() *MeterStatsReply {
	obj := &MeterStatsReply{
		StatsReply: NewStatsReply(9),
	}
	return obj
}

type MeterStatsRequest struct {
	*StatsRequest
	MeterId uint32
}

type IMeterStatsRequest interface {
	IStatsRequest
	GetMeterId() uint32
}

func (self *MeterStatsRequest) GetMeterId() uint32 {
	return self.MeterId
}

func (self *MeterStatsRequest) SetMeterId(v uint32) {
	self.MeterId = v
}

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

	encoder.Write(bytes.Repeat([]byte{0}, 4))
	encoder.PutUint32(uint32(self.MeterId))
	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 DecodeMeterStatsRequest(parent *StatsRequest, decoder *goloxi.Decoder) (*MeterStatsRequest, error) {
	_meterstatsrequest := &MeterStatsRequest{StatsRequest: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("MeterStatsRequest packet too short: %d < 4", decoder.Length())
	}
	decoder.Skip(4)
	_meterstatsrequest.MeterId = uint32(decoder.ReadUint32())
	decoder.Skip(4)
	return _meterstatsrequest, nil
}

func NewMeterStatsRequest() *MeterStatsRequest {
	obj := &MeterStatsRequest{
		StatsRequest: NewStatsRequest(9),
	}
	return obj
}

type NiciraStatsReply struct {
	*ExperimenterStatsReply
}

type INiciraStatsReply interface {
	IExperimenterStatsReply
}

func (self *NiciraStatsReply) Serialize(encoder *goloxi.Encoder) error {
	if err := self.ExperimenterStatsReply.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeNiciraStatsReply(parent *ExperimenterStatsReply, decoder *goloxi.Decoder) (INiciraStatsReply, error) {
	_nicirastatsreply := &NiciraStatsReply{ExperimenterStatsReply: parent}
	if decoder.Length() < -4 {
		return nil, fmt.Errorf("NiciraStatsReply packet too short: %d < -4", decoder.Length())
	}

	switch _nicirastatsreply.Subtype {
	case 0:
		return DecodeNiciraFlowStatsReply(_nicirastatsreply, decoder)
	case 2:
		return DecodeNiciraFlowMonitorReply(_nicirastatsreply, decoder)
	default:
		return nil, fmt.Errorf("Invalid type '%d' for 'NiciraStatsReply'", _nicirastatsreply.Subtype)
	}
}

func NewNiciraStatsReply(_subtype uint32) *NiciraStatsReply {
	obj := &NiciraStatsReply{
		ExperimenterStatsReply: NewExperimenterStatsReply(8992),
	}
	obj.Subtype = _subtype
	return obj
}

type NiciraFlowMonitorReply struct {
	*NiciraStatsReply
	Updates []INiciraFlowUpdateEvent
}

type INiciraFlowMonitorReply interface {
	INiciraStatsReply
	GetUpdates() []INiciraFlowUpdateEvent
}

func (self *NiciraFlowMonitorReply) GetUpdates() []INiciraFlowUpdateEvent {
	return self.Updates
}

func (self *NiciraFlowMonitorReply) SetUpdates(v []INiciraFlowUpdateEvent) {
	self.Updates = v
}

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

	encoder.Write(bytes.Repeat([]byte{0}, 4))
	for _, obj := range self.Updates {
		if err := obj.Serialize(encoder); err != nil {
			return err
		}
	}
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeNiciraFlowMonitorReply(parent *NiciraStatsReply, decoder *goloxi.Decoder) (*NiciraFlowMonitorReply, error) {
	_niciraflowmonitorreply := &NiciraFlowMonitorReply{NiciraStatsReply: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("NiciraFlowMonitorReply packet too short: %d < 4", decoder.Length())
	}
	decoder.Skip(4)

	for decoder.Length() >= 4 {
		item, err := DecodeNiciraFlowUpdateEvent(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_niciraflowmonitorreply.Updates = append(_niciraflowmonitorreply.Updates, item)
		}
	}
	return _niciraflowmonitorreply, nil
}

func NewNiciraFlowMonitorReply() *NiciraFlowMonitorReply {
	obj := &NiciraFlowMonitorReply{
		NiciraStatsReply: NewNiciraStatsReply(2),
	}
	return obj
}

type NiciraFlowMonitorRequest struct {
	*ExperimenterStatsRequest
	MonitorId    uint32
	MonitorFlags NxFlowMonitorFlags
	OutPort      Port
	MatchLen     uint16
	TableId      uint8
	Match        NiciraMatch
}

type INiciraFlowMonitorRequest interface {
	IExperimenterStatsRequest
	GetMonitorId() uint32
	GetMonitorFlags() NxFlowMonitorFlags
	GetOutPort() Port
	GetMatchLen() uint16
	GetTableId() uint8
	GetMatch() NiciraMatch
}

func (self *NiciraFlowMonitorRequest) GetMonitorId() uint32 {
	return self.MonitorId
}

func (self *NiciraFlowMonitorRequest) SetMonitorId(v uint32) {
	self.MonitorId = v
}

func (self *NiciraFlowMonitorRequest) GetMonitorFlags() NxFlowMonitorFlags {
	return self.MonitorFlags
}

func (self *NiciraFlowMonitorRequest) SetMonitorFlags(v NxFlowMonitorFlags) {
	self.MonitorFlags = v
}

func (self *NiciraFlowMonitorRequest) GetOutPort() Port {
	return self.OutPort
}

func (self *NiciraFlowMonitorRequest) SetOutPort(v Port) {
	self.OutPort = v
}

func (self *NiciraFlowMonitorRequest) GetMatchLen() uint16 {
	return self.MatchLen
}

func (self *NiciraFlowMonitorRequest) SetMatchLen(v uint16) {
	self.MatchLen = v
}

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

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

func (self *NiciraFlowMonitorRequest) GetMatch() NiciraMatch {
	return self.Match
}

func (self *NiciraFlowMonitorRequest) SetMatch(v NiciraMatch) {
	self.Match = v
}

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

	encoder.Write(bytes.Repeat([]byte{0}, 4))
	encoder.PutUint32(uint32(self.MonitorId))
	encoder.PutUint16(uint16(self.MonitorFlags))
	self.OutPort.Serialize(encoder)
	encoder.PutUint16(uint16(self.MatchLen))
	encoder.PutUint8(uint8(self.TableId))
	encoder.Write(bytes.Repeat([]byte{0}, 5))
	if err := self.Match.Serialize(encoder); err != nil {
		return err
	}

	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeNiciraFlowMonitorRequest(parent *ExperimenterStatsRequest, decoder *goloxi.Decoder) (*NiciraFlowMonitorRequest, error) {
	_niciraflowmonitorrequest := &NiciraFlowMonitorRequest{ExperimenterStatsRequest: parent}
	if decoder.Length() < 22 {
		return nil, fmt.Errorf("NiciraFlowMonitorRequest packet too short: %d < 22", decoder.Length())
	}
	decoder.Skip(4)
	_niciraflowmonitorrequest.MonitorId = uint32(decoder.ReadUint32())
	_niciraflowmonitorrequest.MonitorFlags = NxFlowMonitorFlags(decoder.ReadUint16())
	_niciraflowmonitorrequest.OutPort.Decode(decoder)
	_niciraflowmonitorrequest.MatchLen = uint16(decoder.ReadUint16())
	_niciraflowmonitorrequest.TableId = uint8(decoder.ReadByte())
	decoder.Skip(5)
	if err := _niciraflowmonitorrequest.Match.Decode(decoder); err != nil {
		return nil, err
	}

	decoder.SkipAlign()
	return _niciraflowmonitorrequest, nil
}

func NewNiciraFlowMonitorRequest() *NiciraFlowMonitorRequest {
	obj := &NiciraFlowMonitorRequest{
		ExperimenterStatsRequest: NewExperimenterStatsRequest(8992),
	}
	return obj
}

type NiciraFlowStatsReply struct {
	*NiciraStatsReply
	Stats []*NiciraFlowStats
}

type INiciraFlowStatsReply interface {
	INiciraStatsReply
	GetStats() []*NiciraFlowStats
}

func (self *NiciraFlowStatsReply) GetStats() []*NiciraFlowStats {
	return self.Stats
}

func (self *NiciraFlowStatsReply) SetStats(v []*NiciraFlowStats) {
	self.Stats = v
}

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

	encoder.Write(bytes.Repeat([]byte{0}, 4))
	for _, obj := range self.Stats {
		if err := obj.Serialize(encoder); err != nil {
			return err
		}
	}
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeNiciraFlowStatsReply(parent *NiciraStatsReply, decoder *goloxi.Decoder) (*NiciraFlowStatsReply, error) {
	_niciraflowstatsreply := &NiciraFlowStatsReply{NiciraStatsReply: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("NiciraFlowStatsReply packet too short: %d < 4", decoder.Length())
	}
	decoder.Skip(4)

	for decoder.Length() >= 48 {
		item, err := DecodeNiciraFlowStats(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_niciraflowstatsreply.Stats = append(_niciraflowstatsreply.Stats, item)
		}
	}
	return _niciraflowstatsreply, nil
}

func NewNiciraFlowStatsReply() *NiciraFlowStatsReply {
	obj := &NiciraFlowStatsReply{
		NiciraStatsReply: NewNiciraStatsReply(0),
	}
	return obj
}

type NiciraFlowStatsRequest struct {
	*ExperimenterStatsRequest
	OutPort  Port
	MatchLen uint16
	TableId  uint8
}

type INiciraFlowStatsRequest interface {
	IExperimenterStatsRequest
	GetOutPort() Port
	GetMatchLen() uint16
	GetTableId() uint8
}

func (self *NiciraFlowStatsRequest) GetOutPort() Port {
	return self.OutPort
}

func (self *NiciraFlowStatsRequest) SetOutPort(v Port) {
	self.OutPort = v
}

func (self *NiciraFlowStatsRequest) GetMatchLen() uint16 {
	return self.MatchLen
}

func (self *NiciraFlowStatsRequest) SetMatchLen(v uint16) {
	self.MatchLen = v
}

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

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

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

	encoder.Write(bytes.Repeat([]byte{0}, 4))
	self.OutPort.Serialize(encoder)
	encoder.PutUint16(uint16(self.MatchLen))
	encoder.PutUint8(uint8(self.TableId))
	encoder.Write(bytes.Repeat([]byte{0}, 3))
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeNiciraFlowStatsRequest(parent *ExperimenterStatsRequest, decoder *goloxi.Decoder) (*NiciraFlowStatsRequest, error) {
	_niciraflowstatsrequest := &NiciraFlowStatsRequest{ExperimenterStatsRequest: parent}
	if decoder.Length() < 14 {
		return nil, fmt.Errorf("NiciraFlowStatsRequest packet too short: %d < 14", decoder.Length())
	}
	decoder.Skip(4)
	_niciraflowstatsrequest.OutPort.Decode(decoder)
	_niciraflowstatsrequest.MatchLen = uint16(decoder.ReadUint16())
	_niciraflowstatsrequest.TableId = uint8(decoder.ReadByte())
	decoder.Skip(3)
	return _niciraflowstatsrequest, nil
}

func NewNiciraFlowStatsRequest() *NiciraFlowStatsRequest {
	obj := &NiciraFlowStatsRequest{
		ExperimenterStatsRequest: NewExperimenterStatsRequest(8992),
	}
	return obj
}

type NiciraHeader struct {
	*Experimenter
}

type INiciraHeader interface {
	IExperimenter
}

func (self *NiciraHeader) Serialize(encoder *goloxi.Encoder) error {
	if err := self.Experimenter.Serialize(encoder); err != nil {
		return err
	}

	return nil
}

func DecodeNiciraHeader(parent *Experimenter, decoder *goloxi.Decoder) (INiciraHeader, error) {
	_niciraheader := &NiciraHeader{Experimenter: parent}
	return _niciraheader, nil
}

func NewNiciraHeader(_subtype uint32) *NiciraHeader {
	obj := &NiciraHeader{
		Experimenter: NewExperimenter(8992),
	}
	obj.Subtype = _subtype
	return obj
}

type PacketIn struct {
	*Header
	BufferId uint32
	TotalLen uint16
	Reason   uint8
	TableId  uint8
	Cookie   uint64
	Match    Match
	Data     []byte
}

type IPacketIn interface {
	IHeader
	GetBufferId() uint32
	GetTotalLen() uint16
	GetReason() uint8
	GetTableId() uint8
	GetCookie() uint64
	GetMatch() Match
	GetData() []byte
}

func (self *PacketIn) GetBufferId() uint32 {
	return self.BufferId
}

func (self *PacketIn) SetBufferId(v uint32) {
	self.BufferId = v
}

func (self *PacketIn) GetTotalLen() uint16 {
	return self.TotalLen
}

func (self *PacketIn) SetTotalLen(v uint16) {
	self.TotalLen = v
}

func (self *PacketIn) GetReason() uint8 {
	return self.Reason
}

func (self *PacketIn) SetReason(v uint8) {
	self.Reason = v
}

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

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

func (self *PacketIn) GetCookie() uint64 {
	return self.Cookie
}

func (self *PacketIn) SetCookie(v uint64) {
	self.Cookie = v
}

func (self *PacketIn) GetMatch() Match {
	return self.Match
}

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

func (self *PacketIn) GetData() []byte {
	return self.Data
}

func (self *PacketIn) SetData(v []byte) {
	self.Data = v
}

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

	encoder.PutUint32(uint32(self.BufferId))
	encoder.PutUint16(uint16(self.TotalLen))
	encoder.PutUint8(uint8(self.Reason))
	encoder.PutUint8(uint8(self.TableId))
	encoder.PutUint64(uint64(self.Cookie))
	if err := self.Match.Serialize(encoder); err != nil {
		return err
	}

	encoder.Write(bytes.Repeat([]byte{0}, 2))
	encoder.Write(self.Data)
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodePacketIn(parent *Header, decoder *goloxi.Decoder) (*PacketIn, error) {
	_packetin := &PacketIn{Header: parent}
	if decoder.Length() < 26 {
		return nil, fmt.Errorf("PacketIn packet too short: %d < 26", decoder.Length())
	}
	_packetin.BufferId = uint32(decoder.ReadUint32())
	_packetin.TotalLen = uint16(decoder.ReadUint16())
	_packetin.Reason = uint8(decoder.ReadByte())
	_packetin.TableId = uint8(decoder.ReadByte())
	_packetin.Cookie = uint64(decoder.ReadUint64())
	if err := _packetin.Match.Decode(decoder); err != nil {
		return nil, err
	}

	decoder.SkipAlign()
	decoder.Skip(2)
	_packetin.Data = decoder.Read(int(decoder.Length()))
	return _packetin, nil
}

func NewPacketIn() *PacketIn {
	obj := &PacketIn{
		Header: NewHeader(10),
	}
	return obj
}

type PacketOut struct {
	*Header
	BufferId   uint32
	InPort     Port
	ActionsLen uint16
	Actions    []goloxi.IAction
	Data       []byte
}

type IPacketOut interface {
	IHeader
	GetBufferId() uint32
	GetInPort() Port
	GetActionsLen() uint16
	GetActions() []goloxi.IAction
	GetData() []byte
}

func (self *PacketOut) GetBufferId() uint32 {
	return self.BufferId
}

func (self *PacketOut) SetBufferId(v uint32) {
	self.BufferId = v
}

func (self *PacketOut) GetInPort() Port {
	return self.InPort
}

func (self *PacketOut) SetInPort(v Port) {
	self.InPort = v
}

func (self *PacketOut) GetActionsLen() uint16 {
	return self.ActionsLen
}

func (self *PacketOut) SetActionsLen(v uint16) {
	self.ActionsLen = v
}

func (self *PacketOut) GetActions() []goloxi.IAction {
	return self.Actions
}

func (self *PacketOut) SetActions(v []goloxi.IAction) {
	self.Actions = v
}

func (self *PacketOut) GetData() []byte {
	return self.Data
}

func (self *PacketOut) SetData(v []byte) {
	self.Data = v
}

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

	encoder.PutUint32(uint32(self.BufferId))
	self.InPort.Serialize(encoder)
	encoder.PutUint16(uint16(self.ActionsLen))
	encoder.Write(bytes.Repeat([]byte{0}, 6))
	for _, obj := range self.Actions {
		if err := obj.Serialize(encoder); err != nil {
			return err
		}
	}
	encoder.Write(self.Data)
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodePacketOut(parent *Header, decoder *goloxi.Decoder) (*PacketOut, error) {
	_packetout := &PacketOut{Header: parent}
	if decoder.Length() < 16 {
		return nil, fmt.Errorf("PacketOut packet too short: %d < 16", decoder.Length())
	}
	_packetout.BufferId = uint32(decoder.ReadUint32())
	_packetout.InPort.Decode(decoder)
	_packetout.ActionsLen = uint16(decoder.ReadUint16())
	decoder.Skip(6)

	end := decoder.Offset() + int(_packetout.ActionsLen)
	for decoder.Offset() < end {
		item, err := DecodeAction(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_packetout.Actions = append(_packetout.Actions, item)
		}
	}
	_packetout.Data = decoder.Read(int(decoder.Length()))
	return _packetout, nil
}

func NewPacketOut() *PacketOut {
	obj := &PacketOut{
		Header: NewHeader(13),
	}
	return obj
}

type PortDescStatsReply struct {
	*StatsReply
	Entries []*PortDesc
}

type IPortDescStatsReply interface {
	IStatsReply
	GetEntries() []*PortDesc
}

func (self *PortDescStatsReply) GetEntries() []*PortDesc {
	return self.Entries
}

func (self *PortDescStatsReply) SetEntries(v []*PortDesc) {
	self.Entries = v
}

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

	encoder.Write(bytes.Repeat([]byte{0}, 4))
	for _, obj := range self.Entries {
		if err := obj.Serialize(encoder); err != nil {
			return err
		}
	}
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodePortDescStatsReply(parent *StatsReply, decoder *goloxi.Decoder) (*PortDescStatsReply, error) {
	_portdescstatsreply := &PortDescStatsReply{StatsReply: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("PortDescStatsReply packet too short: %d < 4", decoder.Length())
	}
	decoder.Skip(4)

	for decoder.Length() >= 40 {
		item := &PortDesc{}
		if err := item.Decode(decoder); err != nil {
			return nil, err
		}
		if item != nil {
			_portdescstatsreply.Entries = append(_portdescstatsreply.Entries, item)
		}
	}
	return _portdescstatsreply, nil
}

func NewPortDescStatsReply() *PortDescStatsReply {
	obj := &PortDescStatsReply{
		StatsReply: NewStatsReply(13),
	}
	return obj
}

type PortDescStatsRequest struct {
	*StatsRequest
}

type IPortDescStatsRequest interface {
	IStatsRequest
}

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

	encoder.Write(bytes.Repeat([]byte{0}, 4))
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodePortDescStatsRequest(parent *StatsRequest, decoder *goloxi.Decoder) (*PortDescStatsRequest, error) {
	_portdescstatsrequest := &PortDescStatsRequest{StatsRequest: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("PortDescStatsRequest packet too short: %d < 4", decoder.Length())
	}
	decoder.Skip(4)
	return _portdescstatsrequest, nil
}

func NewPortDescStatsRequest() *PortDescStatsRequest {
	obj := &PortDescStatsRequest{
		StatsRequest: NewStatsRequest(13),
	}
	return obj
}

type PortMod struct {
	*Header
	PortNo     Port
	HwAddr     net.HardwareAddr
	Config     PortConfig
	Mask       PortConfig
	Properties []IPortModProp
}

type IPortMod interface {
	IHeader
	GetPortNo() Port
	GetHwAddr() net.HardwareAddr
	GetConfig() PortConfig
	GetMask() PortConfig
	GetProperties() []IPortModProp
}

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

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

func (self *PortMod) GetHwAddr() net.HardwareAddr {
	return self.HwAddr
}

func (self *PortMod) SetHwAddr(v net.HardwareAddr) {
	self.HwAddr = v
}

func (self *PortMod) GetConfig() PortConfig {
	return self.Config
}

func (self *PortMod) SetConfig(v PortConfig) {
	self.Config = v
}

func (self *PortMod) GetMask() PortConfig {
	return self.Mask
}

func (self *PortMod) SetMask(v PortConfig) {
	self.Mask = v
}

func (self *PortMod) GetProperties() []IPortModProp {
	return self.Properties
}

func (self *PortMod) SetProperties(v []IPortModProp) {
	self.Properties = v
}

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

	self.PortNo.Serialize(encoder)
	encoder.Write(bytes.Repeat([]byte{0}, 4))
	encoder.Write(self.HwAddr)
	encoder.Write(bytes.Repeat([]byte{0}, 2))
	encoder.PutUint32(uint32(self.Config))
	encoder.PutUint32(uint32(self.Mask))
	for _, obj := range self.Properties {
		if err := obj.Serialize(encoder); err != nil {
			return err
		}
	}
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodePortMod(parent *Header, decoder *goloxi.Decoder) (*PortMod, error) {
	_portmod := &PortMod{Header: parent}
	if decoder.Length() < 24 {
		return nil, fmt.Errorf("PortMod packet too short: %d < 24", decoder.Length())
	}
	_portmod.PortNo.Decode(decoder)
	decoder.Skip(4)
	_portmod.HwAddr = net.HardwareAddr(decoder.Read(6))
	decoder.Skip(2)
	_portmod.Config = PortConfig(decoder.ReadUint32())
	_portmod.Mask = PortConfig(decoder.ReadUint32())

	for decoder.Length() >= 4 {
		item, err := DecodePortModProp(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_portmod.Properties = append(_portmod.Properties, item)
		}
	}
	return _portmod, nil
}

func NewPortMod() *PortMod {
	obj := &PortMod{
		Header: NewHeader(16),
	}
	return obj
}

type PortModFailedErrorMsg struct {
	*ErrorMsg
	Code PortModFailedCode
	Data []byte
}

type IPortModFailedErrorMsg interface {
	IErrorMsg
	GetCode() PortModFailedCode
	GetData() []byte
}

func (self *PortModFailedErrorMsg) GetCode() PortModFailedCode {
	return self.Code
}

func (self *PortModFailedErrorMsg) SetCode(v PortModFailedCode) {
	self.Code = v
}

func (self *PortModFailedErrorMsg) GetData() []byte {
	return self.Data
}

func (self *PortModFailedErrorMsg) SetData(v []byte) {
	self.Data = v
}

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

	encoder.PutUint16(uint16(self.Code))
	encoder.Write(self.Data)
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodePortModFailedErrorMsg(parent *ErrorMsg, decoder *goloxi.Decoder) (*PortModFailedErrorMsg, error) {
	_portmodfailederrormsg := &PortModFailedErrorMsg{ErrorMsg: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("PortModFailedErrorMsg packet too short: %d < 2", decoder.Length())
	}
	_portmodfailederrormsg.Code = PortModFailedCode(decoder.ReadUint16())
	_portmodfailederrormsg.Data = decoder.Read(int(decoder.Length()))
	return _portmodfailederrormsg, nil
}

func NewPortModFailedErrorMsg() *PortModFailedErrorMsg {
	obj := &PortModFailedErrorMsg{
		ErrorMsg: NewErrorMsg(7),
	}
	return obj
}

type PortStatsReply struct {
	*StatsReply
	Entries []*PortStatsEntry
}

type IPortStatsReply interface {
	IStatsReply
	GetEntries() []*PortStatsEntry
}

func (self *PortStatsReply) GetEntries() []*PortStatsEntry {
	return self.Entries
}

func (self *PortStatsReply) SetEntries(v []*PortStatsEntry) {
	self.Entries = v
}

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

	encoder.Write(bytes.Repeat([]byte{0}, 4))
	for _, obj := range self.Entries {
		if err := obj.Serialize(encoder); err != nil {
			return err
		}
	}
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodePortStatsReply(parent *StatsReply, decoder *goloxi.Decoder) (*PortStatsReply, error) {
	_portstatsreply := &PortStatsReply{StatsReply: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("PortStatsReply packet too short: %d < 4", decoder.Length())
	}
	decoder.Skip(4)

	for decoder.Length() >= 80 {
		item, err := DecodePortStatsEntry(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_portstatsreply.Entries = append(_portstatsreply.Entries, item)
		}
	}
	return _portstatsreply, nil
}

func NewPortStatsReply() *PortStatsReply {
	obj := &PortStatsReply{
		StatsReply: NewStatsReply(4),
	}
	return obj
}

type PortStatsRequest struct {
	*StatsRequest
	PortNo Port
}

type IPortStatsRequest interface {
	IStatsRequest
	GetPortNo() Port
}

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

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

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

	encoder.Write(bytes.Repeat([]byte{0}, 4))
	self.PortNo.Serialize(encoder)
	encoder.Write(bytes.Repeat([]byte{0}, 4))
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodePortStatsRequest(parent *StatsRequest, decoder *goloxi.Decoder) (*PortStatsRequest, error) {
	_portstatsrequest := &PortStatsRequest{StatsRequest: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("PortStatsRequest packet too short: %d < 4", decoder.Length())
	}
	decoder.Skip(4)
	_portstatsrequest.PortNo.Decode(decoder)
	decoder.Skip(4)
	return _portstatsrequest, nil
}

func NewPortStatsRequest() *PortStatsRequest {
	obj := &PortStatsRequest{
		StatsRequest: NewStatsRequest(4),
	}
	return obj
}

type PortStatus struct {
	*Header
	Reason PortReason
	Desc   PortDesc
}

type IPortStatus interface {
	IHeader
	GetReason() PortReason
	GetDesc() PortDesc
}

func (self *PortStatus) GetReason() PortReason {
	return self.Reason
}

func (self *PortStatus) SetReason(v PortReason) {
	self.Reason = v
}

func (self *PortStatus) GetDesc() PortDesc {
	return self.Desc
}

func (self *PortStatus) SetDesc(v PortDesc) {
	self.Desc = v
}

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

	encoder.PutUint8(uint8(self.Reason))
	encoder.Write(bytes.Repeat([]byte{0}, 7))
	if err := self.Desc.Serialize(encoder); err != nil {
		return err
	}

	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodePortStatus(parent *Header, decoder *goloxi.Decoder) (*PortStatus, error) {
	_portstatus := &PortStatus{Header: parent}
	if decoder.Length() < 48 {
		return nil, fmt.Errorf("PortStatus packet too short: %d < 48", decoder.Length())
	}
	_portstatus.Reason = PortReason(decoder.ReadByte())
	decoder.Skip(7)
	if err := _portstatus.Desc.Decode(decoder); err != nil {
		return nil, err
	}

	return _portstatus, nil
}

func NewPortStatus() *PortStatus {
	obj := &PortStatus{
		Header: NewHeader(12),
	}
	return obj
}

type QueueDescStatsReply struct {
	*StatsReply
	Entries []*QueueDesc
}

type IQueueDescStatsReply interface {
	IStatsReply
	GetEntries() []*QueueDesc
}

func (self *QueueDescStatsReply) GetEntries() []*QueueDesc {
	return self.Entries
}

func (self *QueueDescStatsReply) SetEntries(v []*QueueDesc) {
	self.Entries = v
}

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

	encoder.Write(bytes.Repeat([]byte{0}, 4))
	for _, obj := range self.Entries {
		if err := obj.Serialize(encoder); err != nil {
			return err
		}
	}
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeQueueDescStatsReply(parent *StatsReply, decoder *goloxi.Decoder) (*QueueDescStatsReply, error) {
	_queuedescstatsreply := &QueueDescStatsReply{StatsReply: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("QueueDescStatsReply packet too short: %d < 4", decoder.Length())
	}
	decoder.Skip(4)

	for decoder.Length() >= 16 {
		item, err := DecodeQueueDesc(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_queuedescstatsreply.Entries = append(_queuedescstatsreply.Entries, item)
		}
	}
	return _queuedescstatsreply, nil
}

func NewQueueDescStatsReply() *QueueDescStatsReply {
	obj := &QueueDescStatsReply{
		StatsReply: NewStatsReply(15),
	}
	return obj
}

type QueueDescStatsRequest struct {
	*StatsRequest
	PortNo  Port
	QueueId uint32
}

type IQueueDescStatsRequest interface {
	IStatsRequest
	GetPortNo() Port
	GetQueueId() uint32
}

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

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

func (self *QueueDescStatsRequest) GetQueueId() uint32 {
	return self.QueueId
}

func (self *QueueDescStatsRequest) SetQueueId(v uint32) {
	self.QueueId = v
}

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

	encoder.Write(bytes.Repeat([]byte{0}, 4))
	self.PortNo.Serialize(encoder)
	encoder.PutUint32(uint32(self.QueueId))
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeQueueDescStatsRequest(parent *StatsRequest, decoder *goloxi.Decoder) (*QueueDescStatsRequest, error) {
	_queuedescstatsrequest := &QueueDescStatsRequest{StatsRequest: parent}
	if decoder.Length() < 12 {
		return nil, fmt.Errorf("QueueDescStatsRequest packet too short: %d < 12", decoder.Length())
	}
	decoder.Skip(4)
	_queuedescstatsrequest.PortNo.Decode(decoder)
	_queuedescstatsrequest.QueueId = uint32(decoder.ReadUint32())
	return _queuedescstatsrequest, nil
}

func NewQueueDescStatsRequest() *QueueDescStatsRequest {
	obj := &QueueDescStatsRequest{
		StatsRequest: NewStatsRequest(15),
	}
	return obj
}

type QueueOpFailedErrorMsg struct {
	*ErrorMsg
	Code QueueOpFailedCode
	Data []byte
}

type IQueueOpFailedErrorMsg interface {
	IErrorMsg
	GetCode() QueueOpFailedCode
	GetData() []byte
}

func (self *QueueOpFailedErrorMsg) GetCode() QueueOpFailedCode {
	return self.Code
}

func (self *QueueOpFailedErrorMsg) SetCode(v QueueOpFailedCode) {
	self.Code = v
}

func (self *QueueOpFailedErrorMsg) GetData() []byte {
	return self.Data
}

func (self *QueueOpFailedErrorMsg) SetData(v []byte) {
	self.Data = v
}

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

	encoder.PutUint16(uint16(self.Code))
	encoder.Write(self.Data)
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeQueueOpFailedErrorMsg(parent *ErrorMsg, decoder *goloxi.Decoder) (*QueueOpFailedErrorMsg, error) {
	_queueopfailederrormsg := &QueueOpFailedErrorMsg{ErrorMsg: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("QueueOpFailedErrorMsg packet too short: %d < 2", decoder.Length())
	}
	_queueopfailederrormsg.Code = QueueOpFailedCode(decoder.ReadUint16())
	_queueopfailederrormsg.Data = decoder.Read(int(decoder.Length()))
	return _queueopfailederrormsg, nil
}

func NewQueueOpFailedErrorMsg() *QueueOpFailedErrorMsg {
	obj := &QueueOpFailedErrorMsg{
		ErrorMsg: NewErrorMsg(9),
	}
	return obj
}

type QueueStatsReply struct {
	*StatsReply
	Entries []*QueueStatsEntry
}

type IQueueStatsReply interface {
	IStatsReply
	GetEntries() []*QueueStatsEntry
}

func (self *QueueStatsReply) GetEntries() []*QueueStatsEntry {
	return self.Entries
}

func (self *QueueStatsReply) SetEntries(v []*QueueStatsEntry) {
	self.Entries = v
}

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

	encoder.Write(bytes.Repeat([]byte{0}, 4))
	for _, obj := range self.Entries {
		if err := obj.Serialize(encoder); err != nil {
			return err
		}
	}
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeQueueStatsReply(parent *StatsReply, decoder *goloxi.Decoder) (*QueueStatsReply, error) {
	_queuestatsreply := &QueueStatsReply{StatsReply: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("QueueStatsReply packet too short: %d < 4", decoder.Length())
	}
	decoder.Skip(4)

	for decoder.Length() >= 48 {
		item, err := DecodeQueueStatsEntry(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_queuestatsreply.Entries = append(_queuestatsreply.Entries, item)
		}
	}
	return _queuestatsreply, nil
}

func NewQueueStatsReply() *QueueStatsReply {
	obj := &QueueStatsReply{
		StatsReply: NewStatsReply(5),
	}
	return obj
}

type QueueStatsRequest struct {
	*StatsRequest
	PortNo  Port
	QueueId uint32
}

type IQueueStatsRequest interface {
	IStatsRequest
	GetPortNo() Port
	GetQueueId() uint32
}

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

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

func (self *QueueStatsRequest) GetQueueId() uint32 {
	return self.QueueId
}

func (self *QueueStatsRequest) SetQueueId(v uint32) {
	self.QueueId = v
}

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

	encoder.Write(bytes.Repeat([]byte{0}, 4))
	self.PortNo.Serialize(encoder)
	encoder.PutUint32(uint32(self.QueueId))
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeQueueStatsRequest(parent *StatsRequest, decoder *goloxi.Decoder) (*QueueStatsRequest, error) {
	_queuestatsrequest := &QueueStatsRequest{StatsRequest: parent}
	if decoder.Length() < 12 {
		return nil, fmt.Errorf("QueueStatsRequest packet too short: %d < 12", decoder.Length())
	}
	decoder.Skip(4)
	_queuestatsrequest.PortNo.Decode(decoder)
	_queuestatsrequest.QueueId = uint32(decoder.ReadUint32())
	return _queuestatsrequest, nil
}

func NewQueueStatsRequest() *QueueStatsRequest {
	obj := &QueueStatsRequest{
		StatsRequest: NewStatsRequest(5),
	}
	return obj
}

type Requestforward struct {
	*Header
	Request IHeader
}

type IRequestforward interface {
	IHeader
	GetRequest() IHeader
}

func (self *Requestforward) GetRequest() IHeader {
	return self.Request
}

func (self *Requestforward) SetRequest(v IHeader) {
	self.Request = v
}

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

	self.Request.Serialize(encoder)
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeRequestforward(parent *Header, decoder *goloxi.Decoder) (*Requestforward, error) {
	_requestforward := &Requestforward{Header: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("Requestforward packet too short: %d < 8", decoder.Length())
	}
	if obj, err := DecodeHeader(decoder); err != nil {
		return nil, err
	} else {
		_requestforward.Request = obj
	}

	return _requestforward, nil
}

func NewRequestforward() *Requestforward {
	obj := &Requestforward{
		Header: NewHeader(32),
	}
	return obj
}

type RoleReply struct {
	*Header
	Role         ControllerRole
	GenerationId uint64
}

type IRoleReply interface {
	IHeader
	GetRole() ControllerRole
	GetGenerationId() uint64
}

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

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

func (self *RoleReply) GetGenerationId() uint64 {
	return self.GenerationId
}

func (self *RoleReply) SetGenerationId(v uint64) {
	self.GenerationId = v
}

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

	encoder.PutUint32(uint32(self.Role))
	encoder.Write(bytes.Repeat([]byte{0}, 4))
	encoder.PutUint64(uint64(self.GenerationId))
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeRoleReply(parent *Header, decoder *goloxi.Decoder) (*RoleReply, error) {
	_rolereply := &RoleReply{Header: parent}
	if decoder.Length() < 16 {
		return nil, fmt.Errorf("RoleReply packet too short: %d < 16", decoder.Length())
	}
	_rolereply.Role = ControllerRole(decoder.ReadUint32())
	decoder.Skip(4)
	_rolereply.GenerationId = uint64(decoder.ReadUint64())
	return _rolereply, nil
}

func NewRoleReply() *RoleReply {
	obj := &RoleReply{
		Header: NewHeader(25),
	}
	return obj
}

type RoleRequest struct {
	*Header
	Role         ControllerRole
	GenerationId uint64
}

type IRoleRequest interface {
	IHeader
	GetRole() ControllerRole
	GetGenerationId() uint64
}

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

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

func (self *RoleRequest) GetGenerationId() uint64 {
	return self.GenerationId
}

func (self *RoleRequest) SetGenerationId(v uint64) {
	self.GenerationId = v
}

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

	encoder.PutUint32(uint32(self.Role))
	encoder.Write(bytes.Repeat([]byte{0}, 4))
	encoder.PutUint64(uint64(self.GenerationId))
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeRoleRequest(parent *Header, decoder *goloxi.Decoder) (*RoleRequest, error) {
	_rolerequest := &RoleRequest{Header: parent}
	if decoder.Length() < 16 {
		return nil, fmt.Errorf("RoleRequest packet too short: %d < 16", decoder.Length())
	}
	_rolerequest.Role = ControllerRole(decoder.ReadUint32())
	decoder.Skip(4)
	_rolerequest.GenerationId = uint64(decoder.ReadUint64())
	return _rolerequest, nil
}

func NewRoleRequest() *RoleRequest {
	obj := &RoleRequest{
		Header: NewHeader(24),
	}
	return obj
}

type RoleRequestFailedErrorMsg struct {
	*ErrorMsg
	Code RoleRequestFailedCode
	Data []byte
}

type IRoleRequestFailedErrorMsg interface {
	IErrorMsg
	GetCode() RoleRequestFailedCode
	GetData() []byte
}

func (self *RoleRequestFailedErrorMsg) GetCode() RoleRequestFailedCode {
	return self.Code
}

func (self *RoleRequestFailedErrorMsg) SetCode(v RoleRequestFailedCode) {
	self.Code = v
}

func (self *RoleRequestFailedErrorMsg) GetData() []byte {
	return self.Data
}

func (self *RoleRequestFailedErrorMsg) SetData(v []byte) {
	self.Data = v
}

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

	encoder.PutUint16(uint16(self.Code))
	encoder.Write(self.Data)
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeRoleRequestFailedErrorMsg(parent *ErrorMsg, decoder *goloxi.Decoder) (*RoleRequestFailedErrorMsg, error) {
	_rolerequestfailederrormsg := &RoleRequestFailedErrorMsg{ErrorMsg: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("RoleRequestFailedErrorMsg packet too short: %d < 2", decoder.Length())
	}
	_rolerequestfailederrormsg.Code = RoleRequestFailedCode(decoder.ReadUint16())
	_rolerequestfailederrormsg.Data = decoder.Read(int(decoder.Length()))
	return _rolerequestfailederrormsg, nil
}

func NewRoleRequestFailedErrorMsg() *RoleRequestFailedErrorMsg {
	obj := &RoleRequestFailedErrorMsg{
		ErrorMsg: NewErrorMsg(11),
	}
	return obj
}

type RoleStatus struct {
	*Header
	Role         ControllerRole
	Reason       ControllerRoleReason
	GenerationId uint64
	Properties   []IRoleProp
}

type IRoleStatus interface {
	IHeader
	GetRole() ControllerRole
	GetReason() ControllerRoleReason
	GetGenerationId() uint64
	GetProperties() []IRoleProp
}

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

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

func (self *RoleStatus) GetReason() ControllerRoleReason {
	return self.Reason
}

func (self *RoleStatus) SetReason(v ControllerRoleReason) {
	self.Reason = v
}

func (self *RoleStatus) GetGenerationId() uint64 {
	return self.GenerationId
}

func (self *RoleStatus) SetGenerationId(v uint64) {
	self.GenerationId = v
}

func (self *RoleStatus) GetProperties() []IRoleProp {
	return self.Properties
}

func (self *RoleStatus) SetProperties(v []IRoleProp) {
	self.Properties = v
}

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

	encoder.PutUint32(uint32(self.Role))
	encoder.PutUint8(uint8(self.Reason))
	encoder.Write(bytes.Repeat([]byte{0}, 3))
	encoder.PutUint64(uint64(self.GenerationId))
	for _, obj := range self.Properties {
		if err := obj.Serialize(encoder); err != nil {
			return err
		}
	}
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeRoleStatus(parent *Header, decoder *goloxi.Decoder) (*RoleStatus, error) {
	_rolestatus := &RoleStatus{Header: parent}
	if decoder.Length() < 16 {
		return nil, fmt.Errorf("RoleStatus packet too short: %d < 16", decoder.Length())
	}
	_rolestatus.Role = ControllerRole(decoder.ReadUint32())
	_rolestatus.Reason = ControllerRoleReason(decoder.ReadByte())
	decoder.Skip(3)
	_rolestatus.GenerationId = uint64(decoder.ReadUint64())

	for decoder.Length() >= 4 {
		item, err := DecodeRoleProp(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_rolestatus.Properties = append(_rolestatus.Properties, item)
		}
	}
	return _rolestatus, nil
}

func NewRoleStatus() *RoleStatus {
	obj := &RoleStatus{
		Header: NewHeader(30),
	}
	return obj
}

type SetConfig struct {
	*Header
	Flags       ConfigFlags
	MissSendLen uint16
}

type ISetConfig interface {
	IHeader
	GetFlags() ConfigFlags
	GetMissSendLen() uint16
}

func (self *SetConfig) GetFlags() ConfigFlags {
	return self.Flags
}

func (self *SetConfig) SetFlags(v ConfigFlags) {
	self.Flags = v
}

func (self *SetConfig) GetMissSendLen() uint16 {
	return self.MissSendLen
}

func (self *SetConfig) SetMissSendLen(v uint16) {
	self.MissSendLen = v
}

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

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

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

	return nil
}

func DecodeSetConfig(parent *Header, decoder *goloxi.Decoder) (*SetConfig, error) {
	_setconfig := &SetConfig{Header: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("SetConfig packet too short: %d < 4", decoder.Length())
	}
	_setconfig.Flags = ConfigFlags(decoder.ReadUint16())
	_setconfig.MissSendLen = uint16(decoder.ReadUint16())
	return _setconfig, nil
}

func NewSetConfig() *SetConfig {
	obj := &SetConfig{
		Header: NewHeader(9),
	}
	return obj
}

type SwitchConfigFailedErrorMsg struct {
	*ErrorMsg
	Code SwitchConfigFailedCode
	Data []byte
}

type ISwitchConfigFailedErrorMsg interface {
	IErrorMsg
	GetCode() SwitchConfigFailedCode
	GetData() []byte
}

func (self *SwitchConfigFailedErrorMsg) GetCode() SwitchConfigFailedCode {
	return self.Code
}

func (self *SwitchConfigFailedErrorMsg) SetCode(v SwitchConfigFailedCode) {
	self.Code = v
}

func (self *SwitchConfigFailedErrorMsg) GetData() []byte {
	return self.Data
}

func (self *SwitchConfigFailedErrorMsg) SetData(v []byte) {
	self.Data = v
}

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

	encoder.PutUint16(uint16(self.Code))
	encoder.Write(self.Data)
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeSwitchConfigFailedErrorMsg(parent *ErrorMsg, decoder *goloxi.Decoder) (*SwitchConfigFailedErrorMsg, error) {
	_switchconfigfailederrormsg := &SwitchConfigFailedErrorMsg{ErrorMsg: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("SwitchConfigFailedErrorMsg packet too short: %d < 2", decoder.Length())
	}
	_switchconfigfailederrormsg.Code = SwitchConfigFailedCode(decoder.ReadUint16())
	_switchconfigfailederrormsg.Data = decoder.Read(int(decoder.Length()))
	return _switchconfigfailederrormsg, nil
}

func NewSwitchConfigFailedErrorMsg() *SwitchConfigFailedErrorMsg {
	obj := &SwitchConfigFailedErrorMsg{
		ErrorMsg: NewErrorMsg(10),
	}
	return obj
}

type TableDescStatsReply struct {
	*StatsReply
	Entries []*TableDesc
}

type ITableDescStatsReply interface {
	IStatsReply
	GetEntries() []*TableDesc
}

func (self *TableDescStatsReply) GetEntries() []*TableDesc {
	return self.Entries
}

func (self *TableDescStatsReply) SetEntries(v []*TableDesc) {
	self.Entries = v
}

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

	encoder.Write(bytes.Repeat([]byte{0}, 4))
	for _, obj := range self.Entries {
		if err := obj.Serialize(encoder); err != nil {
			return err
		}
	}
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeTableDescStatsReply(parent *StatsReply, decoder *goloxi.Decoder) (*TableDescStatsReply, error) {
	_tabledescstatsreply := &TableDescStatsReply{StatsReply: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("TableDescStatsReply packet too short: %d < 4", decoder.Length())
	}
	decoder.Skip(4)

	for decoder.Length() >= 8 {
		item := &TableDesc{}
		if err := item.Decode(decoder); err != nil {
			return nil, err
		}
		if item != nil {
			_tabledescstatsreply.Entries = append(_tabledescstatsreply.Entries, item)
		}
	}
	return _tabledescstatsreply, nil
}

func NewTableDescStatsReply() *TableDescStatsReply {
	obj := &TableDescStatsReply{
		StatsReply: NewStatsReply(14),
	}
	return obj
}

type TableDescStatsRequest struct {
	*StatsRequest
}

type ITableDescStatsRequest interface {
	IStatsRequest
}

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

	encoder.Write(bytes.Repeat([]byte{0}, 4))
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeTableDescStatsRequest(parent *StatsRequest, decoder *goloxi.Decoder) (*TableDescStatsRequest, error) {
	_tabledescstatsrequest := &TableDescStatsRequest{StatsRequest: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("TableDescStatsRequest packet too short: %d < 4", decoder.Length())
	}
	decoder.Skip(4)
	return _tabledescstatsrequest, nil
}

func NewTableDescStatsRequest() *TableDescStatsRequest {
	obj := &TableDescStatsRequest{
		StatsRequest: NewStatsRequest(14),
	}
	return obj
}

type TableFeaturesFailedErrorMsg struct {
	*ErrorMsg
	Code TableFeaturesFailedCode
	Data []byte
}

type ITableFeaturesFailedErrorMsg interface {
	IErrorMsg
	GetCode() TableFeaturesFailedCode
	GetData() []byte
}

func (self *TableFeaturesFailedErrorMsg) GetCode() TableFeaturesFailedCode {
	return self.Code
}

func (self *TableFeaturesFailedErrorMsg) SetCode(v TableFeaturesFailedCode) {
	self.Code = v
}

func (self *TableFeaturesFailedErrorMsg) GetData() []byte {
	return self.Data
}

func (self *TableFeaturesFailedErrorMsg) SetData(v []byte) {
	self.Data = v
}

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

	encoder.PutUint16(uint16(self.Code))
	encoder.Write(self.Data)
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeTableFeaturesFailedErrorMsg(parent *ErrorMsg, decoder *goloxi.Decoder) (*TableFeaturesFailedErrorMsg, error) {
	_tablefeaturesfailederrormsg := &TableFeaturesFailedErrorMsg{ErrorMsg: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("TableFeaturesFailedErrorMsg packet too short: %d < 2", decoder.Length())
	}
	_tablefeaturesfailederrormsg.Code = TableFeaturesFailedCode(decoder.ReadUint16())
	_tablefeaturesfailederrormsg.Data = decoder.Read(int(decoder.Length()))
	return _tablefeaturesfailederrormsg, nil
}

func NewTableFeaturesFailedErrorMsg() *TableFeaturesFailedErrorMsg {
	obj := &TableFeaturesFailedErrorMsg{
		ErrorMsg: NewErrorMsg(13),
	}
	return obj
}

type TableFeaturesStatsReply struct {
	*StatsReply
	Entries []*TableFeatures
}

type ITableFeaturesStatsReply interface {
	IStatsReply
	GetEntries() []*TableFeatures
}

func (self *TableFeaturesStatsReply) GetEntries() []*TableFeatures {
	return self.Entries
}

func (self *TableFeaturesStatsReply) SetEntries(v []*TableFeatures) {
	self.Entries = v
}

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

	encoder.Write(bytes.Repeat([]byte{0}, 4))
	for _, obj := range self.Entries {
		if err := obj.Serialize(encoder); err != nil {
			return err
		}
	}
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeTableFeaturesStatsReply(parent *StatsReply, decoder *goloxi.Decoder) (*TableFeaturesStatsReply, error) {
	_tablefeaturesstatsreply := &TableFeaturesStatsReply{StatsReply: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("TableFeaturesStatsReply packet too short: %d < 4", decoder.Length())
	}
	decoder.Skip(4)

	for decoder.Length() >= 64 {
		item, err := DecodeTableFeatures(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_tablefeaturesstatsreply.Entries = append(_tablefeaturesstatsreply.Entries, item)
		}
	}
	return _tablefeaturesstatsreply, nil
}

func NewTableFeaturesStatsReply() *TableFeaturesStatsReply {
	obj := &TableFeaturesStatsReply{
		StatsReply: NewStatsReply(12),
	}
	return obj
}

type TableFeaturesStatsRequest struct {
	*StatsRequest
	Entries []*TableFeatures
}

type ITableFeaturesStatsRequest interface {
	IStatsRequest
	GetEntries() []*TableFeatures
}

func (self *TableFeaturesStatsRequest) GetEntries() []*TableFeatures {
	return self.Entries
}

func (self *TableFeaturesStatsRequest) SetEntries(v []*TableFeatures) {
	self.Entries = v
}

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

	encoder.Write(bytes.Repeat([]byte{0}, 4))
	for _, obj := range self.Entries {
		if err := obj.Serialize(encoder); err != nil {
			return err
		}
	}
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeTableFeaturesStatsRequest(parent *StatsRequest, decoder *goloxi.Decoder) (*TableFeaturesStatsRequest, error) {
	_tablefeaturesstatsrequest := &TableFeaturesStatsRequest{StatsRequest: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("TableFeaturesStatsRequest packet too short: %d < 4", decoder.Length())
	}
	decoder.Skip(4)

	for decoder.Length() >= 64 {
		item, err := DecodeTableFeatures(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_tablefeaturesstatsrequest.Entries = append(_tablefeaturesstatsrequest.Entries, item)
		}
	}
	return _tablefeaturesstatsrequest, nil
}

func NewTableFeaturesStatsRequest() *TableFeaturesStatsRequest {
	obj := &TableFeaturesStatsRequest{
		StatsRequest: NewStatsRequest(12),
	}
	return obj
}

type TableMod struct {
	*Header
	TableId    uint8
	Config     uint32
	Properties []ITableModProp
}

type ITableMod interface {
	IHeader
	GetTableId() uint8
	GetConfig() uint32
	GetProperties() []ITableModProp
}

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

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

func (self *TableMod) GetConfig() uint32 {
	return self.Config
}

func (self *TableMod) SetConfig(v uint32) {
	self.Config = v
}

func (self *TableMod) GetProperties() []ITableModProp {
	return self.Properties
}

func (self *TableMod) SetProperties(v []ITableModProp) {
	self.Properties = v
}

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

	encoder.PutUint8(uint8(self.TableId))
	encoder.Write(bytes.Repeat([]byte{0}, 3))
	encoder.PutUint32(uint32(self.Config))
	for _, obj := range self.Properties {
		if err := obj.Serialize(encoder); err != nil {
			return err
		}
	}
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeTableMod(parent *Header, decoder *goloxi.Decoder) (*TableMod, error) {
	_tablemod := &TableMod{Header: parent}
	if decoder.Length() < 8 {
		return nil, fmt.Errorf("TableMod packet too short: %d < 8", decoder.Length())
	}
	_tablemod.TableId = uint8(decoder.ReadByte())
	decoder.Skip(3)
	_tablemod.Config = uint32(decoder.ReadUint32())

	for decoder.Length() >= 4 {
		item, err := DecodeTableModProp(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_tablemod.Properties = append(_tablemod.Properties, item)
		}
	}
	return _tablemod, nil
}

func NewTableMod() *TableMod {
	obj := &TableMod{
		Header: NewHeader(17),
	}
	return obj
}

type TableModFailedErrorMsg struct {
	*ErrorMsg
	Code TableModFailedCode
	Data []byte
}

type ITableModFailedErrorMsg interface {
	IErrorMsg
	GetCode() TableModFailedCode
	GetData() []byte
}

func (self *TableModFailedErrorMsg) GetCode() TableModFailedCode {
	return self.Code
}

func (self *TableModFailedErrorMsg) SetCode(v TableModFailedCode) {
	self.Code = v
}

func (self *TableModFailedErrorMsg) GetData() []byte {
	return self.Data
}

func (self *TableModFailedErrorMsg) SetData(v []byte) {
	self.Data = v
}

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

	encoder.PutUint16(uint16(self.Code))
	encoder.Write(self.Data)
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeTableModFailedErrorMsg(parent *ErrorMsg, decoder *goloxi.Decoder) (*TableModFailedErrorMsg, error) {
	_tablemodfailederrormsg := &TableModFailedErrorMsg{ErrorMsg: parent}
	if decoder.Length() < 2 {
		return nil, fmt.Errorf("TableModFailedErrorMsg packet too short: %d < 2", decoder.Length())
	}
	_tablemodfailederrormsg.Code = TableModFailedCode(decoder.ReadUint16())
	_tablemodfailederrormsg.Data = decoder.Read(int(decoder.Length()))
	return _tablemodfailederrormsg, nil
}

func NewTableModFailedErrorMsg() *TableModFailedErrorMsg {
	obj := &TableModFailedErrorMsg{
		ErrorMsg: NewErrorMsg(8),
	}
	return obj
}

type TableStatsReply struct {
	*StatsReply
	Entries []*TableStatsEntry
}

type ITableStatsReply interface {
	IStatsReply
	GetEntries() []*TableStatsEntry
}

func (self *TableStatsReply) GetEntries() []*TableStatsEntry {
	return self.Entries
}

func (self *TableStatsReply) SetEntries(v []*TableStatsEntry) {
	self.Entries = v
}

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

	encoder.Write(bytes.Repeat([]byte{0}, 4))
	for _, obj := range self.Entries {
		if err := obj.Serialize(encoder); err != nil {
			return err
		}
	}
	length := len(encoder.Bytes()) - startIndex

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

	return nil
}

func DecodeTableStatsReply(parent *StatsReply, decoder *goloxi.Decoder) (*TableStatsReply, error) {
	_tablestatsreply := &TableStatsReply{StatsReply: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("TableStatsReply packet too short: %d < 4", decoder.Length())
	}
	decoder.Skip(4)

	for decoder.Length() >= 24 {
		item, err := DecodeTableStatsEntry(decoder)
		if err != nil {
			return nil, err
		}
		if item != nil {
			_tablestatsreply.Entries = append(_tablestatsreply.Entries, item)
		}
	}
	return _tablestatsreply, nil
}

func NewTableStatsReply() *TableStatsReply {
	obj := &TableStatsReply{
		StatsReply: NewStatsReply(3),
	}
	return obj
}

type TableStatsRequest struct {
	*StatsRequest
}

type ITableStatsRequest interface {
	IStatsRequest
}

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

	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 DecodeTableStatsRequest(parent *StatsRequest, decoder *goloxi.Decoder) (*TableStatsRequest, error) {
	_tablestatsrequest := &TableStatsRequest{StatsRequest: parent}
	if decoder.Length() < 4 {
		return nil, fmt.Errorf("TableStatsRequest packet too short: %d < 4", decoder.Length())
	}
	decoder.Skip(4)
	return _tablestatsrequest, nil
}

func NewTableStatsRequest() *TableStatsRequest {
	obj := &TableStatsRequest{
		StatsRequest: NewStatsRequest(3),
	}
	return obj
}

type TableStatus struct {
	*Header
	Role   uint32
	Reason TableReason
	Table  TableDesc
}

type ITableStatus interface {
	IHeader
	GetRole() uint32
	GetReason() TableReason
	GetTable() TableDesc
}

func (self *TableStatus) GetRole() uint32 {
	return self.Role
}

func (self *TableStatus) SetRole(v uint32) {
	self.Role = v
}

func (self *TableStatus) GetReason() TableReason {
	return self.Reason
}

func (self *TableStatus) SetReason(v TableReason) {
	self.Reason = v
}

func (self *TableStatus) GetTable() TableDesc {
	return self.Table
}

func (self *TableStatus) SetTable(v TableDesc) {
	self.Table = v
}

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

	encoder.PutUint32(uint32(self.Role))
	encoder.PutUint8(uint8(self.Reason))
	encoder.Write(bytes.Repeat([]byte{0}, 7))
	if err := self.Table.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 DecodeTableStatus(parent *Header, decoder *goloxi.Decoder) (*TableStatus, error) {
	_tablestatus := &TableStatus{Header: parent}
	if decoder.Length() < 20 {
		return nil, fmt.Errorf("TableStatus packet too short: %d < 20", decoder.Length())
	}
	_tablestatus.Role = uint32(decoder.ReadUint32())
	_tablestatus.Reason = TableReason(decoder.ReadByte())
	decoder.Skip(7)
	if err := _tablestatus.Table.Decode(decoder); err != nil {
		return nil, err
	}

	return _tablestatus, nil
}

func NewTableStatus() *TableStatus {
	obj := &TableStatus{
		Header: NewHeader(31),
	}
	return obj
}