github.com/networkservicemesh/govpp@v0.0.0-20240328101142-8a444680fbba/binapi/lisp/lisp.ba.go

// Code generated by GoVPP's binapi-generator. DO NOT EDIT.
// versions:
//  binapi-generator: v0.10.0-dev
//  VPP:              23.10-rc0~170-g6f1548434
// source: plugins/lisp.api.json

// Package lisp contains generated bindings for API file lisp.api.
//
// Contents:
// -  1 enum
// -  1 struct
// - 60 messages
package lisp

import (
	"strconv"

	_ "github.com/networkservicemesh/govpp/binapi/ethernet_types"
	interface_types "github.com/networkservicemesh/govpp/binapi/interface_types"
	ip_types "github.com/networkservicemesh/govpp/binapi/ip_types"
	lisp_types "github.com/networkservicemesh/govpp/binapi/lisp_types"
	api "go.fd.io/govpp/api"
	codec "go.fd.io/govpp/codec"
)

// This is a compile-time assertion to ensure that this generated file
// is compatible with the GoVPP api package it is being compiled against.
// A compilation error at this line likely means your copy of the
// GoVPP api package needs to be updated.
const _ = api.GoVppAPIPackageIsVersion2

const (
	APIFile    = "lisp"
	APIVersion = "2.0.0"
	VersionCrc = 0xcb04530f
)

// LispLocatorSetFilter defines enum 'lisp_locator_set_filter'.
type LispLocatorSetFilter uint8

const (
	LISP_LOCATOR_SET_FILTER_API_ALL    LispLocatorSetFilter = 0
	LISP_LOCATOR_SET_FILTER_API_LOCAL  LispLocatorSetFilter = 1
	LISP_LOCATOR_SET_FILTER_API_REMOTE LispLocatorSetFilter = 2
)

var (
	LispLocatorSetFilter_name = map[uint8]string{
		0: "LISP_LOCATOR_SET_FILTER_API_ALL",
		1: "LISP_LOCATOR_SET_FILTER_API_LOCAL",
		2: "LISP_LOCATOR_SET_FILTER_API_REMOTE",
	}
	LispLocatorSetFilter_value = map[string]uint8{
		"LISP_LOCATOR_SET_FILTER_API_ALL":    0,
		"LISP_LOCATOR_SET_FILTER_API_LOCAL":  1,
		"LISP_LOCATOR_SET_FILTER_API_REMOTE": 2,
	}
)

func (x LispLocatorSetFilter) String() string {
	s, ok := LispLocatorSetFilter_name[uint8(x)]
	if ok {
		return s
	}
	return "LispLocatorSetFilter(" + strconv.Itoa(int(x)) + ")"
}

// LispAdjacency defines type 'lisp_adjacency'.
type LispAdjacency struct {
	Reid lisp_types.Eid `binapi:"eid,name=reid" json:"reid,omitempty"`
	Leid lisp_types.Eid `binapi:"eid,name=leid" json:"leid,omitempty"`
}

// add or delete LISP adjacency adjacency
//   - is_add - add address if non-zero, else delete
//   - vni - virtual network instance
//   - reid - remote EID
//   - leid - local EID
//
// LispAddDelAdjacency defines message 'lisp_add_del_adjacency'.
type LispAddDelAdjacency struct {
	IsAdd bool           `binapi:"bool,name=is_add,default=true" json:"is_add,omitempty"`
	Vni   uint32         `binapi:"u32,name=vni" json:"vni,omitempty"`
	Reid  lisp_types.Eid `binapi:"eid,name=reid" json:"reid,omitempty"`
	Leid  lisp_types.Eid `binapi:"eid,name=leid" json:"leid,omitempty"`
}

func (m *LispAddDelAdjacency) Reset()               { *m = LispAddDelAdjacency{} }
func (*LispAddDelAdjacency) GetMessageName() string { return "lisp_add_del_adjacency" }
func (*LispAddDelAdjacency) GetCrcString() string   { return "2ce0e6f6" }
func (*LispAddDelAdjacency) GetMessageType() api.MessageType {
	return api.RequestMessage
}

func (m *LispAddDelAdjacency) Size() (size int) {
	if m == nil {
		return 0
	}
	size += 1      // m.IsAdd
	size += 4      // m.Vni
	size += 1      // m.Reid.Type
	size += 1 * 18 // m.Reid.Address
	size += 1      // m.Leid.Type
	size += 1 * 18 // m.Leid.Address
	return size
}
func (m *LispAddDelAdjacency) Marshal(b []byte) ([]byte, error) {
	if b == nil {
		b = make([]byte, m.Size())
	}
	buf := codec.NewBuffer(b)
	buf.EncodeBool(m.IsAdd)
	buf.EncodeUint32(m.Vni)
	buf.EncodeUint8(uint8(m.Reid.Type))
	buf.EncodeBytes(m.Reid.Address.XXX_UnionData[:], 18)
	buf.EncodeUint8(uint8(m.Leid.Type))
	buf.EncodeBytes(m.Leid.Address.XXX_UnionData[:], 18)
	return buf.Bytes(), nil
}
func (m *LispAddDelAdjacency) Unmarshal(b []byte) error {
	buf := codec.NewBuffer(b)
	m.IsAdd = buf.DecodeBool()
	m.Vni = buf.DecodeUint32()
	m.Reid.Type = lisp_types.EidType(buf.DecodeUint8())
	copy(m.Reid.Address.XXX_UnionData[:], buf.DecodeBytes(18))
	m.Leid.Type = lisp_types.EidType(buf.DecodeUint8())
	copy(m.Leid.Address.XXX_UnionData[:], buf.DecodeBytes(18))
	return nil
}

// LispAddDelAdjacencyReply defines message 'lisp_add_del_adjacency_reply'.
type LispAddDelAdjacencyReply struct {
	Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
}

func (m *LispAddDelAdjacencyReply) Reset()               { *m = LispAddDelAdjacencyReply{} }
func (*LispAddDelAdjacencyReply) GetMessageName() string { return "lisp_add_del_adjacency_reply" }
func (*LispAddDelAdjacencyReply) GetCrcString() string   { return "e8d4e804" }
func (*LispAddDelAdjacencyReply) GetMessageType() api.MessageType {
	return api.ReplyMessage
}

func (m *LispAddDelAdjacencyReply) Size() (size int) {
	if m == nil {
		return 0
	}
	size += 4 // m.Retval
	return size
}
func (m *LispAddDelAdjacencyReply) Marshal(b []byte) ([]byte, error) {
	if b == nil {
		b = make([]byte, m.Size())
	}
	buf := codec.NewBuffer(b)
	buf.EncodeInt32(m.Retval)
	return buf.Bytes(), nil
}
func (m *LispAddDelAdjacencyReply) Unmarshal(b []byte) error {
	buf := codec.NewBuffer(b)
	m.Retval = buf.DecodeInt32()
	return nil
}

// add or delete lisp eid-table
//   - is_add - add address if non-zero, else delete
//   - eid - endpoint identifier
//   - locator_set_name - name of locator_set to add/del eid-table
//   - vni - virtual network instance
//   - key - secret key
//
// LispAddDelLocalEid defines message 'lisp_add_del_local_eid'.
type LispAddDelLocalEid struct {
	IsAdd          bool               `binapi:"bool,name=is_add,default=true" json:"is_add,omitempty"`
	Eid            lisp_types.Eid     `binapi:"eid,name=eid" json:"eid,omitempty"`
	LocatorSetName string             `binapi:"string[64],name=locator_set_name" json:"locator_set_name,omitempty"`
	Vni            uint32             `binapi:"u32,name=vni" json:"vni,omitempty"`
	Key            lisp_types.HmacKey `binapi:"hmac_key,name=key" json:"key,omitempty"`
}

func (m *LispAddDelLocalEid) Reset()               { *m = LispAddDelLocalEid{} }
func (*LispAddDelLocalEid) GetMessageName() string { return "lisp_add_del_local_eid" }
func (*LispAddDelLocalEid) GetCrcString() string   { return "4e5a83a2" }
func (*LispAddDelLocalEid) GetMessageType() api.MessageType {
	return api.RequestMessage
}

func (m *LispAddDelLocalEid) Size() (size int) {
	if m == nil {
		return 0
	}
	size += 1      // m.IsAdd
	size += 1      // m.Eid.Type
	size += 1 * 18 // m.Eid.Address
	size += 64     // m.LocatorSetName
	size += 4      // m.Vni
	size += 1      // m.Key.ID
	size += 1 * 64 // m.Key.Key
	return size
}
func (m *LispAddDelLocalEid) Marshal(b []byte) ([]byte, error) {
	if b == nil {
		b = make([]byte, m.Size())
	}
	buf := codec.NewBuffer(b)
	buf.EncodeBool(m.IsAdd)
	buf.EncodeUint8(uint8(m.Eid.Type))
	buf.EncodeBytes(m.Eid.Address.XXX_UnionData[:], 18)
	buf.EncodeString(m.LocatorSetName, 64)
	buf.EncodeUint32(m.Vni)
	buf.EncodeUint8(uint8(m.Key.ID))
	buf.EncodeBytes(m.Key.Key, 64)
	return buf.Bytes(), nil
}
func (m *LispAddDelLocalEid) Unmarshal(b []byte) error {
	buf := codec.NewBuffer(b)
	m.IsAdd = buf.DecodeBool()
	m.Eid.Type = lisp_types.EidType(buf.DecodeUint8())
	copy(m.Eid.Address.XXX_UnionData[:], buf.DecodeBytes(18))
	m.LocatorSetName = buf.DecodeString(64)
	m.Vni = buf.DecodeUint32()
	m.Key.ID = lisp_types.HmacKeyID(buf.DecodeUint8())
	m.Key.Key = make([]byte, 64)
	copy(m.Key.Key, buf.DecodeBytes(len(m.Key.Key)))
	return nil
}

// LispAddDelLocalEidReply defines message 'lisp_add_del_local_eid_reply'.
type LispAddDelLocalEidReply struct {
	Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
}

func (m *LispAddDelLocalEidReply) Reset()               { *m = LispAddDelLocalEidReply{} }
func (*LispAddDelLocalEidReply) GetMessageName() string { return "lisp_add_del_local_eid_reply" }
func (*LispAddDelLocalEidReply) GetCrcString() string   { return "e8d4e804" }
func (*LispAddDelLocalEidReply) GetMessageType() api.MessageType {
	return api.ReplyMessage
}

func (m *LispAddDelLocalEidReply) Size() (size int) {
	if m == nil {
		return 0
	}
	size += 4 // m.Retval
	return size
}
func (m *LispAddDelLocalEidReply) Marshal(b []byte) ([]byte, error) {
	if b == nil {
		b = make([]byte, m.Size())
	}
	buf := codec.NewBuffer(b)
	buf.EncodeInt32(m.Retval)
	return buf.Bytes(), nil
}
func (m *LispAddDelLocalEidReply) Unmarshal(b []byte) error {
	buf := codec.NewBuffer(b)
	m.Retval = buf.DecodeInt32()
	return nil
}

// add or delete locator for locator_set
//   - is_add - add address if non-zero, else delete
//   - locator_set_name - name of locator_set to add/del locator
//   - sw_if_index - index of the interface
//   - priority - priority of the lisp locator
//   - weight - weight of the lisp locator
//
// LispAddDelLocator defines message 'lisp_add_del_locator'.
type LispAddDelLocator struct {
	IsAdd          bool                           `binapi:"bool,name=is_add,default=true" json:"is_add,omitempty"`
	LocatorSetName string                         `binapi:"string[64],name=locator_set_name" json:"locator_set_name,omitempty"`
	SwIfIndex      interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
	Priority       uint8                          `binapi:"u8,name=priority" json:"priority,omitempty"`
	Weight         uint8                          `binapi:"u8,name=weight" json:"weight,omitempty"`
}

func (m *LispAddDelLocator) Reset()               { *m = LispAddDelLocator{} }
func (*LispAddDelLocator) GetMessageName() string { return "lisp_add_del_locator" }
func (*LispAddDelLocator) GetCrcString() string   { return "af4d8f13" }
func (*LispAddDelLocator) GetMessageType() api.MessageType {
	return api.RequestMessage
}

func (m *LispAddDelLocator) Size() (size int) {
	if m == nil {
		return 0
	}
	size += 1  // m.IsAdd
	size += 64 // m.LocatorSetName
	size += 4  // m.SwIfIndex
	size += 1  // m.Priority
	size += 1  // m.Weight
	return size
}
func (m *LispAddDelLocator) Marshal(b []byte) ([]byte, error) {
	if b == nil {
		b = make([]byte, m.Size())
	}
	buf := codec.NewBuffer(b)
	buf.EncodeBool(m.IsAdd)
	buf.EncodeString(m.LocatorSetName, 64)
	buf.EncodeUint32(uint32(m.SwIfIndex))
	buf.EncodeUint8(m.Priority)
	buf.EncodeUint8(m.Weight)
	return buf.Bytes(), nil
}
func (m *LispAddDelLocator) Unmarshal(b []byte) error {
	buf := codec.NewBuffer(b)
	m.IsAdd = buf.DecodeBool()
	m.LocatorSetName = buf.DecodeString(64)
	m.SwIfIndex = interface_types.InterfaceIndex(buf.DecodeUint32())
	m.Priority = buf.DecodeUint8()
	m.Weight = buf.DecodeUint8()
	return nil
}

// LispAddDelLocatorReply defines message 'lisp_add_del_locator_reply'.
type LispAddDelLocatorReply struct {
	Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
}

func (m *LispAddDelLocatorReply) Reset()               { *m = LispAddDelLocatorReply{} }
func (*LispAddDelLocatorReply) GetMessageName() string { return "lisp_add_del_locator_reply" }
func (*LispAddDelLocatorReply) GetCrcString() string   { return "e8d4e804" }
func (*LispAddDelLocatorReply) GetMessageType() api.MessageType {
	return api.ReplyMessage
}

func (m *LispAddDelLocatorReply) Size() (size int) {
	if m == nil {
		return 0
	}
	size += 4 // m.Retval
	return size
}
func (m *LispAddDelLocatorReply) Marshal(b []byte) ([]byte, error) {
	if b == nil {
		b = make([]byte, m.Size())
	}
	buf := codec.NewBuffer(b)
	buf.EncodeInt32(m.Retval)
	return buf.Bytes(), nil
}
func (m *LispAddDelLocatorReply) Unmarshal(b []byte) error {
	buf := codec.NewBuffer(b)
	m.Retval = buf.DecodeInt32()
	return nil
}

// add or delete locator_set
//   - is_add - add address if non-zero, else delete
//   - locator_set_name - locator name
//   - locator_num - number of locators
//   - locators - LISP locator records
//
// LispAddDelLocatorSet defines message 'lisp_add_del_locator_set'.
type LispAddDelLocatorSet struct {
	IsAdd          bool                      `binapi:"bool,name=is_add,default=true" json:"is_add,omitempty"`
	LocatorSetName string                    `binapi:"string[64],name=locator_set_name" json:"locator_set_name,omitempty"`
	LocatorNum     uint32                    `binapi:"u32,name=locator_num" json:"-"`
	Locators       []lisp_types.LocalLocator `binapi:"local_locator[locator_num],name=locators" json:"locators,omitempty"`
}

func (m *LispAddDelLocatorSet) Reset()               { *m = LispAddDelLocatorSet{} }
func (*LispAddDelLocatorSet) GetMessageName() string { return "lisp_add_del_locator_set" }
func (*LispAddDelLocatorSet) GetCrcString() string   { return "6fcd6471" }
func (*LispAddDelLocatorSet) GetMessageType() api.MessageType {
	return api.RequestMessage
}

func (m *LispAddDelLocatorSet) Size() (size int) {
	if m == nil {
		return 0
	}
	size += 1  // m.IsAdd
	size += 64 // m.LocatorSetName
	size += 4  // m.LocatorNum
	for j1 := 0; j1 < len(m.Locators); j1++ {
		var s1 lisp_types.LocalLocator
		_ = s1
		if j1 < len(m.Locators) {
			s1 = m.Locators[j1]
		}
		size += 4 // s1.SwIfIndex
		size += 1 // s1.Priority
		size += 1 // s1.Weight
	}
	return size
}
func (m *LispAddDelLocatorSet) Marshal(b []byte) ([]byte, error) {
	if b == nil {
		b = make([]byte, m.Size())
	}
	buf := codec.NewBuffer(b)
	buf.EncodeBool(m.IsAdd)
	buf.EncodeString(m.LocatorSetName, 64)
	buf.EncodeUint32(uint32(len(m.Locators)))
	for j0 := 0; j0 < len(m.Locators); j0++ {
		var v0 lisp_types.LocalLocator // Locators
		if j0 < len(m.Locators) {
			v0 = m.Locators[j0]
		}
		buf.EncodeUint32(uint32(v0.SwIfIndex))
		buf.EncodeUint8(v0.Priority)
		buf.EncodeUint8(v0.Weight)
	}
	return buf.Bytes(), nil
}
func (m *LispAddDelLocatorSet) Unmarshal(b []byte) error {
	buf := codec.NewBuffer(b)
	m.IsAdd = buf.DecodeBool()
	m.LocatorSetName = buf.DecodeString(64)
	m.LocatorNum = buf.DecodeUint32()
	m.Locators = make([]lisp_types.LocalLocator, m.LocatorNum)
	for j0 := 0; j0 < len(m.Locators); j0++ {
		m.Locators[j0].SwIfIndex = interface_types.InterfaceIndex(buf.DecodeUint32())
		m.Locators[j0].Priority = buf.DecodeUint8()
		m.Locators[j0].Weight = buf.DecodeUint8()
	}
	return nil
}

// Reply for locator_set add/del
//   - retval - return code
//   - ls_index - locator set index
//
// LispAddDelLocatorSetReply defines message 'lisp_add_del_locator_set_reply'.
type LispAddDelLocatorSetReply struct {
	Retval  int32  `binapi:"i32,name=retval" json:"retval,omitempty"`
	LsIndex uint32 `binapi:"u32,name=ls_index" json:"ls_index,omitempty"`
}

func (m *LispAddDelLocatorSetReply) Reset()               { *m = LispAddDelLocatorSetReply{} }
func (*LispAddDelLocatorSetReply) GetMessageName() string { return "lisp_add_del_locator_set_reply" }
func (*LispAddDelLocatorSetReply) GetCrcString() string   { return "b6666db4" }
func (*LispAddDelLocatorSetReply) GetMessageType() api.MessageType {
	return api.ReplyMessage
}

func (m *LispAddDelLocatorSetReply) Size() (size int) {
	if m == nil {
		return 0
	}
	size += 4 // m.Retval
	size += 4 // m.LsIndex
	return size
}
func (m *LispAddDelLocatorSetReply) Marshal(b []byte) ([]byte, error) {
	if b == nil {
		b = make([]byte, m.Size())
	}
	buf := codec.NewBuffer(b)
	buf.EncodeInt32(m.Retval)
	buf.EncodeUint32(m.LsIndex)
	return buf.Bytes(), nil
}
func (m *LispAddDelLocatorSetReply) Unmarshal(b []byte) error {
	buf := codec.NewBuffer(b)
	m.Retval = buf.DecodeInt32()
	m.LsIndex = buf.DecodeUint32()
	return nil
}

// add or delete map request itr rlocs
//   - is_add - add address if non-zero, else delete
//   - locator_set_name - locator set name
//
// LispAddDelMapRequestItrRlocs defines message 'lisp_add_del_map_request_itr_rlocs'.
type LispAddDelMapRequestItrRlocs struct {
	IsAdd          bool   `binapi:"bool,name=is_add,default=true" json:"is_add,omitempty"`
	LocatorSetName string `binapi:"string[64],name=locator_set_name" json:"locator_set_name,omitempty"`
}

func (m *LispAddDelMapRequestItrRlocs) Reset() { *m = LispAddDelMapRequestItrRlocs{} }
func (*LispAddDelMapRequestItrRlocs) GetMessageName() string {
	return "lisp_add_del_map_request_itr_rlocs"
}
func (*LispAddDelMapRequestItrRlocs) GetCrcString() string { return "6be88e45" }
func (*LispAddDelMapRequestItrRlocs) GetMessageType() api.MessageType {
	return api.RequestMessage
}

func (m *LispAddDelMapRequestItrRlocs) Size() (size int) {
	if m == nil {
		return 0
	}
	size += 1  // m.IsAdd
	size += 64 // m.LocatorSetName
	return size
}
func (m *LispAddDelMapRequestItrRlocs) Marshal(b []byte) ([]byte, error) {
	if b == nil {
		b = make([]byte, m.Size())
	}
	buf := codec.NewBuffer(b)
	buf.EncodeBool(m.IsAdd)
	buf.EncodeString(m.LocatorSetName, 64)
	return buf.Bytes(), nil
}
func (m *LispAddDelMapRequestItrRlocs) Unmarshal(b []byte) error {
	buf := codec.NewBuffer(b)
	m.IsAdd = buf.DecodeBool()
	m.LocatorSetName = buf.DecodeString(64)
	return nil
}

// LispAddDelMapRequestItrRlocsReply defines message 'lisp_add_del_map_request_itr_rlocs_reply'.
type LispAddDelMapRequestItrRlocsReply struct {
	Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
}

func (m *LispAddDelMapRequestItrRlocsReply) Reset() { *m = LispAddDelMapRequestItrRlocsReply{} }
func (*LispAddDelMapRequestItrRlocsReply) GetMessageName() string {
	return "lisp_add_del_map_request_itr_rlocs_reply"
}
func (*LispAddDelMapRequestItrRlocsReply) GetCrcString() string { return "e8d4e804" }
func (*LispAddDelMapRequestItrRlocsReply) GetMessageType() api.MessageType {
	return api.ReplyMessage
}

func (m *LispAddDelMapRequestItrRlocsReply) Size() (size int) {
	if m == nil {
		return 0
	}
	size += 4 // m.Retval
	return size
}
func (m *LispAddDelMapRequestItrRlocsReply) Marshal(b []byte) ([]byte, error) {
	if b == nil {
		b = make([]byte, m.Size())
	}
	buf := codec.NewBuffer(b)
	buf.EncodeInt32(m.Retval)
	return buf.Bytes(), nil
}
func (m *LispAddDelMapRequestItrRlocsReply) Unmarshal(b []byte) error {
	buf := codec.NewBuffer(b)
	m.Retval = buf.DecodeInt32()
	return nil
}

// add or delete map-resolver
//   - is_add - add address if non-zero, else delete
//   - ip_address - ip address
//
// LispAddDelMapResolver defines message 'lisp_add_del_map_resolver'.
type LispAddDelMapResolver struct {
	IsAdd     bool             `binapi:"bool,name=is_add,default=true" json:"is_add,omitempty"`
	IPAddress ip_types.Address `binapi:"address,name=ip_address" json:"ip_address,omitempty"`
}

func (m *LispAddDelMapResolver) Reset()               { *m = LispAddDelMapResolver{} }
func (*LispAddDelMapResolver) GetMessageName() string { return "lisp_add_del_map_resolver" }
func (*LispAddDelMapResolver) GetCrcString() string   { return "ce19e32d" }
func (*LispAddDelMapResolver) GetMessageType() api.MessageType {
	return api.RequestMessage
}

func (m *LispAddDelMapResolver) Size() (size int) {
	if m == nil {
		return 0
	}
	size += 1      // m.IsAdd
	size += 1      // m.IPAddress.Af
	size += 1 * 16 // m.IPAddress.Un
	return size
}
func (m *LispAddDelMapResolver) Marshal(b []byte) ([]byte, error) {
	if b == nil {
		b = make([]byte, m.Size())
	}
	buf := codec.NewBuffer(b)
	buf.EncodeBool(m.IsAdd)
	buf.EncodeUint8(uint8(m.IPAddress.Af))
	buf.EncodeBytes(m.IPAddress.Un.XXX_UnionData[:], 16)
	return buf.Bytes(), nil
}
func (m *LispAddDelMapResolver) Unmarshal(b []byte) error {
	buf := codec.NewBuffer(b)
	m.IsAdd = buf.DecodeBool()
	m.IPAddress.Af = ip_types.AddressFamily(buf.DecodeUint8())
	copy(m.IPAddress.Un.XXX_UnionData[:], buf.DecodeBytes(16))
	return nil
}

// LispAddDelMapResolverReply defines message 'lisp_add_del_map_resolver_reply'.
type LispAddDelMapResolverReply struct {
	Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
}

func (m *LispAddDelMapResolverReply) Reset()               { *m = LispAddDelMapResolverReply{} }
func (*LispAddDelMapResolverReply) GetMessageName() string { return "lisp_add_del_map_resolver_reply" }
func (*LispAddDelMapResolverReply) GetCrcString() string   { return "e8d4e804" }
func (*LispAddDelMapResolverReply) GetMessageType() api.MessageType {
	return api.ReplyMessage
}

func (m *LispAddDelMapResolverReply) Size() (size int) {
	if m == nil {
		return 0
	}
	size += 4 // m.Retval
	return size
}
func (m *LispAddDelMapResolverReply) Marshal(b []byte) ([]byte, error) {
	if b == nil {
		b = make([]byte, m.Size())
	}
	buf := codec.NewBuffer(b)
	buf.EncodeInt32(m.Retval)
	return buf.Bytes(), nil
}
func (m *LispAddDelMapResolverReply) Unmarshal(b []byte) error {
	buf := codec.NewBuffer(b)
	m.Retval = buf.DecodeInt32()
	return nil
}

// Add/delete map server
//   - is_add - add address if non-zero; delete otherwise
//   - ip_address - map server IP address
//
// LispAddDelMapServer defines message 'lisp_add_del_map_server'.
type LispAddDelMapServer struct {
	IsAdd     bool             `binapi:"bool,name=is_add,default=true" json:"is_add,omitempty"`
	IPAddress ip_types.Address `binapi:"address,name=ip_address" json:"ip_address,omitempty"`
}

func (m *LispAddDelMapServer) Reset()               { *m = LispAddDelMapServer{} }
func (*LispAddDelMapServer) GetMessageName() string { return "lisp_add_del_map_server" }
func (*LispAddDelMapServer) GetCrcString() string   { return "ce19e32d" }
func (*LispAddDelMapServer) GetMessageType() api.MessageType {
	return api.RequestMessage
}

func (m *LispAddDelMapServer) Size() (size int) {
	if m == nil {
		return 0
	}
	size += 1      // m.IsAdd
	size += 1      // m.IPAddress.Af
	size += 1 * 16 // m.IPAddress.Un
	return size
}
func (m *LispAddDelMapServer) Marshal(b []byte) ([]byte, error) {
	if b == nil {
		b = make([]byte, m.Size())
	}
	buf := codec.NewBuffer(b)
	buf.EncodeBool(m.IsAdd)
	buf.EncodeUint8(uint8(m.IPAddress.Af))
	buf.EncodeBytes(m.IPAddress.Un.XXX_UnionData[:], 16)
	return buf.Bytes(), nil
}
func (m *LispAddDelMapServer) Unmarshal(b []byte) error {
	buf := codec.NewBuffer(b)
	m.IsAdd = buf.DecodeBool()
	m.IPAddress.Af = ip_types.AddressFamily(buf.DecodeUint8())
	copy(m.IPAddress.Un.XXX_UnionData[:], buf.DecodeBytes(16))
	return nil
}

// LispAddDelMapServerReply defines message 'lisp_add_del_map_server_reply'.
type LispAddDelMapServerReply struct {
	Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
}

func (m *LispAddDelMapServerReply) Reset()               { *m = LispAddDelMapServerReply{} }
func (*LispAddDelMapServerReply) GetMessageName() string { return "lisp_add_del_map_server_reply" }
func (*LispAddDelMapServerReply) GetCrcString() string   { return "e8d4e804" }
func (*LispAddDelMapServerReply) GetMessageType() api.MessageType {
	return api.ReplyMessage
}

func (m *LispAddDelMapServerReply) Size() (size int) {
	if m == nil {
		return 0
	}
	size += 4 // m.Retval
	return size
}
func (m *LispAddDelMapServerReply) Marshal(b []byte) ([]byte, error) {
	if b == nil {
		b = make([]byte, m.Size())
	}
	buf := codec.NewBuffer(b)
	buf.EncodeInt32(m.Retval)
	return buf.Bytes(), nil
}
func (m *LispAddDelMapServerReply) Unmarshal(b []byte) error {
	buf := codec.NewBuffer(b)
	m.Retval = buf.DecodeInt32()
	return nil
}

// add or delete remote static mapping
//   - is_add - add address if non-zero, else delete
//   - is_src_dst - flag indicating src/dst based routing policy
//   - del_all - if set, delete all remote mappings
//   - vni - virtual network instance
//   - action - negative map-reply action
//   - deid - dst EID
//   - seid - src EID, valid only if is_src_dst is enabled
//   - rloc_num - number of remote locators
//   - rlocs - remote locator records
//
// LispAddDelRemoteMapping defines message 'lisp_add_del_remote_mapping'.
type LispAddDelRemoteMapping struct {
	IsAdd    bool                       `binapi:"bool,name=is_add,default=true" json:"is_add,omitempty"`
	IsSrcDst bool                       `binapi:"bool,name=is_src_dst" json:"is_src_dst,omitempty"`
	DelAll   bool                       `binapi:"bool,name=del_all" json:"del_all,omitempty"`
	Vni      uint32                     `binapi:"u32,name=vni" json:"vni,omitempty"`
	Action   uint8                      `binapi:"u8,name=action" json:"action,omitempty"`
	Deid     lisp_types.Eid             `binapi:"eid,name=deid" json:"deid,omitempty"`
	Seid     lisp_types.Eid             `binapi:"eid,name=seid" json:"seid,omitempty"`
	RlocNum  uint32                     `binapi:"u32,name=rloc_num" json:"-"`
	Rlocs    []lisp_types.RemoteLocator `binapi:"remote_locator[rloc_num],name=rlocs" json:"rlocs,omitempty"`
}

func (m *LispAddDelRemoteMapping) Reset()               { *m = LispAddDelRemoteMapping{} }
func (*LispAddDelRemoteMapping) GetMessageName() string { return "lisp_add_del_remote_mapping" }
func (*LispAddDelRemoteMapping) GetCrcString() string   { return "6d5c789e" }
func (*LispAddDelRemoteMapping) GetMessageType() api.MessageType {
	return api.RequestMessage
}

func (m *LispAddDelRemoteMapping) Size() (size int) {
	if m == nil {
		return 0
	}
	size += 1      // m.IsAdd
	size += 1      // m.IsSrcDst
	size += 1      // m.DelAll
	size += 4      // m.Vni
	size += 1      // m.Action
	size += 1      // m.Deid.Type
	size += 1 * 18 // m.Deid.Address
	size += 1      // m.Seid.Type
	size += 1 * 18 // m.Seid.Address
	size += 4      // m.RlocNum
	for j1 := 0; j1 < len(m.Rlocs); j1++ {
		var s1 lisp_types.RemoteLocator
		_ = s1
		if j1 < len(m.Rlocs) {
			s1 = m.Rlocs[j1]
		}
		size += 1      // s1.Priority
		size += 1      // s1.Weight
		size += 1      // s1.IPAddress.Af
		size += 1 * 16 // s1.IPAddress.Un
	}
	return size
}
func (m *LispAddDelRemoteMapping) Marshal(b []byte) ([]byte, error) {
	if b == nil {
		b = make([]byte, m.Size())
	}
	buf := codec.NewBuffer(b)
	buf.EncodeBool(m.IsAdd)
	buf.EncodeBool(m.IsSrcDst)
	buf.EncodeBool(m.DelAll)
	buf.EncodeUint32(m.Vni)
	buf.EncodeUint8(m.Action)
	buf.EncodeUint8(uint8(m.Deid.Type))
	buf.EncodeBytes(m.Deid.Address.XXX_UnionData[:], 18)
	buf.EncodeUint8(uint8(m.Seid.Type))
	buf.EncodeBytes(m.Seid.Address.XXX_UnionData[:], 18)
	buf.EncodeUint32(uint32(len(m.Rlocs)))
	for j0 := 0; j0 < len(m.Rlocs); j0++ {
		var v0 lisp_types.RemoteLocator // Rlocs
		if j0 < len(m.Rlocs) {
			v0 = m.Rlocs[j0]
		}
		buf.EncodeUint8(v0.Priority)
		buf.EncodeUint8(v0.Weight)
		buf.EncodeUint8(uint8(v0.IPAddress.Af))
		buf.EncodeBytes(v0.IPAddress.Un.XXX_UnionData[:], 16)
	}
	return buf.Bytes(), nil
}
func (m *LispAddDelRemoteMapping) Unmarshal(b []byte) error {
	buf := codec.NewBuffer(b)
	m.IsAdd = buf.DecodeBool()
	m.IsSrcDst = buf.DecodeBool()
	m.DelAll = buf.DecodeBool()
	m.Vni = buf.DecodeUint32()
	m.Action = buf.DecodeUint8()
	m.Deid.Type = lisp_types.EidType(buf.DecodeUint8())
	copy(m.Deid.Address.XXX_UnionData[:], buf.DecodeBytes(18))
	m.Seid.Type = lisp_types.EidType(buf.DecodeUint8())
	copy(m.Seid.Address.XXX_UnionData[:], buf.DecodeBytes(18))
	m.RlocNum = buf.DecodeUint32()
	m.Rlocs = make([]lisp_types.RemoteLocator, m.RlocNum)
	for j0 := 0; j0 < len(m.Rlocs); j0++ {
		m.Rlocs[j0].Priority = buf.DecodeUint8()
		m.Rlocs[j0].Weight = buf.DecodeUint8()
		m.Rlocs[j0].IPAddress.Af = ip_types.AddressFamily(buf.DecodeUint8())
		copy(m.Rlocs[j0].IPAddress.Un.XXX_UnionData[:], buf.DecodeBytes(16))
	}
	return nil
}

// LispAddDelRemoteMappingReply defines message 'lisp_add_del_remote_mapping_reply'.
type LispAddDelRemoteMappingReply struct {
	Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
}

func (m *LispAddDelRemoteMappingReply) Reset() { *m = LispAddDelRemoteMappingReply{} }
func (*LispAddDelRemoteMappingReply) GetMessageName() string {
	return "lisp_add_del_remote_mapping_reply"
}
func (*LispAddDelRemoteMappingReply) GetCrcString() string { return "e8d4e804" }
func (*LispAddDelRemoteMappingReply) GetMessageType() api.MessageType {
	return api.ReplyMessage
}

func (m *LispAddDelRemoteMappingReply) Size() (size int) {
	if m == nil {
		return 0
	}
	size += 4 // m.Retval
	return size
}
func (m *LispAddDelRemoteMappingReply) Marshal(b []byte) ([]byte, error) {
	if b == nil {
		b = make([]byte, m.Size())
	}
	buf := codec.NewBuffer(b)
	buf.EncodeInt32(m.Retval)
	return buf.Bytes(), nil
}
func (m *LispAddDelRemoteMappingReply) Unmarshal(b []byte) error {
	buf := codec.NewBuffer(b)
	m.Retval = buf.DecodeInt32()
	return nil
}

// Request for LISP adjacencies
//   - vni - filter adjacencies by VNI
//
// LispAdjacenciesGet defines message 'lisp_adjacencies_get'.
type LispAdjacenciesGet struct {
	Vni uint32 `binapi:"u32,name=vni" json:"vni,omitempty"`
}

func (m *LispAdjacenciesGet) Reset()               { *m = LispAdjacenciesGet{} }
func (*LispAdjacenciesGet) GetMessageName() string { return "lisp_adjacencies_get" }
func (*LispAdjacenciesGet) GetCrcString() string   { return "8d1f2fe9" }
func (*LispAdjacenciesGet) GetMessageType() api.MessageType {
	return api.RequestMessage
}

func (m *LispAdjacenciesGet) Size() (size int) {
	if m == nil {
		return 0
	}
	size += 4 // m.Vni
	return size
}
func (m *LispAdjacenciesGet) Marshal(b []byte) ([]byte, error) {
	if b == nil {
		b = make([]byte, m.Size())
	}
	buf := codec.NewBuffer(b)
	buf.EncodeUint32(m.Vni)
	return buf.Bytes(), nil
}
func (m *LispAdjacenciesGet) Unmarshal(b []byte) error {
	buf := codec.NewBuffer(b)
	m.Vni = buf.DecodeUint32()
	return nil
}

// LISP adjacency reply
//   - count - number of adjacencies
//   - adjacencies - array of adjacencies
//
// LispAdjacenciesGetReply defines message 'lisp_adjacencies_get_reply'.
type LispAdjacenciesGetReply struct {
	Retval      int32           `binapi:"i32,name=retval" json:"retval,omitempty"`
	Count       uint32          `binapi:"u32,name=count" json:"-"`
	Adjacencies []LispAdjacency `binapi:"lisp_adjacency[count],name=adjacencies" json:"adjacencies,omitempty"`
}

func (m *LispAdjacenciesGetReply) Reset()               { *m = LispAdjacenciesGetReply{} }
func (*LispAdjacenciesGetReply) GetMessageName() string { return "lisp_adjacencies_get_reply" }
func (*LispAdjacenciesGetReply) GetCrcString() string   { return "807257bf" }
func (*LispAdjacenciesGetReply) GetMessageType() api.MessageType {
	return api.ReplyMessage
}

func (m *LispAdjacenciesGetReply) Size() (size int) {
	if m == nil {
		return 0
	}
	size += 4 // m.Retval
	size += 4 // m.Count
	for j1 := 0; j1 < len(m.Adjacencies); j1++ {
		var s1 LispAdjacency
		_ = s1
		if j1 < len(m.Adjacencies) {
			s1 = m.Adjacencies[j1]
		}
		size += 1      // s1.Reid.Type
		size += 1 * 18 // s1.Reid.Address
		size += 1      // s1.Leid.Type
		size += 1 * 18 // s1.Leid.Address
	}
	return size
}
func (m *LispAdjacenciesGetReply) Marshal(b []byte) ([]byte, error) {
	if b == nil {
		b = make([]byte, m.Size())
	}
	buf := codec.NewBuffer(b)
	buf.EncodeInt32(m.Retval)
	buf.EncodeUint32(uint32(len(m.Adjacencies)))
	for j0 := 0; j0 < len(m.Adjacencies); j0++ {
		var v0 LispAdjacency // Adjacencies
		if j0 < len(m.Adjacencies) {
			v0 = m.Adjacencies[j0]
		}
		buf.EncodeUint8(uint8(v0.Reid.Type))
		buf.EncodeBytes(v0.Reid.Address.XXX_UnionData[:], 18)
		buf.EncodeUint8(uint8(v0.Leid.Type))
		buf.EncodeBytes(v0.Leid.Address.XXX_UnionData[:], 18)
	}
	return buf.Bytes(), nil
}
func (m *LispAdjacenciesGetReply) Unmarshal(b []byte) error {
	buf := codec.NewBuffer(b)
	m.Retval = buf.DecodeInt32()
	m.Count = buf.DecodeUint32()
	m.Adjacencies = make([]LispAdjacency, m.Count)
	for j0 := 0; j0 < len(m.Adjacencies); j0++ {
		m.Adjacencies[j0].Reid.Type = lisp_types.EidType(buf.DecodeUint8())
		copy(m.Adjacencies[j0].Reid.Address.XXX_UnionData[:], buf.DecodeBytes(18))
		m.Adjacencies[j0].Leid.Type = lisp_types.EidType(buf.DecodeUint8())
		copy(m.Adjacencies[j0].Leid.Address.XXX_UnionData[:], buf.DecodeBytes(18))
	}
	return nil
}

// map/unmap vni/bd_index to vrf
//   - is_add - add or delete mapping
//   - dp_table - virtual network id/bridge domain index
//   - vrf - vrf
//
// LispEidTableAddDelMap defines message 'lisp_eid_table_add_del_map'.
type LispEidTableAddDelMap struct {
	IsAdd   bool   `binapi:"bool,name=is_add,default=true" json:"is_add,omitempty"`
	Vni     uint32 `binapi:"u32,name=vni" json:"vni,omitempty"`
	DpTable uint32 `binapi:"u32,name=dp_table" json:"dp_table,omitempty"`
	IsL2    bool   `binapi:"bool,name=is_l2" json:"is_l2,omitempty"`
}

func (m *LispEidTableAddDelMap) Reset()               { *m = LispEidTableAddDelMap{} }
func (*LispEidTableAddDelMap) GetMessageName() string { return "lisp_eid_table_add_del_map" }
func (*LispEidTableAddDelMap) GetCrcString() string   { return "9481416b" }
func (*LispEidTableAddDelMap) GetMessageType() api.MessageType {
	return api.RequestMessage
}

func (m *LispEidTableAddDelMap) Size() (size int) {
	if m == nil {
		return 0
	}
	size += 1 // m.IsAdd
	size += 4 // m.Vni
	size += 4 // m.DpTable
	size += 1 // m.IsL2
	return size
}
func (m *LispEidTableAddDelMap) Marshal(b []byte) ([]byte, error) {
	if b == nil {
		b = make([]byte, m.Size())
	}
	buf := codec.NewBuffer(b)
	buf.EncodeBool(m.IsAdd)
	buf.EncodeUint32(m.Vni)
	buf.EncodeUint32(m.DpTable)
	buf.EncodeBool(m.IsL2)
	return buf.Bytes(), nil
}
func (m *LispEidTableAddDelMap) Unmarshal(b []byte) error {
	buf := codec.NewBuffer(b)
	m.IsAdd = buf.DecodeBool()
	m.Vni = buf.DecodeUint32()
	m.DpTable = buf.DecodeUint32()
	m.IsL2 = buf.DecodeBool()
	return nil
}

// LispEidTableAddDelMapReply defines message 'lisp_eid_table_add_del_map_reply'.
type LispEidTableAddDelMapReply struct {
	Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
}

func (m *LispEidTableAddDelMapReply) Reset()               { *m = LispEidTableAddDelMapReply{} }
func (*LispEidTableAddDelMapReply) GetMessageName() string { return "lisp_eid_table_add_del_map_reply" }
func (*LispEidTableAddDelMapReply) GetCrcString() string   { return "e8d4e804" }
func (*LispEidTableAddDelMapReply) GetMessageType() api.MessageType {
	return api.ReplyMessage
}

func (m *LispEidTableAddDelMapReply) Size() (size int) {
	if m == nil {
		return 0
	}
	size += 4 // m.Retval
	return size
}
func (m *LispEidTableAddDelMapReply) Marshal(b []byte) ([]byte, error) {
	if b == nil {
		b = make([]byte, m.Size())
	}
	buf := codec.NewBuffer(b)
	buf.EncodeInt32(m.Retval)
	return buf.Bytes(), nil
}
func (m *LispEidTableAddDelMapReply) Unmarshal(b []byte) error {
	buf := codec.NewBuffer(b)
	m.Retval = buf.DecodeInt32()
	return nil
}

// Dump lisp eid-table
//   - locator_set_index - index of locator_set, if ~0 then the mapping
//     is negative
//   - action - negative map request action
//   - is_local - local if non-zero, else remote
//   - is_src_dst - EID is type of source/destination
//   - deid - dst EID
//   - seid - src EID
//   - vni - virtual network instance
//   - ttl - time to live
//   - authoritative - authoritative
//   - key_id
//     HMAC_NO_KEY           0
//     HMAC_SHA_1_96         1
//     HMAC_SHA_256_128      2
//   - key - secret key
//
// LispEidTableDetails defines message 'lisp_eid_table_details'.
type LispEidTableDetails struct {
	LocatorSetIndex uint32             `binapi:"u32,name=locator_set_index" json:"locator_set_index,omitempty"`
	Action          uint8              `binapi:"u8,name=action" json:"action,omitempty"`
	IsLocal         bool               `binapi:"bool,name=is_local" json:"is_local,omitempty"`
	IsSrcDst        bool               `binapi:"bool,name=is_src_dst" json:"is_src_dst,omitempty"`
	Vni             uint32             `binapi:"u32,name=vni" json:"vni,omitempty"`
	Deid            lisp_types.Eid     `binapi:"eid,name=deid" json:"deid,omitempty"`
	Seid            lisp_types.Eid     `binapi:"eid,name=seid" json:"seid,omitempty"`
	TTL             uint32             `binapi:"u32,name=ttl" json:"ttl,omitempty"`
	Authoritative   uint8              `binapi:"u8,name=authoritative" json:"authoritative,omitempty"`
	Key             lisp_types.HmacKey `binapi:"hmac_key,name=key" json:"key,omitempty"`
}

func (m *LispEidTableDetails) Reset()               { *m = LispEidTableDetails{} }
func (*LispEidTableDetails) GetMessageName() string { return "lisp_eid_table_details" }
func (*LispEidTableDetails) GetCrcString() string   { return "1c29f792" }
func (*LispEidTableDetails) GetMessageType() api.MessageType {
	return api.ReplyMessage
}

func (m *LispEidTableDetails) Size() (size int) {
	if m == nil {
		return 0
	}
	size += 4      // m.LocatorSetIndex
	size += 1      // m.Action
	size += 1      // m.IsLocal
	size += 1      // m.IsSrcDst
	size += 4      // m.Vni
	size += 1      // m.Deid.Type
	size += 1 * 18 // m.Deid.Address
	size += 1      // m.Seid.Type
	size += 1 * 18 // m.Seid.Address
	size += 4      // m.TTL
	size += 1      // m.Authoritative
	size += 1      // m.Key.ID
	size += 1 * 64 // m.Key.Key
	return size
}
func (m *LispEidTableDetails) Marshal(b []byte) ([]byte, error) {
	if b == nil {
		b = make([]byte, m.Size())
	}
	buf := codec.NewBuffer(b)
	buf.EncodeUint32(m.LocatorSetIndex)
	buf.EncodeUint8(m.Action)
	buf.EncodeBool(m.IsLocal)
	buf.EncodeBool(m.IsSrcDst)
	buf.EncodeUint32(m.Vni)
	buf.EncodeUint8(uint8(m.Deid.Type))
	buf.EncodeBytes(m.Deid.Address.XXX_UnionData[:], 18)
	buf.EncodeUint8(uint8(m.Seid.Type))
	buf.EncodeBytes(m.Seid.Address.XXX_UnionData[:], 18)
	buf.EncodeUint32(m.TTL)
	buf.EncodeUint8(m.Authoritative)
	buf.EncodeUint8(uint8(m.Key.ID))
	buf.EncodeBytes(m.Key.Key, 64)
	return buf.Bytes(), nil
}
func (m *LispEidTableDetails) Unmarshal(b []byte) error {
	buf := codec.NewBuffer(b)
	m.LocatorSetIndex = buf.DecodeUint32()
	m.Action = buf.DecodeUint8()
	m.IsLocal = buf.DecodeBool()
	m.IsSrcDst = buf.DecodeBool()
	m.Vni = buf.DecodeUint32()
	m.Deid.Type = lisp_types.EidType(buf.DecodeUint8())
	copy(m.Deid.Address.XXX_UnionData[:], buf.DecodeBytes(18))
	m.Seid.Type = lisp_types.EidType(buf.DecodeUint8())
	copy(m.Seid.Address.XXX_UnionData[:], buf.DecodeBytes(18))
	m.TTL = buf.DecodeUint32()
	m.Authoritative = buf.DecodeUint8()
	m.Key.ID = lisp_types.HmacKeyID(buf.DecodeUint8())
	m.Key.Key = make([]byte, 64)
	copy(m.Key.Key, buf.DecodeBytes(len(m.Key.Key)))
	return nil
}

// Request for eid table summary status
//   - eid_set - if non-zero request info about specific mapping
//   - vni - virtual network instance; valid only if eid_set != 0
//   - prefix_length - prefix length if EID is IP address;
//     valid only if eid_set != 0
//   - eid - endpoint identifier
//   - filter - filter type;
//     Support values:
//     0: all eid
//     1: local eid
//     2: remote eid
//
// LispEidTableDump defines message 'lisp_eid_table_dump'.
type LispEidTableDump struct {
	EidSet       uint8                `binapi:"u8,name=eid_set" json:"eid_set,omitempty"`
	PrefixLength uint8                `binapi:"u8,name=prefix_length" json:"prefix_length,omitempty"`
	Vni          uint32               `binapi:"u32,name=vni" json:"vni,omitempty"`
	Eid          lisp_types.Eid       `binapi:"eid,name=eid" json:"eid,omitempty"`
	Filter       LispLocatorSetFilter `binapi:"lisp_locator_set_filter,name=filter" json:"filter,omitempty"`
}

func (m *LispEidTableDump) Reset()               { *m = LispEidTableDump{} }
func (*LispEidTableDump) GetMessageName() string { return "lisp_eid_table_dump" }
func (*LispEidTableDump) GetCrcString() string   { return "629468b5" }
func (*LispEidTableDump) GetMessageType() api.MessageType {
	return api.RequestMessage
}

func (m *LispEidTableDump) Size() (size int) {
	if m == nil {
		return 0
	}
	size += 1      // m.EidSet
	size += 1      // m.PrefixLength
	size += 4      // m.Vni
	size += 1      // m.Eid.Type
	size += 1 * 18 // m.Eid.Address
	size += 1      // m.Filter
	return size
}
func (m *LispEidTableDump) Marshal(b []byte) ([]byte, error) {
	if b == nil {
		b = make([]byte, m.Size())
	}
	buf := codec.NewBuffer(b)
	buf.EncodeUint8(m.EidSet)
	buf.EncodeUint8(m.PrefixLength)
	buf.EncodeUint32(m.Vni)
	buf.EncodeUint8(uint8(m.Eid.Type))
	buf.EncodeBytes(m.Eid.Address.XXX_UnionData[:], 18)
	buf.EncodeUint8(uint8(m.Filter))
	return buf.Bytes(), nil
}
func (m *LispEidTableDump) Unmarshal(b []byte) error {
	buf := codec.NewBuffer(b)
	m.EidSet = buf.DecodeUint8()
	m.PrefixLength = buf.DecodeUint8()
	m.Vni = buf.DecodeUint32()
	m.Eid.Type = lisp_types.EidType(buf.DecodeUint8())
	copy(m.Eid.Address.XXX_UnionData[:], buf.DecodeBytes(18))
	m.Filter = LispLocatorSetFilter(buf.DecodeUint8())
	return nil
}

// Shows relationship between vni and vrf/bd
//   - dp_table - VRF index or bridge domain index
//   - vni - virtual network instance
//
// LispEidTableMapDetails defines message 'lisp_eid_table_map_details'.
type LispEidTableMapDetails struct {
	Vni     uint32 `binapi:"u32,name=vni" json:"vni,omitempty"`
	DpTable uint32 `binapi:"u32,name=dp_table" json:"dp_table,omitempty"`
}

func (m *LispEidTableMapDetails) Reset()               { *m = LispEidTableMapDetails{} }
func (*LispEidTableMapDetails) GetMessageName() string { return "lisp_eid_table_map_details" }
func (*LispEidTableMapDetails) GetCrcString() string   { return "0b6859e2" }
func (*LispEidTableMapDetails) GetMessageType() api.MessageType {
	return api.ReplyMessage
}

func (m *LispEidTableMapDetails) Size() (size int) {
	if m == nil {
		return 0
	}
	size += 4 // m.Vni
	size += 4 // m.DpTable
	return size
}
func (m *LispEidTableMapDetails) Marshal(b []byte) ([]byte, error) {
	if b == nil {
		b = make([]byte, m.Size())
	}
	buf := codec.NewBuffer(b)
	buf.EncodeUint32(m.Vni)
	buf.EncodeUint32(m.DpTable)
	return buf.Bytes(), nil
}
func (m *LispEidTableMapDetails) Unmarshal(b []byte) error {
	buf := codec.NewBuffer(b)
	m.Vni = buf.DecodeUint32()
	m.DpTable = buf.DecodeUint32()
	return nil
}

// Request for lisp_eid_table_map_details
//   - is_l2 - if set dump vni/bd mappings else vni/vrf
//
// LispEidTableMapDump defines message 'lisp_eid_table_map_dump'.
type LispEidTableMapDump struct {
	IsL2 bool `binapi:"bool,name=is_l2" json:"is_l2,omitempty"`
}

func (m *LispEidTableMapDump) Reset()               { *m = LispEidTableMapDump{} }
func (*LispEidTableMapDump) GetMessageName() string { return "lisp_eid_table_map_dump" }
func (*LispEidTableMapDump) GetCrcString() string   { return "d6cf0c3d" }
func (*LispEidTableMapDump) GetMessageType() api.MessageType {
	return api.RequestMessage
}

func (m *LispEidTableMapDump) Size() (size int) {
	if m == nil {
		return 0
	}
	size += 1 // m.IsL2
	return size
}
func (m *LispEidTableMapDump) Marshal(b []byte) ([]byte, error) {
	if b == nil {
		b = make([]byte, m.Size())
	}
	buf := codec.NewBuffer(b)
	buf.EncodeBool(m.IsL2)
	return buf.Bytes(), nil
}
func (m *LispEidTableMapDump) Unmarshal(b []byte) error {
	buf := codec.NewBuffer(b)
	m.IsL2 = buf.DecodeBool()
	return nil
}

// reply to lisp_eid_table_vni_dump
//   - vni - virtual network instance
//
// LispEidTableVniDetails defines message 'lisp_eid_table_vni_details'.
type LispEidTableVniDetails struct {
	Vni uint32 `binapi:"u32,name=vni" json:"vni,omitempty"`
}

func (m *LispEidTableVniDetails) Reset()               { *m = LispEidTableVniDetails{} }
func (*LispEidTableVniDetails) GetMessageName() string { return "lisp_eid_table_vni_details" }
func (*LispEidTableVniDetails) GetCrcString() string   { return "64abc01e" }
func (*LispEidTableVniDetails) GetMessageType() api.MessageType {
	return api.ReplyMessage
}

func (m *LispEidTableVniDetails) Size() (size int) {
	if m == nil {
		return 0
	}
	size += 4 // m.Vni
	return size
}
func (m *LispEidTableVniDetails) Marshal(b []byte) ([]byte, error) {
	if b == nil {
		b = make([]byte, m.Size())
	}
	buf := codec.NewBuffer(b)
	buf.EncodeUint32(m.Vni)
	return buf.Bytes(), nil
}
func (m *LispEidTableVniDetails) Unmarshal(b []byte) error {
	buf := codec.NewBuffer(b)
	m.Vni = buf.DecodeUint32()
	return nil
}

// Dumps all VNIs used in mappings
// LispEidTableVniDump defines message 'lisp_eid_table_vni_dump'.
type LispEidTableVniDump struct{}

func (m *LispEidTableVniDump) Reset()               { *m = LispEidTableVniDump{} }
func (*LispEidTableVniDump) GetMessageName() string { return "lisp_eid_table_vni_dump" }
func (*LispEidTableVniDump) GetCrcString() string   { return "51077d14" }
func (*LispEidTableVniDump) GetMessageType() api.MessageType {
	return api.RequestMessage
}

func (m *LispEidTableVniDump) Size() (size int) {
	if m == nil {
		return 0
	}
	return size
}
func (m *LispEidTableVniDump) Marshal(b []byte) ([]byte, error) {
	if b == nil {
		b = make([]byte, m.Size())
	}
	buf := codec.NewBuffer(b)
	return buf.Bytes(), nil
}
func (m *LispEidTableVniDump) Unmarshal(b []byte) error {
	return nil
}

// enable or disable LISP feature
//   - is_en - enable protocol if non-zero, else disable
//
// LispEnableDisable defines message 'lisp_enable_disable'.
type LispEnableDisable struct {
	IsEnable bool `binapi:"bool,name=is_enable,default=true" json:"is_enable,omitempty"`
}

func (m *LispEnableDisable) Reset()               { *m = LispEnableDisable{} }
func (*LispEnableDisable) GetMessageName() string { return "lisp_enable_disable" }
func (*LispEnableDisable) GetCrcString() string   { return "c264d7bf" }
func (*LispEnableDisable) GetMessageType() api.MessageType {
	return api.RequestMessage
}

func (m *LispEnableDisable) Size() (size int) {
	if m == nil {
		return 0
	}
	size += 1 // m.IsEnable
	return size
}
func (m *LispEnableDisable) Marshal(b []byte) ([]byte, error) {
	if b == nil {
		b = make([]byte, m.Size())
	}
	buf := codec.NewBuffer(b)
	buf.EncodeBool(m.IsEnable)
	return buf.Bytes(), nil
}
func (m *LispEnableDisable) Unmarshal(b []byte) error {
	buf := codec.NewBuffer(b)
	m.IsEnable = buf.DecodeBool()
	return nil
}

// LispEnableDisableReply defines message 'lisp_enable_disable_reply'.
type LispEnableDisableReply struct {
	Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
}

func (m *LispEnableDisableReply) Reset()               { *m = LispEnableDisableReply{} }
func (*LispEnableDisableReply) GetMessageName() string { return "lisp_enable_disable_reply" }
func (*LispEnableDisableReply) GetCrcString() string   { return "e8d4e804" }
func (*LispEnableDisableReply) GetMessageType() api.MessageType {
	return api.ReplyMessage
}

func (m *LispEnableDisableReply) Size() (size int) {
	if m == nil {
		return 0
	}
	size += 4 // m.Retval
	return size
}
func (m *LispEnableDisableReply) Marshal(b []byte) ([]byte, error) {
	if b == nil {
		b = make([]byte, m.Size())
	}
	buf := codec.NewBuffer(b)
	buf.EncodeInt32(m.Retval)
	return buf.Bytes(), nil
}
func (m *LispEnableDisableReply) Unmarshal(b []byte) error {
	buf := codec.NewBuffer(b)
	m.Retval = buf.DecodeInt32()
	return nil
}

// Get LISP map request itr rlocs status
//   - locator_set_name - name of the locator_set
//
// LispGetMapRequestItrRlocs defines message 'lisp_get_map_request_itr_rlocs'.
type LispGetMapRequestItrRlocs struct{}

func (m *LispGetMapRequestItrRlocs) Reset()               { *m = LispGetMapRequestItrRlocs{} }
func (*LispGetMapRequestItrRlocs) GetMessageName() string { return "lisp_get_map_request_itr_rlocs" }
func (*LispGetMapRequestItrRlocs) GetCrcString() string   { return "51077d14" }
func (*LispGetMapRequestItrRlocs) GetMessageType() api.MessageType {
	return api.RequestMessage
}

func (m *LispGetMapRequestItrRlocs) Size() (size int) {
	if m == nil {
		return 0
	}
	return size
}
func (m *LispGetMapRequestItrRlocs) Marshal(b []byte) ([]byte, error) {
	if b == nil {
		b = make([]byte, m.Size())
	}
	buf := codec.NewBuffer(b)
	return buf.Bytes(), nil
}
func (m *LispGetMapRequestItrRlocs) Unmarshal(b []byte) error {
	return nil
}

// Request for map request itr rlocs summary status
// LispGetMapRequestItrRlocsReply defines message 'lisp_get_map_request_itr_rlocs_reply'.
type LispGetMapRequestItrRlocsReply struct {
	Retval         int32  `binapi:"i32,name=retval" json:"retval,omitempty"`
	LocatorSetName string `binapi:"string[64],name=locator_set_name" json:"locator_set_name,omitempty"`
}

func (m *LispGetMapRequestItrRlocsReply) Reset() { *m = LispGetMapRequestItrRlocsReply{} }
func (*LispGetMapRequestItrRlocsReply) GetMessageName() string {
	return "lisp_get_map_request_itr_rlocs_reply"
}
func (*LispGetMapRequestItrRlocsReply) GetCrcString() string { return "76580f3a" }
func (*LispGetMapRequestItrRlocsReply) GetMessageType() api.MessageType {
	return api.ReplyMessage
}

func (m *LispGetMapRequestItrRlocsReply) Size() (size int) {
	if m == nil {
		return 0
	}
	size += 4  // m.Retval
	size += 64 // m.LocatorSetName
	return size
}
func (m *LispGetMapRequestItrRlocsReply) Marshal(b []byte) ([]byte, error) {
	if b == nil {
		b = make([]byte, m.Size())
	}
	buf := codec.NewBuffer(b)
	buf.EncodeInt32(m.Retval)
	buf.EncodeString(m.LocatorSetName, 64)
	return buf.Bytes(), nil
}
func (m *LispGetMapRequestItrRlocsReply) Unmarshal(b []byte) error {
	buf := codec.NewBuffer(b)
	m.Retval = buf.DecodeInt32()
	m.LocatorSetName = buf.DecodeString(64)
	return nil
}

// LISP locator_set status
//   - local - if is set, then locator is local
//   - locator_set_name - name of the locator_set
//   - sw_if_index - sw_if_index of the locator
//   - ip_address - ip address
//   - priority - locator priority
//   - weight - locator weight
//
// LispLocatorDetails defines message 'lisp_locator_details'.
type LispLocatorDetails struct {
	Local     uint8                          `binapi:"u8,name=local" json:"local,omitempty"`
	SwIfIndex interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
	IPAddress ip_types.Address               `binapi:"address,name=ip_address" json:"ip_address,omitempty"`
	Priority  uint8                          `binapi:"u8,name=priority" json:"priority,omitempty"`
	Weight    uint8                          `binapi:"u8,name=weight" json:"weight,omitempty"`
}

func (m *LispLocatorDetails) Reset()               { *m = LispLocatorDetails{} }
func (*LispLocatorDetails) GetMessageName() string { return "lisp_locator_details" }
func (*LispLocatorDetails) GetCrcString() string   { return "2c620ffe" }
func (*LispLocatorDetails) GetMessageType() api.MessageType {
	return api.ReplyMessage
}

func (m *LispLocatorDetails) Size() (size int) {
	if m == nil {
		return 0
	}
	size += 1      // m.Local
	size += 4      // m.SwIfIndex
	size += 1      // m.IPAddress.Af
	size += 1 * 16 // m.IPAddress.Un
	size += 1      // m.Priority
	size += 1      // m.Weight
	return size
}
func (m *LispLocatorDetails) Marshal(b []byte) ([]byte, error) {
	if b == nil {
		b = make([]byte, m.Size())
	}
	buf := codec.NewBuffer(b)
	buf.EncodeUint8(m.Local)
	buf.EncodeUint32(uint32(m.SwIfIndex))
	buf.EncodeUint8(uint8(m.IPAddress.Af))
	buf.EncodeBytes(m.IPAddress.Un.XXX_UnionData[:], 16)
	buf.EncodeUint8(m.Priority)
	buf.EncodeUint8(m.Weight)
	return buf.Bytes(), nil
}
func (m *LispLocatorDetails) Unmarshal(b []byte) error {
	buf := codec.NewBuffer(b)
	m.Local = buf.DecodeUint8()
	m.SwIfIndex = interface_types.InterfaceIndex(buf.DecodeUint32())
	m.IPAddress.Af = ip_types.AddressFamily(buf.DecodeUint8())
	copy(m.IPAddress.Un.XXX_UnionData[:], buf.DecodeBytes(16))
	m.Priority = buf.DecodeUint8()
	m.Weight = buf.DecodeUint8()
	return nil
}

// Request for map lisp locator status
//   - locator_set_index - index of locator_set
//   - ls_name - locator set name
//   - is_index_set - flag indicating whether ls_name or ls_index is set
//
// LispLocatorDump defines message 'lisp_locator_dump'.
type LispLocatorDump struct {
	LsIndex    uint32 `binapi:"u32,name=ls_index" json:"ls_index,omitempty"`
	LsName     string `binapi:"string[64],name=ls_name" json:"ls_name,omitempty"`
	IsIndexSet uint8  `binapi:"u8,name=is_index_set" json:"is_index_set,omitempty"`
}

func (m *LispLocatorDump) Reset()               { *m = LispLocatorDump{} }
func (*LispLocatorDump) GetMessageName() string { return "lisp_locator_dump" }
func (*LispLocatorDump) GetCrcString() string   { return "b954fad7" }
func (*LispLocatorDump) GetMessageType() api.MessageType {
	return api.RequestMessage
}

func (m *LispLocatorDump) Size() (size int) {
	if m == nil {
		return 0
	}
	size += 4  // m.LsIndex
	size += 64 // m.LsName
	size += 1  // m.IsIndexSet
	return size
}
func (m *LispLocatorDump) Marshal(b []byte) ([]byte, error) {
	if b == nil {
		b = make([]byte, m.Size())
	}
	buf := codec.NewBuffer(b)
	buf.EncodeUint32(m.LsIndex)
	buf.EncodeString(m.LsName, 64)
	buf.EncodeUint8(m.IsIndexSet)
	return buf.Bytes(), nil
}
func (m *LispLocatorDump) Unmarshal(b []byte) error {
	buf := codec.NewBuffer(b)
	m.LsIndex = buf.DecodeUint32()
	m.LsName = buf.DecodeString(64)
	m.IsIndexSet = buf.DecodeUint8()
	return nil
}

// LISP locator_set status
//   - ls_index - locator set index
//   - ls_name - name of the locator set
//
// LispLocatorSetDetails defines message 'lisp_locator_set_details'.
type LispLocatorSetDetails struct {
	LsIndex uint32 `binapi:"u32,name=ls_index" json:"ls_index,omitempty"`
	LsName  string `binapi:"string[64],name=ls_name" json:"ls_name,omitempty"`
}

func (m *LispLocatorSetDetails) Reset()               { *m = LispLocatorSetDetails{} }
func (*LispLocatorSetDetails) GetMessageName() string { return "lisp_locator_set_details" }
func (*LispLocatorSetDetails) GetCrcString() string   { return "5b33a105" }
func (*LispLocatorSetDetails) GetMessageType() api.MessageType {
	return api.ReplyMessage
}

func (m *LispLocatorSetDetails) Size() (size int) {
	if m == nil {
		return 0
	}
	size += 4  // m.LsIndex
	size += 64 // m.LsName
	return size
}
func (m *LispLocatorSetDetails) Marshal(b []byte) ([]byte, error) {
	if b == nil {
		b = make([]byte, m.Size())
	}
	buf := codec.NewBuffer(b)
	buf.EncodeUint32(m.LsIndex)
	buf.EncodeString(m.LsName, 64)
	return buf.Bytes(), nil
}
func (m *LispLocatorSetDetails) Unmarshal(b []byte) error {
	buf := codec.NewBuffer(b)
	m.LsIndex = buf.DecodeUint32()
	m.LsName = buf.DecodeString(64)
	return nil
}

// Request for locator_set summary status
//   - filter - filter type
//
// LispLocatorSetDump defines message 'lisp_locator_set_dump'.
type LispLocatorSetDump struct {
	Filter LispLocatorSetFilter `binapi:"lisp_locator_set_filter,name=filter" json:"filter,omitempty"`
}

func (m *LispLocatorSetDump) Reset()               { *m = LispLocatorSetDump{} }
func (*LispLocatorSetDump) GetMessageName() string { return "lisp_locator_set_dump" }
func (*LispLocatorSetDump) GetCrcString() string   { return "c2cb5922" }
func (*LispLocatorSetDump) GetMessageType() api.MessageType {
	return api.RequestMessage
}

func (m *LispLocatorSetDump) Size() (size int) {
	if m == nil {
		return 0
	}
	size += 1 // m.Filter
	return size
}
func (m *LispLocatorSetDump) Marshal(b []byte) ([]byte, error) {
	if b == nil {
		b = make([]byte, m.Size())
	}
	buf := codec.NewBuffer(b)
	buf.EncodeUint8(uint8(m.Filter))
	return buf.Bytes(), nil
}
func (m *LispLocatorSetDump) Unmarshal(b []byte) error {
	buf := codec.NewBuffer(b)
	m.Filter = LispLocatorSetFilter(buf.DecodeUint8())
	return nil
}

// enable/disable LISP map-register
//   - is_enable - enable if non-zero; disable otherwise
//
// LispMapRegisterEnableDisable defines message 'lisp_map_register_enable_disable'.
type LispMapRegisterEnableDisable struct {
	IsEnable bool `binapi:"bool,name=is_enable,default=true" json:"is_enable,omitempty"`
}

func (m *LispMapRegisterEnableDisable) Reset() { *m = LispMapRegisterEnableDisable{} }
func (*LispMapRegisterEnableDisable) GetMessageName() string {
	return "lisp_map_register_enable_disable"
}
func (*LispMapRegisterEnableDisable) GetCrcString() string { return "c264d7bf" }
func (*LispMapRegisterEnableDisable) GetMessageType() api.MessageType {
	return api.RequestMessage
}

func (m *LispMapRegisterEnableDisable) Size() (size int) {
	if m == nil {
		return 0
	}
	size += 1 // m.IsEnable
	return size
}
func (m *LispMapRegisterEnableDisable) Marshal(b []byte) ([]byte, error) {
	if b == nil {
		b = make([]byte, m.Size())
	}
	buf := codec.NewBuffer(b)
	buf.EncodeBool(m.IsEnable)
	return buf.Bytes(), nil
}
func (m *LispMapRegisterEnableDisable) Unmarshal(b []byte) error {
	buf := codec.NewBuffer(b)
	m.IsEnable = buf.DecodeBool()
	return nil
}

// LispMapRegisterEnableDisableReply defines message 'lisp_map_register_enable_disable_reply'.
type LispMapRegisterEnableDisableReply struct {
	Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
}

func (m *LispMapRegisterEnableDisableReply) Reset() { *m = LispMapRegisterEnableDisableReply{} }
func (*LispMapRegisterEnableDisableReply) GetMessageName() string {
	return "lisp_map_register_enable_disable_reply"
}
func (*LispMapRegisterEnableDisableReply) GetCrcString() string { return "e8d4e804" }
func (*LispMapRegisterEnableDisableReply) GetMessageType() api.MessageType {
	return api.ReplyMessage
}

func (m *LispMapRegisterEnableDisableReply) Size() (size int) {
	if m == nil {
		return 0
	}
	size += 4 // m.Retval
	return size
}
func (m *LispMapRegisterEnableDisableReply) Marshal(b []byte) ([]byte, error) {
	if b == nil {
		b = make([]byte, m.Size())
	}
	buf := codec.NewBuffer(b)
	buf.EncodeInt32(m.Retval)
	return buf.Bytes(), nil
}
func (m *LispMapRegisterEnableDisableReply) Unmarshal(b []byte) error {
	buf := codec.NewBuffer(b)
	m.Retval = buf.DecodeInt32()
	return nil
}

// set LISP map-request mode. Based on configuration VPP will send
//
//	  src/dest or just normal destination map requests.
//	- is_src_dst - if non-zero source/destination else destination only
//
// LispMapRequestMode defines message 'lisp_map_request_mode'.
type LispMapRequestMode struct {
	IsSrcDst bool `binapi:"bool,name=is_src_dst" json:"is_src_dst,omitempty"`
}

func (m *LispMapRequestMode) Reset()               { *m = LispMapRequestMode{} }
func (*LispMapRequestMode) GetMessageName() string { return "lisp_map_request_mode" }
func (*LispMapRequestMode) GetCrcString() string   { return "f43c26ae" }
func (*LispMapRequestMode) GetMessageType() api.MessageType {
	return api.RequestMessage
}

func (m *LispMapRequestMode) Size() (size int) {
	if m == nil {
		return 0
	}
	size += 1 // m.IsSrcDst
	return size
}
func (m *LispMapRequestMode) Marshal(b []byte) ([]byte, error) {
	if b == nil {
		b = make([]byte, m.Size())
	}
	buf := codec.NewBuffer(b)
	buf.EncodeBool(m.IsSrcDst)
	return buf.Bytes(), nil
}
func (m *LispMapRequestMode) Unmarshal(b []byte) error {
	buf := codec.NewBuffer(b)
	m.IsSrcDst = buf.DecodeBool()
	return nil
}

// LispMapRequestModeReply defines message 'lisp_map_request_mode_reply'.
type LispMapRequestModeReply struct {
	Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
}

func (m *LispMapRequestModeReply) Reset()               { *m = LispMapRequestModeReply{} }
func (*LispMapRequestModeReply) GetMessageName() string { return "lisp_map_request_mode_reply" }
func (*LispMapRequestModeReply) GetCrcString() string   { return "e8d4e804" }
func (*LispMapRequestModeReply) GetMessageType() api.MessageType {
	return api.ReplyMessage
}

func (m *LispMapRequestModeReply) Size() (size int) {
	if m == nil {
		return 0
	}
	size += 4 // m.Retval
	return size
}
func (m *LispMapRequestModeReply) Marshal(b []byte) ([]byte, error) {
	if b == nil {
		b = make([]byte, m.Size())
	}
	buf := codec.NewBuffer(b)
	buf.EncodeInt32(m.Retval)
	return buf.Bytes(), nil
}
func (m *LispMapRequestModeReply) Unmarshal(b []byte) error {
	buf := codec.NewBuffer(b)
	m.Retval = buf.DecodeInt32()
	return nil
}

// LISP map resolver status
//   - ip_address - array of address bytes
//
// LispMapResolverDetails defines message 'lisp_map_resolver_details'.
type LispMapResolverDetails struct {
	IPAddress ip_types.Address `binapi:"address,name=ip_address" json:"ip_address,omitempty"`
}

func (m *LispMapResolverDetails) Reset()               { *m = LispMapResolverDetails{} }
func (*LispMapResolverDetails) GetMessageName() string { return "lisp_map_resolver_details" }
func (*LispMapResolverDetails) GetCrcString() string   { return "3e78fc57" }
func (*LispMapResolverDetails) GetMessageType() api.MessageType {
	return api.ReplyMessage
}

func (m *LispMapResolverDetails) Size() (size int) {
	if m == nil {
		return 0
	}
	size += 1      // m.IPAddress.Af
	size += 1 * 16 // m.IPAddress.Un
	return size
}
func (m *LispMapResolverDetails) Marshal(b []byte) ([]byte, error) {
	if b == nil {
		b = make([]byte, m.Size())
	}
	buf := codec.NewBuffer(b)
	buf.EncodeUint8(uint8(m.IPAddress.Af))
	buf.EncodeBytes(m.IPAddress.Un.XXX_UnionData[:], 16)
	return buf.Bytes(), nil
}
func (m *LispMapResolverDetails) Unmarshal(b []byte) error {
	buf := codec.NewBuffer(b)
	m.IPAddress.Af = ip_types.AddressFamily(buf.DecodeUint8())
	copy(m.IPAddress.Un.XXX_UnionData[:], buf.DecodeBytes(16))
	return nil
}

// Request for map resolver summary status
// LispMapResolverDump defines message 'lisp_map_resolver_dump'.
type LispMapResolverDump struct{}

func (m *LispMapResolverDump) Reset()               { *m = LispMapResolverDump{} }
func (*LispMapResolverDump) GetMessageName() string { return "lisp_map_resolver_dump" }
func (*LispMapResolverDump) GetCrcString() string   { return "51077d14" }
func (*LispMapResolverDump) GetMessageType() api.MessageType {
	return api.RequestMessage
}

func (m *LispMapResolverDump) Size() (size int) {
	if m == nil {
		return 0
	}
	return size
}
func (m *LispMapResolverDump) Marshal(b []byte) ([]byte, error) {
	if b == nil {
		b = make([]byte, m.Size())
	}
	buf := codec.NewBuffer(b)
	return buf.Bytes(), nil
}
func (m *LispMapResolverDump) Unmarshal(b []byte) error {
	return nil
}

// LISP map server details
//   - ip_address - array of address bytes
//
// LispMapServerDetails defines message 'lisp_map_server_details'.
type LispMapServerDetails struct {
	IPAddress ip_types.Address `binapi:"address,name=ip_address" json:"ip_address,omitempty"`
}

func (m *LispMapServerDetails) Reset()               { *m = LispMapServerDetails{} }
func (*LispMapServerDetails) GetMessageName() string { return "lisp_map_server_details" }
func (*LispMapServerDetails) GetCrcString() string   { return "3e78fc57" }
func (*LispMapServerDetails) GetMessageType() api.MessageType {
	return api.ReplyMessage
}

func (m *LispMapServerDetails) Size() (size int) {
	if m == nil {
		return 0
	}
	size += 1      // m.IPAddress.Af
	size += 1 * 16 // m.IPAddress.Un
	return size
}
func (m *LispMapServerDetails) Marshal(b []byte) ([]byte, error) {
	if b == nil {
		b = make([]byte, m.Size())
	}
	buf := codec.NewBuffer(b)
	buf.EncodeUint8(uint8(m.IPAddress.Af))
	buf.EncodeBytes(m.IPAddress.Un.XXX_UnionData[:], 16)
	return buf.Bytes(), nil
}
func (m *LispMapServerDetails) Unmarshal(b []byte) error {
	buf := codec.NewBuffer(b)
	m.IPAddress.Af = ip_types.AddressFamily(buf.DecodeUint8())
	copy(m.IPAddress.Un.XXX_UnionData[:], buf.DecodeBytes(16))
	return nil
}

// Request for map server summary status
// LispMapServerDump defines message 'lisp_map_server_dump'.
type LispMapServerDump struct{}

func (m *LispMapServerDump) Reset()               { *m = LispMapServerDump{} }
func (*LispMapServerDump) GetMessageName() string { return "lisp_map_server_dump" }
func (*LispMapServerDump) GetCrcString() string   { return "51077d14" }
func (*LispMapServerDump) GetMessageType() api.MessageType {
	return api.RequestMessage
}

func (m *LispMapServerDump) Size() (size int) {
	if m == nil {
		return 0
	}
	return size
}
func (m *LispMapServerDump) Marshal(b []byte) ([]byte, error) {
	if b == nil {
		b = make([]byte, m.Size())
	}
	buf := codec.NewBuffer(b)
	return buf.Bytes(), nil
}
func (m *LispMapServerDump) Unmarshal(b []byte) error {
	return nil
}

// configure or disable LISP PITR node
//   - ls_name - locator set name
//   - is_add - add locator set if non-zero, else disable pitr
//
// LispPitrSetLocatorSet defines message 'lisp_pitr_set_locator_set'.
type LispPitrSetLocatorSet struct {
	IsAdd  bool   `binapi:"bool,name=is_add,default=true" json:"is_add,omitempty"`
	LsName string `binapi:"string[64],name=ls_name" json:"ls_name,omitempty"`
}

func (m *LispPitrSetLocatorSet) Reset()               { *m = LispPitrSetLocatorSet{} }
func (*LispPitrSetLocatorSet) GetMessageName() string { return "lisp_pitr_set_locator_set" }
func (*LispPitrSetLocatorSet) GetCrcString() string   { return "486e2b76" }
func (*LispPitrSetLocatorSet) GetMessageType() api.MessageType {
	return api.RequestMessage
}

func (m *LispPitrSetLocatorSet) Size() (size int) {
	if m == nil {
		return 0
	}
	size += 1  // m.IsAdd
	size += 64 // m.LsName
	return size
}
func (m *LispPitrSetLocatorSet) Marshal(b []byte) ([]byte, error) {
	if b == nil {
		b = make([]byte, m.Size())
	}
	buf := codec.NewBuffer(b)
	buf.EncodeBool(m.IsAdd)
	buf.EncodeString(m.LsName, 64)
	return buf.Bytes(), nil
}
func (m *LispPitrSetLocatorSet) Unmarshal(b []byte) error {
	buf := codec.NewBuffer(b)
	m.IsAdd = buf.DecodeBool()
	m.LsName = buf.DecodeString(64)
	return nil
}

// LispPitrSetLocatorSetReply defines message 'lisp_pitr_set_locator_set_reply'.
type LispPitrSetLocatorSetReply struct {
	Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
}

func (m *LispPitrSetLocatorSetReply) Reset()               { *m = LispPitrSetLocatorSetReply{} }
func (*LispPitrSetLocatorSetReply) GetMessageName() string { return "lisp_pitr_set_locator_set_reply" }
func (*LispPitrSetLocatorSetReply) GetCrcString() string   { return "e8d4e804" }
func (*LispPitrSetLocatorSetReply) GetMessageType() api.MessageType {
	return api.ReplyMessage
}

func (m *LispPitrSetLocatorSetReply) Size() (size int) {
	if m == nil {
		return 0
	}
	size += 4 // m.Retval
	return size
}
func (m *LispPitrSetLocatorSetReply) Marshal(b []byte) ([]byte, error) {
	if b == nil {
		b = make([]byte, m.Size())
	}
	buf := codec.NewBuffer(b)
	buf.EncodeInt32(m.Retval)
	return buf.Bytes(), nil
}
func (m *LispPitrSetLocatorSetReply) Unmarshal(b []byte) error {
	buf := codec.NewBuffer(b)
	m.Retval = buf.DecodeInt32()
	return nil
}

// enable/disable LISP RLOC probing
//   - is_enable - enable if non-zero; disable otherwise
//
// LispRlocProbeEnableDisable defines message 'lisp_rloc_probe_enable_disable'.
type LispRlocProbeEnableDisable struct {
	IsEnable bool `binapi:"bool,name=is_enable,default=true" json:"is_enable,omitempty"`
}

func (m *LispRlocProbeEnableDisable) Reset()               { *m = LispRlocProbeEnableDisable{} }
func (*LispRlocProbeEnableDisable) GetMessageName() string { return "lisp_rloc_probe_enable_disable" }
func (*LispRlocProbeEnableDisable) GetCrcString() string   { return "c264d7bf" }
func (*LispRlocProbeEnableDisable) GetMessageType() api.MessageType {
	return api.RequestMessage
}

func (m *LispRlocProbeEnableDisable) Size() (size int) {
	if m == nil {
		return 0
	}
	size += 1 // m.IsEnable
	return size
}
func (m *LispRlocProbeEnableDisable) Marshal(b []byte) ([]byte, error) {
	if b == nil {
		b = make([]byte, m.Size())
	}
	buf := codec.NewBuffer(b)
	buf.EncodeBool(m.IsEnable)
	return buf.Bytes(), nil
}
func (m *LispRlocProbeEnableDisable) Unmarshal(b []byte) error {
	buf := codec.NewBuffer(b)
	m.IsEnable = buf.DecodeBool()
	return nil
}

// LispRlocProbeEnableDisableReply defines message 'lisp_rloc_probe_enable_disable_reply'.
type LispRlocProbeEnableDisableReply struct {
	Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
}

func (m *LispRlocProbeEnableDisableReply) Reset() { *m = LispRlocProbeEnableDisableReply{} }
func (*LispRlocProbeEnableDisableReply) GetMessageName() string {
	return "lisp_rloc_probe_enable_disable_reply"
}
func (*LispRlocProbeEnableDisableReply) GetCrcString() string { return "e8d4e804" }
func (*LispRlocProbeEnableDisableReply) GetMessageType() api.MessageType {
	return api.ReplyMessage
}

func (m *LispRlocProbeEnableDisableReply) Size() (size int) {
	if m == nil {
		return 0
	}
	size += 4 // m.Retval
	return size
}
func (m *LispRlocProbeEnableDisableReply) Marshal(b []byte) ([]byte, error) {
	if b == nil {
		b = make([]byte, m.Size())
	}
	buf := codec.NewBuffer(b)
	buf.EncodeInt32(m.Retval)
	return buf.Bytes(), nil
}
func (m *LispRlocProbeEnableDisableReply) Unmarshal(b []byte) error {
	buf := codec.NewBuffer(b)
	m.Retval = buf.DecodeInt32()
	return nil
}

// configure or disable use of PETR
//   - ip_address - PETR IP address
//   - is_add - add locator set if non-zero, else disable pitr
//
// LispUsePetr defines message 'lisp_use_petr'.
type LispUsePetr struct {
	IPAddress ip_types.Address `binapi:"address,name=ip_address" json:"ip_address,omitempty"`
	IsAdd     bool             `binapi:"bool,name=is_add,default=true" json:"is_add,omitempty"`
}

func (m *LispUsePetr) Reset()               { *m = LispUsePetr{} }
func (*LispUsePetr) GetMessageName() string { return "lisp_use_petr" }
func (*LispUsePetr) GetCrcString() string   { return "d87dbad9" }
func (*LispUsePetr) GetMessageType() api.MessageType {
	return api.RequestMessage
}

func (m *LispUsePetr) Size() (size int) {
	if m == nil {
		return 0
	}
	size += 1      // m.IPAddress.Af
	size += 1 * 16 // m.IPAddress.Un
	size += 1      // m.IsAdd
	return size
}
func (m *LispUsePetr) Marshal(b []byte) ([]byte, error) {
	if b == nil {
		b = make([]byte, m.Size())
	}
	buf := codec.NewBuffer(b)
	buf.EncodeUint8(uint8(m.IPAddress.Af))
	buf.EncodeBytes(m.IPAddress.Un.XXX_UnionData[:], 16)
	buf.EncodeBool(m.IsAdd)
	return buf.Bytes(), nil
}
func (m *LispUsePetr) Unmarshal(b []byte) error {
	buf := codec.NewBuffer(b)
	m.IPAddress.Af = ip_types.AddressFamily(buf.DecodeUint8())
	copy(m.IPAddress.Un.XXX_UnionData[:], buf.DecodeBytes(16))
	m.IsAdd = buf.DecodeBool()
	return nil
}

// LispUsePetrReply defines message 'lisp_use_petr_reply'.
type LispUsePetrReply struct {
	Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
}

func (m *LispUsePetrReply) Reset()               { *m = LispUsePetrReply{} }
func (*LispUsePetrReply) GetMessageName() string { return "lisp_use_petr_reply" }
func (*LispUsePetrReply) GetCrcString() string   { return "e8d4e804" }
func (*LispUsePetrReply) GetMessageType() api.MessageType {
	return api.ReplyMessage
}

func (m *LispUsePetrReply) Size() (size int) {
	if m == nil {
		return 0
	}
	size += 4 // m.Retval
	return size
}
func (m *LispUsePetrReply) Marshal(b []byte) ([]byte, error) {
	if b == nil {
		b = make([]byte, m.Size())
	}
	buf := codec.NewBuffer(b)
	buf.EncodeInt32(m.Retval)
	return buf.Bytes(), nil
}
func (m *LispUsePetrReply) Unmarshal(b []byte) error {
	buf := codec.NewBuffer(b)
	m.Retval = buf.DecodeInt32()
	return nil
}

// Get state of LISP map-register
// ShowLispMapRegisterState defines message 'show_lisp_map_register_state'.
type ShowLispMapRegisterState struct{}

func (m *ShowLispMapRegisterState) Reset()               { *m = ShowLispMapRegisterState{} }
func (*ShowLispMapRegisterState) GetMessageName() string { return "show_lisp_map_register_state" }
func (*ShowLispMapRegisterState) GetCrcString() string   { return "51077d14" }
func (*ShowLispMapRegisterState) GetMessageType() api.MessageType {
	return api.RequestMessage
}

func (m *ShowLispMapRegisterState) Size() (size int) {
	if m == nil {
		return 0
	}
	return size
}
func (m *ShowLispMapRegisterState) Marshal(b []byte) ([]byte, error) {
	if b == nil {
		b = make([]byte, m.Size())
	}
	buf := codec.NewBuffer(b)
	return buf.Bytes(), nil
}
func (m *ShowLispMapRegisterState) Unmarshal(b []byte) error {
	return nil
}

// Reply for show_lisp_map_register_state
//   - retval - return code
//
// ShowLispMapRegisterStateReply defines message 'show_lisp_map_register_state_reply'.
type ShowLispMapRegisterStateReply struct {
	Retval    int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
	IsEnabled bool  `binapi:"bool,name=is_enabled" json:"is_enabled,omitempty"`
}

func (m *ShowLispMapRegisterStateReply) Reset() { *m = ShowLispMapRegisterStateReply{} }
func (*ShowLispMapRegisterStateReply) GetMessageName() string {
	return "show_lisp_map_register_state_reply"
}
func (*ShowLispMapRegisterStateReply) GetCrcString() string { return "e33a377b" }
func (*ShowLispMapRegisterStateReply) GetMessageType() api.MessageType {
	return api.ReplyMessage
}

func (m *ShowLispMapRegisterStateReply) Size() (size int) {
	if m == nil {
		return 0
	}
	size += 4 // m.Retval
	size += 1 // m.IsEnabled
	return size
}
func (m *ShowLispMapRegisterStateReply) Marshal(b []byte) ([]byte, error) {
	if b == nil {
		b = make([]byte, m.Size())
	}
	buf := codec.NewBuffer(b)
	buf.EncodeInt32(m.Retval)
	buf.EncodeBool(m.IsEnabled)
	return buf.Bytes(), nil
}
func (m *ShowLispMapRegisterStateReply) Unmarshal(b []byte) error {
	buf := codec.NewBuffer(b)
	m.Retval = buf.DecodeInt32()
	m.IsEnabled = buf.DecodeBool()
	return nil
}

// Request for LISP map-request mode
// ShowLispMapRequestMode defines message 'show_lisp_map_request_mode'.
type ShowLispMapRequestMode struct{}

func (m *ShowLispMapRequestMode) Reset()               { *m = ShowLispMapRequestMode{} }
func (*ShowLispMapRequestMode) GetMessageName() string { return "show_lisp_map_request_mode" }
func (*ShowLispMapRequestMode) GetCrcString() string   { return "51077d14" }
func (*ShowLispMapRequestMode) GetMessageType() api.MessageType {
	return api.RequestMessage
}

func (m *ShowLispMapRequestMode) Size() (size int) {
	if m == nil {
		return 0
	}
	return size
}
func (m *ShowLispMapRequestMode) Marshal(b []byte) ([]byte, error) {
	if b == nil {
		b = make([]byte, m.Size())
	}
	buf := codec.NewBuffer(b)
	return buf.Bytes(), nil
}
func (m *ShowLispMapRequestMode) Unmarshal(b []byte) error {
	return nil
}

// Reply for show_lisp_map_request_mode
//   - retval - return code
//   - is_src_dst - if non-zero source/destination else destination only
//
// ShowLispMapRequestModeReply defines message 'show_lisp_map_request_mode_reply'.
type ShowLispMapRequestModeReply struct {
	Retval   int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
	IsSrcDst bool  `binapi:"bool,name=is_src_dst" json:"is_src_dst,omitempty"`
}

func (m *ShowLispMapRequestModeReply) Reset() { *m = ShowLispMapRequestModeReply{} }
func (*ShowLispMapRequestModeReply) GetMessageName() string {
	return "show_lisp_map_request_mode_reply"
}
func (*ShowLispMapRequestModeReply) GetCrcString() string { return "5b05038e" }
func (*ShowLispMapRequestModeReply) GetMessageType() api.MessageType {
	return api.ReplyMessage
}

func (m *ShowLispMapRequestModeReply) Size() (size int) {
	if m == nil {
		return 0
	}
	size += 4 // m.Retval
	size += 1 // m.IsSrcDst
	return size
}
func (m *ShowLispMapRequestModeReply) Marshal(b []byte) ([]byte, error) {
	if b == nil {
		b = make([]byte, m.Size())
	}
	buf := codec.NewBuffer(b)
	buf.EncodeInt32(m.Retval)
	buf.EncodeBool(m.IsSrcDst)
	return buf.Bytes(), nil
}
func (m *ShowLispMapRequestModeReply) Unmarshal(b []byte) error {
	buf := codec.NewBuffer(b)
	m.Retval = buf.DecodeInt32()
	m.IsSrcDst = buf.DecodeBool()
	return nil
}

// Request for lisp pitr status
// ShowLispPitr defines message 'show_lisp_pitr'.
type ShowLispPitr struct{}

func (m *ShowLispPitr) Reset()               { *m = ShowLispPitr{} }
func (*ShowLispPitr) GetMessageName() string { return "show_lisp_pitr" }
func (*ShowLispPitr) GetCrcString() string   { return "51077d14" }
func (*ShowLispPitr) GetMessageType() api.MessageType {
	return api.RequestMessage
}

func (m *ShowLispPitr) Size() (size int) {
	if m == nil {
		return 0
	}
	return size
}
func (m *ShowLispPitr) Marshal(b []byte) ([]byte, error) {
	if b == nil {
		b = make([]byte, m.Size())
	}
	buf := codec.NewBuffer(b)
	return buf.Bytes(), nil
}
func (m *ShowLispPitr) Unmarshal(b []byte) error {
	return nil
}

// Status of lisp pitr, enable or disable
//   - status - lisp pitr enable if non-zero, else disable
//   - locator_set_name -  name of the locator_set
//
// ShowLispPitrReply defines message 'show_lisp_pitr_reply'.
type ShowLispPitrReply struct {
	Retval         int32  `binapi:"i32,name=retval" json:"retval,omitempty"`
	IsEnabled      bool   `binapi:"bool,name=is_enabled" json:"is_enabled,omitempty"`
	LocatorSetName string `binapi:"string[64],name=locator_set_name" json:"locator_set_name,omitempty"`
}

func (m *ShowLispPitrReply) Reset()               { *m = ShowLispPitrReply{} }
func (*ShowLispPitrReply) GetMessageName() string { return "show_lisp_pitr_reply" }
func (*ShowLispPitrReply) GetCrcString() string   { return "27aa69b1" }
func (*ShowLispPitrReply) GetMessageType() api.MessageType {
	return api.ReplyMessage
}

func (m *ShowLispPitrReply) Size() (size int) {
	if m == nil {
		return 0
	}
	size += 4  // m.Retval
	size += 1  // m.IsEnabled
	size += 64 // m.LocatorSetName
	return size
}
func (m *ShowLispPitrReply) Marshal(b []byte) ([]byte, error) {
	if b == nil {
		b = make([]byte, m.Size())
	}
	buf := codec.NewBuffer(b)
	buf.EncodeInt32(m.Retval)
	buf.EncodeBool(m.IsEnabled)
	buf.EncodeString(m.LocatorSetName, 64)
	return buf.Bytes(), nil
}
func (m *ShowLispPitrReply) Unmarshal(b []byte) error {
	buf := codec.NewBuffer(b)
	m.Retval = buf.DecodeInt32()
	m.IsEnabled = buf.DecodeBool()
	m.LocatorSetName = buf.DecodeString(64)
	return nil
}

// Get state of LISP RLOC probing
// ShowLispRlocProbeState defines message 'show_lisp_rloc_probe_state'.
type ShowLispRlocProbeState struct{}

func (m *ShowLispRlocProbeState) Reset()               { *m = ShowLispRlocProbeState{} }
func (*ShowLispRlocProbeState) GetMessageName() string { return "show_lisp_rloc_probe_state" }
func (*ShowLispRlocProbeState) GetCrcString() string   { return "51077d14" }
func (*ShowLispRlocProbeState) GetMessageType() api.MessageType {
	return api.RequestMessage
}

func (m *ShowLispRlocProbeState) Size() (size int) {
	if m == nil {
		return 0
	}
	return size
}
func (m *ShowLispRlocProbeState) Marshal(b []byte) ([]byte, error) {
	if b == nil {
		b = make([]byte, m.Size())
	}
	buf := codec.NewBuffer(b)
	return buf.Bytes(), nil
}
func (m *ShowLispRlocProbeState) Unmarshal(b []byte) error {
	return nil
}

// Reply for show_lisp_rloc_probe_state
//   - retval - return code
//   - is_enabled - state of RLOC probing
//
// ShowLispRlocProbeStateReply defines message 'show_lisp_rloc_probe_state_reply'.
type ShowLispRlocProbeStateReply struct {
	Retval    int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
	IsEnabled bool  `binapi:"bool,name=is_enabled" json:"is_enabled,omitempty"`
}

func (m *ShowLispRlocProbeStateReply) Reset() { *m = ShowLispRlocProbeStateReply{} }
func (*ShowLispRlocProbeStateReply) GetMessageName() string {
	return "show_lisp_rloc_probe_state_reply"
}
func (*ShowLispRlocProbeStateReply) GetCrcString() string { return "e33a377b" }
func (*ShowLispRlocProbeStateReply) GetMessageType() api.MessageType {
	return api.ReplyMessage
}

func (m *ShowLispRlocProbeStateReply) Size() (size int) {
	if m == nil {
		return 0
	}
	size += 4 // m.Retval
	size += 1 // m.IsEnabled
	return size
}
func (m *ShowLispRlocProbeStateReply) Marshal(b []byte) ([]byte, error) {
	if b == nil {
		b = make([]byte, m.Size())
	}
	buf := codec.NewBuffer(b)
	buf.EncodeInt32(m.Retval)
	buf.EncodeBool(m.IsEnabled)
	return buf.Bytes(), nil
}
func (m *ShowLispRlocProbeStateReply) Unmarshal(b []byte) error {
	buf := codec.NewBuffer(b)
	m.Retval = buf.DecodeInt32()
	m.IsEnabled = buf.DecodeBool()
	return nil
}

// Request for lisp-gpe protocol status
// ShowLispStatus defines message 'show_lisp_status'.
type ShowLispStatus struct{}

func (m *ShowLispStatus) Reset()               { *m = ShowLispStatus{} }
func (*ShowLispStatus) GetMessageName() string { return "show_lisp_status" }
func (*ShowLispStatus) GetCrcString() string   { return "51077d14" }
func (*ShowLispStatus) GetMessageType() api.MessageType {
	return api.RequestMessage
}

func (m *ShowLispStatus) Size() (size int) {
	if m == nil {
		return 0
	}
	return size
}
func (m *ShowLispStatus) Marshal(b []byte) ([]byte, error) {
	if b == nil {
		b = make([]byte, m.Size())
	}
	buf := codec.NewBuffer(b)
	return buf.Bytes(), nil
}
func (m *ShowLispStatus) Unmarshal(b []byte) error {
	return nil
}

// Status of lisp, enable or disable
//   - feature_status - lisp enable if non-zero, else disable
//   - gpe_status - lisp enable if non-zero, else disable
//
// ShowLispStatusReply defines message 'show_lisp_status_reply'.
type ShowLispStatusReply struct {
	Retval        int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
	IsLispEnabled bool  `binapi:"bool,name=is_lisp_enabled" json:"is_lisp_enabled,omitempty"`
	IsGpeEnabled  bool  `binapi:"bool,name=is_gpe_enabled" json:"is_gpe_enabled,omitempty"`
}

func (m *ShowLispStatusReply) Reset()               { *m = ShowLispStatusReply{} }
func (*ShowLispStatusReply) GetMessageName() string { return "show_lisp_status_reply" }
func (*ShowLispStatusReply) GetCrcString() string   { return "9e8f10c0" }
func (*ShowLispStatusReply) GetMessageType() api.MessageType {
	return api.ReplyMessage
}

func (m *ShowLispStatusReply) Size() (size int) {
	if m == nil {
		return 0
	}
	size += 4 // m.Retval
	size += 1 // m.IsLispEnabled
	size += 1 // m.IsGpeEnabled
	return size
}
func (m *ShowLispStatusReply) Marshal(b []byte) ([]byte, error) {
	if b == nil {
		b = make([]byte, m.Size())
	}
	buf := codec.NewBuffer(b)
	buf.EncodeInt32(m.Retval)
	buf.EncodeBool(m.IsLispEnabled)
	buf.EncodeBool(m.IsGpeEnabled)
	return buf.Bytes(), nil
}
func (m *ShowLispStatusReply) Unmarshal(b []byte) error {
	buf := codec.NewBuffer(b)
	m.Retval = buf.DecodeInt32()
	m.IsLispEnabled = buf.DecodeBool()
	m.IsGpeEnabled = buf.DecodeBool()
	return nil
}

// Request for LISP PETR status
// ShowLispUsePetr defines message 'show_lisp_use_petr'.
type ShowLispUsePetr struct{}

func (m *ShowLispUsePetr) Reset()               { *m = ShowLispUsePetr{} }
func (*ShowLispUsePetr) GetMessageName() string { return "show_lisp_use_petr" }
func (*ShowLispUsePetr) GetCrcString() string   { return "51077d14" }
func (*ShowLispUsePetr) GetMessageType() api.MessageType {
	return api.RequestMessage
}

func (m *ShowLispUsePetr) Size() (size int) {
	if m == nil {
		return 0
	}
	return size
}
func (m *ShowLispUsePetr) Marshal(b []byte) ([]byte, error) {
	if b == nil {
		b = make([]byte, m.Size())
	}
	buf := codec.NewBuffer(b)
	return buf.Bytes(), nil
}
func (m *ShowLispUsePetr) Unmarshal(b []byte) error {
	return nil
}

// LISP PETR status, enable or disable
//   - status - LISP PETR enable if non-zero, else disable
//   - address - PETR IP address
//
// ShowLispUsePetrReply defines message 'show_lisp_use_petr_reply'.
type ShowLispUsePetrReply struct {
	Retval       int32            `binapi:"i32,name=retval" json:"retval,omitempty"`
	IsPetrEnable bool             `binapi:"bool,name=is_petr_enable" json:"is_petr_enable,omitempty"`
	IPAddress    ip_types.Address `binapi:"address,name=ip_address" json:"ip_address,omitempty"`
}

func (m *ShowLispUsePetrReply) Reset()               { *m = ShowLispUsePetrReply{} }
func (*ShowLispUsePetrReply) GetMessageName() string { return "show_lisp_use_petr_reply" }
func (*ShowLispUsePetrReply) GetCrcString() string   { return "22b9a4b0" }
func (*ShowLispUsePetrReply) GetMessageType() api.MessageType {
	return api.ReplyMessage
}

func (m *ShowLispUsePetrReply) Size() (size int) {
	if m == nil {
		return 0
	}
	size += 4      // m.Retval
	size += 1      // m.IsPetrEnable
	size += 1      // m.IPAddress.Af
	size += 1 * 16 // m.IPAddress.Un
	return size
}
func (m *ShowLispUsePetrReply) Marshal(b []byte) ([]byte, error) {
	if b == nil {
		b = make([]byte, m.Size())
	}
	buf := codec.NewBuffer(b)
	buf.EncodeInt32(m.Retval)
	buf.EncodeBool(m.IsPetrEnable)
	buf.EncodeUint8(uint8(m.IPAddress.Af))
	buf.EncodeBytes(m.IPAddress.Un.XXX_UnionData[:], 16)
	return buf.Bytes(), nil
}
func (m *ShowLispUsePetrReply) Unmarshal(b []byte) error {
	buf := codec.NewBuffer(b)
	m.Retval = buf.DecodeInt32()
	m.IsPetrEnable = buf.DecodeBool()
	m.IPAddress.Af = ip_types.AddressFamily(buf.DecodeUint8())
	copy(m.IPAddress.Un.XXX_UnionData[:], buf.DecodeBytes(16))
	return nil
}

func init() { file_lisp_binapi_init() }
func file_lisp_binapi_init() {
	api.RegisterMessage((*LispAddDelAdjacency)(nil), "lisp_add_del_adjacency_2ce0e6f6")
	api.RegisterMessage((*LispAddDelAdjacencyReply)(nil), "lisp_add_del_adjacency_reply_e8d4e804")
	api.RegisterMessage((*LispAddDelLocalEid)(nil), "lisp_add_del_local_eid_4e5a83a2")
	api.RegisterMessage((*LispAddDelLocalEidReply)(nil), "lisp_add_del_local_eid_reply_e8d4e804")
	api.RegisterMessage((*LispAddDelLocator)(nil), "lisp_add_del_locator_af4d8f13")
	api.RegisterMessage((*LispAddDelLocatorReply)(nil), "lisp_add_del_locator_reply_e8d4e804")
	api.RegisterMessage((*LispAddDelLocatorSet)(nil), "lisp_add_del_locator_set_6fcd6471")
	api.RegisterMessage((*LispAddDelLocatorSetReply)(nil), "lisp_add_del_locator_set_reply_b6666db4")
	api.RegisterMessage((*LispAddDelMapRequestItrRlocs)(nil), "lisp_add_del_map_request_itr_rlocs_6be88e45")
	api.RegisterMessage((*LispAddDelMapRequestItrRlocsReply)(nil), "lisp_add_del_map_request_itr_rlocs_reply_e8d4e804")
	api.RegisterMessage((*LispAddDelMapResolver)(nil), "lisp_add_del_map_resolver_ce19e32d")
	api.RegisterMessage((*LispAddDelMapResolverReply)(nil), "lisp_add_del_map_resolver_reply_e8d4e804")
	api.RegisterMessage((*LispAddDelMapServer)(nil), "lisp_add_del_map_server_ce19e32d")
	api.RegisterMessage((*LispAddDelMapServerReply)(nil), "lisp_add_del_map_server_reply_e8d4e804")
	api.RegisterMessage((*LispAddDelRemoteMapping)(nil), "lisp_add_del_remote_mapping_6d5c789e")
	api.RegisterMessage((*LispAddDelRemoteMappingReply)(nil), "lisp_add_del_remote_mapping_reply_e8d4e804")
	api.RegisterMessage((*LispAdjacenciesGet)(nil), "lisp_adjacencies_get_8d1f2fe9")
	api.RegisterMessage((*LispAdjacenciesGetReply)(nil), "lisp_adjacencies_get_reply_807257bf")
	api.RegisterMessage((*LispEidTableAddDelMap)(nil), "lisp_eid_table_add_del_map_9481416b")
	api.RegisterMessage((*LispEidTableAddDelMapReply)(nil), "lisp_eid_table_add_del_map_reply_e8d4e804")
	api.RegisterMessage((*LispEidTableDetails)(nil), "lisp_eid_table_details_1c29f792")
	api.RegisterMessage((*LispEidTableDump)(nil), "lisp_eid_table_dump_629468b5")
	api.RegisterMessage((*LispEidTableMapDetails)(nil), "lisp_eid_table_map_details_0b6859e2")
	api.RegisterMessage((*LispEidTableMapDump)(nil), "lisp_eid_table_map_dump_d6cf0c3d")
	api.RegisterMessage((*LispEidTableVniDetails)(nil), "lisp_eid_table_vni_details_64abc01e")
	api.RegisterMessage((*LispEidTableVniDump)(nil), "lisp_eid_table_vni_dump_51077d14")
	api.RegisterMessage((*LispEnableDisable)(nil), "lisp_enable_disable_c264d7bf")
	api.RegisterMessage((*LispEnableDisableReply)(nil), "lisp_enable_disable_reply_e8d4e804")
	api.RegisterMessage((*LispGetMapRequestItrRlocs)(nil), "lisp_get_map_request_itr_rlocs_51077d14")
	api.RegisterMessage((*LispGetMapRequestItrRlocsReply)(nil), "lisp_get_map_request_itr_rlocs_reply_76580f3a")
	api.RegisterMessage((*LispLocatorDetails)(nil), "lisp_locator_details_2c620ffe")
	api.RegisterMessage((*LispLocatorDump)(nil), "lisp_locator_dump_b954fad7")
	api.RegisterMessage((*LispLocatorSetDetails)(nil), "lisp_locator_set_details_5b33a105")
	api.RegisterMessage((*LispLocatorSetDump)(nil), "lisp_locator_set_dump_c2cb5922")
	api.RegisterMessage((*LispMapRegisterEnableDisable)(nil), "lisp_map_register_enable_disable_c264d7bf")
	api.RegisterMessage((*LispMapRegisterEnableDisableReply)(nil), "lisp_map_register_enable_disable_reply_e8d4e804")
	api.RegisterMessage((*LispMapRequestMode)(nil), "lisp_map_request_mode_f43c26ae")
	api.RegisterMessage((*LispMapRequestModeReply)(nil), "lisp_map_request_mode_reply_e8d4e804")
	api.RegisterMessage((*LispMapResolverDetails)(nil), "lisp_map_resolver_details_3e78fc57")
	api.RegisterMessage((*LispMapResolverDump)(nil), "lisp_map_resolver_dump_51077d14")
	api.RegisterMessage((*LispMapServerDetails)(nil), "lisp_map_server_details_3e78fc57")
	api.RegisterMessage((*LispMapServerDump)(nil), "lisp_map_server_dump_51077d14")
	api.RegisterMessage((*LispPitrSetLocatorSet)(nil), "lisp_pitr_set_locator_set_486e2b76")
	api.RegisterMessage((*LispPitrSetLocatorSetReply)(nil), "lisp_pitr_set_locator_set_reply_e8d4e804")
	api.RegisterMessage((*LispRlocProbeEnableDisable)(nil), "lisp_rloc_probe_enable_disable_c264d7bf")
	api.RegisterMessage((*LispRlocProbeEnableDisableReply)(nil), "lisp_rloc_probe_enable_disable_reply_e8d4e804")
	api.RegisterMessage((*LispUsePetr)(nil), "lisp_use_petr_d87dbad9")
	api.RegisterMessage((*LispUsePetrReply)(nil), "lisp_use_petr_reply_e8d4e804")
	api.RegisterMessage((*ShowLispMapRegisterState)(nil), "show_lisp_map_register_state_51077d14")
	api.RegisterMessage((*ShowLispMapRegisterStateReply)(nil), "show_lisp_map_register_state_reply_e33a377b")
	api.RegisterMessage((*ShowLispMapRequestMode)(nil), "show_lisp_map_request_mode_51077d14")
	api.RegisterMessage((*ShowLispMapRequestModeReply)(nil), "show_lisp_map_request_mode_reply_5b05038e")
	api.RegisterMessage((*ShowLispPitr)(nil), "show_lisp_pitr_51077d14")
	api.RegisterMessage((*ShowLispPitrReply)(nil), "show_lisp_pitr_reply_27aa69b1")
	api.RegisterMessage((*ShowLispRlocProbeState)(nil), "show_lisp_rloc_probe_state_51077d14")
	api.RegisterMessage((*ShowLispRlocProbeStateReply)(nil), "show_lisp_rloc_probe_state_reply_e33a377b")
	api.RegisterMessage((*ShowLispStatus)(nil), "show_lisp_status_51077d14")
	api.RegisterMessage((*ShowLispStatusReply)(nil), "show_lisp_status_reply_9e8f10c0")
	api.RegisterMessage((*ShowLispUsePetr)(nil), "show_lisp_use_petr_51077d14")
	api.RegisterMessage((*ShowLispUsePetrReply)(nil), "show_lisp_use_petr_reply_22b9a4b0")
}

// Messages returns list of all messages in this module.
func AllMessages() []api.Message {
	return []api.Message{
		(*LispAddDelAdjacency)(nil),
		(*LispAddDelAdjacencyReply)(nil),
		(*LispAddDelLocalEid)(nil),
		(*LispAddDelLocalEidReply)(nil),
		(*LispAddDelLocator)(nil),
		(*LispAddDelLocatorReply)(nil),
		(*LispAddDelLocatorSet)(nil),
		(*LispAddDelLocatorSetReply)(nil),
		(*LispAddDelMapRequestItrRlocs)(nil),
		(*LispAddDelMapRequestItrRlocsReply)(nil),
		(*LispAddDelMapResolver)(nil),
		(*LispAddDelMapResolverReply)(nil),
		(*LispAddDelMapServer)(nil),
		(*LispAddDelMapServerReply)(nil),
		(*LispAddDelRemoteMapping)(nil),
		(*LispAddDelRemoteMappingReply)(nil),
		(*LispAdjacenciesGet)(nil),
		(*LispAdjacenciesGetReply)(nil),
		(*LispEidTableAddDelMap)(nil),
		(*LispEidTableAddDelMapReply)(nil),
		(*LispEidTableDetails)(nil),
		(*LispEidTableDump)(nil),
		(*LispEidTableMapDetails)(nil),
		(*LispEidTableMapDump)(nil),
		(*LispEidTableVniDetails)(nil),
		(*LispEidTableVniDump)(nil),
		(*LispEnableDisable)(nil),
		(*LispEnableDisableReply)(nil),
		(*LispGetMapRequestItrRlocs)(nil),
		(*LispGetMapRequestItrRlocsReply)(nil),
		(*LispLocatorDetails)(nil),
		(*LispLocatorDump)(nil),
		(*LispLocatorSetDetails)(nil),
		(*LispLocatorSetDump)(nil),
		(*LispMapRegisterEnableDisable)(nil),
		(*LispMapRegisterEnableDisableReply)(nil),
		(*LispMapRequestMode)(nil),
		(*LispMapRequestModeReply)(nil),
		(*LispMapResolverDetails)(nil),
		(*LispMapResolverDump)(nil),
		(*LispMapServerDetails)(nil),
		(*LispMapServerDump)(nil),
		(*LispPitrSetLocatorSet)(nil),
		(*LispPitrSetLocatorSetReply)(nil),
		(*LispRlocProbeEnableDisable)(nil),
		(*LispRlocProbeEnableDisableReply)(nil),
		(*LispUsePetr)(nil),
		(*LispUsePetrReply)(nil),
		(*ShowLispMapRegisterState)(nil),
		(*ShowLispMapRegisterStateReply)(nil),
		(*ShowLispMapRequestMode)(nil),
		(*ShowLispMapRequestModeReply)(nil),
		(*ShowLispPitr)(nil),
		(*ShowLispPitrReply)(nil),
		(*ShowLispRlocProbeState)(nil),
		(*ShowLispRlocProbeStateReply)(nil),
		(*ShowLispStatus)(nil),
		(*ShowLispStatusReply)(nil),
		(*ShowLispUsePetr)(nil),
		(*ShowLispUsePetrReply)(nil),
	}
}