// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: felixbackend.proto

/*
Package proto is a generated protocol buffer package.

It is generated from these files:

	felixbackend.proto

It has these top-level messages:

	SyncRequest
	ToDataplane
	FromDataplane
	ConfigUpdate
	RawConfig
	InSync
	IPSetUpdate
	IPSetDeltaUpdate
	IPSetRemove
	ActiveProfileUpdate
	ActiveProfileRemove
	ProfileID
	Profile
	ActivePolicyUpdate
	ActivePolicyRemove
	PolicyID
	Policy
	Rule
	ServiceAccountMatch
	HTTPMatch
	RuleMetadata
	IcmpTypeAndCode
	Protocol
	PortRange
	WorkloadEndpointID
	WorkloadEndpointUpdate
	WorkloadEndpoint
	WorkloadEndpointRemove
	HostEndpointID
	HostEndpointUpdate
	HostEndpoint
	HostEndpointRemove
	TierInfo
	NatInfo
	ProcessStatusUpdate
	HostEndpointStatusUpdate
	EndpointStatus
	HostEndpointStatusRemove
	WorkloadEndpointStatusUpdate
	WorkloadEndpointStatusRemove
	WireguardStatusUpdate
	DataplaneInSync
	HostMetadataV4V6Update
	HostMetadataV4V6Remove
	HostMetadataUpdate
	HostMetadataRemove
	HostMetadataV6Update
	HostMetadataV6Remove
	IPAMPoolUpdate
	IPAMPoolRemove
	IPAMPool
	Encapsulation
	ServiceAccountUpdate
	ServiceAccountRemove
	ServiceAccountID
	NamespaceUpdate
	NamespaceRemove
	NamespaceID
	TunnelType
	RouteUpdate
	RouteRemove
	VXLANTunnelEndpointUpdate
	VXLANTunnelEndpointRemove
	WireguardEndpointUpdate
	WireguardEndpointRemove
	WireguardEndpointV6Update
	WireguardEndpointV6Remove
	GlobalBGPConfigUpdate
	ServicePort
	ServiceUpdate
	ServiceRemove
*/
package proto

import (
	fmt "fmt"

	proto1 "github.com/gogo/protobuf/proto"

	math "math"

	context "golang.org/x/net/context"

	grpc "google.golang.org/grpc"

	binary "encoding/binary"

	io "io"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto1.Marshal
var _ = fmt.Errorf
var _ = math.Inf

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

type IPVersion int32

const (
	IPVersion_ANY  IPVersion = 0
	IPVersion_IPV4 IPVersion = 4
	IPVersion_IPV6 IPVersion = 6
)

var IPVersion_name = map[int32]string{
	0: "ANY",
	4: "IPV4",
	6: "IPV6",
}
var IPVersion_value = map[string]int32{
	"ANY":  0,
	"IPV4": 4,
	"IPV6": 6,
}

func (x IPVersion) String() string {
	return proto1.EnumName(IPVersion_name, int32(x))
}
func (IPVersion) EnumDescriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{0} }

type RouteType int32

const (
	// CIDR_INFO gives information about a CIDR without establishing a route.  For example,
	// it is emitted for IP pools with no blocks.
	RouteType_CIDR_INFO       RouteType = 0
	RouteType_REMOTE_WORKLOAD RouteType = 1
	RouteType_REMOTE_HOST     RouteType = 2
	RouteType_LOCAL_WORKLOAD  RouteType = 3
	RouteType_LOCAL_HOST      RouteType = 4
	RouteType_REMOTE_TUNNEL   RouteType = 5
	RouteType_LOCAL_TUNNEL    RouteType = 6
)

var RouteType_name = map[int32]string{
	0: "CIDR_INFO",
	1: "REMOTE_WORKLOAD",
	2: "REMOTE_HOST",
	3: "LOCAL_WORKLOAD",
	4: "LOCAL_HOST",
	5: "REMOTE_TUNNEL",
	6: "LOCAL_TUNNEL",
}
var RouteType_value = map[string]int32{
	"CIDR_INFO":       0,
	"REMOTE_WORKLOAD": 1,
	"REMOTE_HOST":     2,
	"LOCAL_WORKLOAD":  3,
	"LOCAL_HOST":      4,
	"REMOTE_TUNNEL":   5,
	"LOCAL_TUNNEL":    6,
}

func (x RouteType) String() string {
	return proto1.EnumName(RouteType_name, int32(x))
}
func (RouteType) EnumDescriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{1} }

type IPPoolType int32

const (
	IPPoolType_NONE     IPPoolType = 0
	IPPoolType_NO_ENCAP IPPoolType = 1
	IPPoolType_VXLAN    IPPoolType = 2
	IPPoolType_IPIP     IPPoolType = 3
)

var IPPoolType_name = map[int32]string{
	0: "NONE",
	1: "NO_ENCAP",
	2: "VXLAN",
	3: "IPIP",
}
var IPPoolType_value = map[string]int32{
	"NONE":     0,
	"NO_ENCAP": 1,
	"VXLAN":    2,
	"IPIP":     3,
}

func (x IPPoolType) String() string {
	return proto1.EnumName(IPPoolType_name, int32(x))
}
func (IPPoolType) EnumDescriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{2} }

type IPSetUpdate_IPSetType int32

const (
	IPSetUpdate_IP          IPSetUpdate_IPSetType = 0
	IPSetUpdate_IP_AND_PORT IPSetUpdate_IPSetType = 1
	IPSetUpdate_NET         IPSetUpdate_IPSetType = 2
)

var IPSetUpdate_IPSetType_name = map[int32]string{
	0: "IP",
	1: "IP_AND_PORT",
	2: "NET",
}
var IPSetUpdate_IPSetType_value = map[string]int32{
	"IP":          0,
	"IP_AND_PORT": 1,
	"NET":         2,
}

func (x IPSetUpdate_IPSetType) String() string {
	return proto1.EnumName(IPSetUpdate_IPSetType_name, int32(x))
}
func (IPSetUpdate_IPSetType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptorFelixbackend, []int{6, 0}
}

type SyncRequest struct {
}

func (m *SyncRequest) Reset()                    { *m = SyncRequest{} }
func (m *SyncRequest) String() string            { return proto1.CompactTextString(m) }
func (*SyncRequest) ProtoMessage()               {}
func (*SyncRequest) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{0} }

type ToDataplane struct {
	// Sequence number incremented with each message.  Useful for correlating
	// messages in logs.
	SequenceNumber uint64 `protobuf:"varint,15,opt,name=sequence_number,json=sequenceNumber,proto3" json:"sequence_number,omitempty"`
	// Types that are valid to be assigned to Payload:
	//	*ToDataplane_InSync
	//	*ToDataplane_IpsetUpdate
	//	*ToDataplane_IpsetDeltaUpdate
	//	*ToDataplane_IpsetRemove
	//	*ToDataplane_ActiveProfileUpdate
	//	*ToDataplane_ActiveProfileRemove
	//	*ToDataplane_ActivePolicyUpdate
	//	*ToDataplane_ActivePolicyRemove
	//	*ToDataplane_HostEndpointUpdate
	//	*ToDataplane_HostEndpointRemove
	//	*ToDataplane_WorkloadEndpointUpdate
	//	*ToDataplane_WorkloadEndpointRemove
	//	*ToDataplane_ConfigUpdate
	//	*ToDataplane_HostMetadataUpdate
	//	*ToDataplane_HostMetadataRemove
	//	*ToDataplane_HostMetadataV4V6Update
	//	*ToDataplane_HostMetadataV4V6Remove
	//	*ToDataplane_IpamPoolUpdate
	//	*ToDataplane_IpamPoolRemove
	//	*ToDataplane_ServiceAccountUpdate
	//	*ToDataplane_ServiceAccountRemove
	//	*ToDataplane_NamespaceUpdate
	//	*ToDataplane_NamespaceRemove
	//	*ToDataplane_RouteUpdate
	//	*ToDataplane_RouteRemove
	//	*ToDataplane_VtepUpdate
	//	*ToDataplane_VtepRemove
	//	*ToDataplane_WireguardEndpointUpdate
	//	*ToDataplane_WireguardEndpointRemove
	//	*ToDataplane_GlobalBgpConfigUpdate
	//	*ToDataplane_Encapsulation
	//	*ToDataplane_ServiceUpdate
	//	*ToDataplane_ServiceRemove
	//	*ToDataplane_WireguardEndpointV6Update
	//	*ToDataplane_WireguardEndpointV6Remove
	//	*ToDataplane_HostMetadataV6Update
	//	*ToDataplane_HostMetadataV6Remove
	Payload isToDataplane_Payload `protobuf_oneof:"payload"`
}

func (m *ToDataplane) Reset()                    { *m = ToDataplane{} }
func (m *ToDataplane) String() string            { return proto1.CompactTextString(m) }
func (*ToDataplane) ProtoMessage()               {}
func (*ToDataplane) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{1} }

type isToDataplane_Payload interface {
	isToDataplane_Payload()
	MarshalTo([]byte) (int, error)
	Size() int
}

type ToDataplane_InSync struct {
	InSync *InSync `protobuf:"bytes,1,opt,name=in_sync,json=inSync,oneof"`
}
type ToDataplane_IpsetUpdate struct {
	IpsetUpdate *IPSetUpdate `protobuf:"bytes,2,opt,name=ipset_update,json=ipsetUpdate,oneof"`
}
type ToDataplane_IpsetDeltaUpdate struct {
	IpsetDeltaUpdate *IPSetDeltaUpdate `protobuf:"bytes,3,opt,name=ipset_delta_update,json=ipsetDeltaUpdate,oneof"`
}
type ToDataplane_IpsetRemove struct {
	IpsetRemove *IPSetRemove `protobuf:"bytes,4,opt,name=ipset_remove,json=ipsetRemove,oneof"`
}
type ToDataplane_ActiveProfileUpdate struct {
	ActiveProfileUpdate *ActiveProfileUpdate `protobuf:"bytes,5,opt,name=active_profile_update,json=activeProfileUpdate,oneof"`
}
type ToDataplane_ActiveProfileRemove struct {
	ActiveProfileRemove *ActiveProfileRemove `protobuf:"bytes,6,opt,name=active_profile_remove,json=activeProfileRemove,oneof"`
}
type ToDataplane_ActivePolicyUpdate struct {
	ActivePolicyUpdate *ActivePolicyUpdate `protobuf:"bytes,7,opt,name=active_policy_update,json=activePolicyUpdate,oneof"`
}
type ToDataplane_ActivePolicyRemove struct {
	ActivePolicyRemove *ActivePolicyRemove `protobuf:"bytes,8,opt,name=active_policy_remove,json=activePolicyRemove,oneof"`
}
type ToDataplane_HostEndpointUpdate struct {
	HostEndpointUpdate *HostEndpointUpdate `protobuf:"bytes,9,opt,name=host_endpoint_update,json=hostEndpointUpdate,oneof"`
}
type ToDataplane_HostEndpointRemove struct {
	HostEndpointRemove *HostEndpointRemove `protobuf:"bytes,10,opt,name=host_endpoint_remove,json=hostEndpointRemove,oneof"`
}
type ToDataplane_WorkloadEndpointUpdate struct {
	WorkloadEndpointUpdate *WorkloadEndpointUpdate `protobuf:"bytes,11,opt,name=workload_endpoint_update,json=workloadEndpointUpdate,oneof"`
}
type ToDataplane_WorkloadEndpointRemove struct {
	WorkloadEndpointRemove *WorkloadEndpointRemove `protobuf:"bytes,12,opt,name=workload_endpoint_remove,json=workloadEndpointRemove,oneof"`
}
type ToDataplane_ConfigUpdate struct {
	ConfigUpdate *ConfigUpdate `protobuf:"bytes,13,opt,name=config_update,json=configUpdate,oneof"`
}
type ToDataplane_HostMetadataUpdate struct {
	HostMetadataUpdate *HostMetadataUpdate `protobuf:"bytes,14,opt,name=host_metadata_update,json=hostMetadataUpdate,oneof"`
}
type ToDataplane_HostMetadataRemove struct {
	HostMetadataRemove *HostMetadataRemove `protobuf:"bytes,18,opt,name=host_metadata_remove,json=hostMetadataRemove,oneof"`
}
type ToDataplane_HostMetadataV4V6Update struct {
	HostMetadataV4V6Update *HostMetadataV4V6Update `protobuf:"bytes,37,opt,name=host_metadata_v4v6_update,json=hostMetadataV4v6Update,oneof"`
}
type ToDataplane_HostMetadataV4V6Remove struct {
	HostMetadataV4V6Remove *HostMetadataV4V6Remove `protobuf:"bytes,38,opt,name=host_metadata_v4v6_remove,json=hostMetadataV4v6Remove,oneof"`
}
type ToDataplane_IpamPoolUpdate struct {
	IpamPoolUpdate *IPAMPoolUpdate `protobuf:"bytes,16,opt,name=ipam_pool_update,json=ipamPoolUpdate,oneof"`
}
type ToDataplane_IpamPoolRemove struct {
	IpamPoolRemove *IPAMPoolRemove `protobuf:"bytes,17,opt,name=ipam_pool_remove,json=ipamPoolRemove,oneof"`
}
type ToDataplane_ServiceAccountUpdate struct {
	ServiceAccountUpdate *ServiceAccountUpdate `protobuf:"bytes,19,opt,name=service_account_update,json=serviceAccountUpdate,oneof"`
}
type ToDataplane_ServiceAccountRemove struct {
	ServiceAccountRemove *ServiceAccountRemove `protobuf:"bytes,20,opt,name=service_account_remove,json=serviceAccountRemove,oneof"`
}
type ToDataplane_NamespaceUpdate struct {
	NamespaceUpdate *NamespaceUpdate `protobuf:"bytes,21,opt,name=namespace_update,json=namespaceUpdate,oneof"`
}
type ToDataplane_NamespaceRemove struct {
	NamespaceRemove *NamespaceRemove `protobuf:"bytes,22,opt,name=namespace_remove,json=namespaceRemove,oneof"`
}
type ToDataplane_RouteUpdate struct {
	RouteUpdate *RouteUpdate `protobuf:"bytes,23,opt,name=route_update,json=routeUpdate,oneof"`
}
type ToDataplane_RouteRemove struct {
	RouteRemove *RouteRemove `protobuf:"bytes,24,opt,name=route_remove,json=routeRemove,oneof"`
}
type ToDataplane_VtepUpdate struct {
	VtepUpdate *VXLANTunnelEndpointUpdate `protobuf:"bytes,25,opt,name=vtep_update,json=vtepUpdate,oneof"`
}
type ToDataplane_VtepRemove struct {
	VtepRemove *VXLANTunnelEndpointRemove `protobuf:"bytes,26,opt,name=vtep_remove,json=vtepRemove,oneof"`
}
type ToDataplane_WireguardEndpointUpdate struct {
	WireguardEndpointUpdate *WireguardEndpointUpdate `protobuf:"bytes,27,opt,name=wireguard_endpoint_update,json=wireguardEndpointUpdate,oneof"`
}
type ToDataplane_WireguardEndpointRemove struct {
	WireguardEndpointRemove *WireguardEndpointRemove `protobuf:"bytes,28,opt,name=wireguard_endpoint_remove,json=wireguardEndpointRemove,oneof"`
}
type ToDataplane_GlobalBgpConfigUpdate struct {
	GlobalBgpConfigUpdate *GlobalBGPConfigUpdate `protobuf:"bytes,29,opt,name=global_bgp_config_update,json=globalBgpConfigUpdate,oneof"`
}
type ToDataplane_Encapsulation struct {
	Encapsulation *Encapsulation `protobuf:"bytes,30,opt,name=encapsulation,oneof"`
}
type ToDataplane_ServiceUpdate struct {
	ServiceUpdate *ServiceUpdate `protobuf:"bytes,31,opt,name=service_update,json=serviceUpdate,oneof"`
}
type ToDataplane_ServiceRemove struct {
	ServiceRemove *ServiceRemove `protobuf:"bytes,32,opt,name=service_remove,json=serviceRemove,oneof"`
}
type ToDataplane_WireguardEndpointV6Update struct {
	WireguardEndpointV6Update *WireguardEndpointV6Update `protobuf:"bytes,33,opt,name=wireguard_endpoint_v6_update,json=wireguardEndpointV6Update,oneof"`
}
type ToDataplane_WireguardEndpointV6Remove struct {
	WireguardEndpointV6Remove *WireguardEndpointV6Remove `protobuf:"bytes,34,opt,name=wireguard_endpoint_v6_remove,json=wireguardEndpointV6Remove,oneof"`
}
type ToDataplane_HostMetadataV6Update struct {
	HostMetadataV6Update *HostMetadataV6Update `protobuf:"bytes,35,opt,name=host_metadata_v6_update,json=hostMetadataV6Update,oneof"`
}
type ToDataplane_HostMetadataV6Remove struct {
	HostMetadataV6Remove *HostMetadataV6Remove `protobuf:"bytes,36,opt,name=host_metadata_v6_remove,json=hostMetadataV6Remove,oneof"`
}

func (*ToDataplane_InSync) isToDataplane_Payload()                    {}
func (*ToDataplane_IpsetUpdate) isToDataplane_Payload()               {}
func (*ToDataplane_IpsetDeltaUpdate) isToDataplane_Payload()          {}
func (*ToDataplane_IpsetRemove) isToDataplane_Payload()               {}
func (*ToDataplane_ActiveProfileUpdate) isToDataplane_Payload()       {}
func (*ToDataplane_ActiveProfileRemove) isToDataplane_Payload()       {}
func (*ToDataplane_ActivePolicyUpdate) isToDataplane_Payload()        {}
func (*ToDataplane_ActivePolicyRemove) isToDataplane_Payload()        {}
func (*ToDataplane_HostEndpointUpdate) isToDataplane_Payload()        {}
func (*ToDataplane_HostEndpointRemove) isToDataplane_Payload()        {}
func (*ToDataplane_WorkloadEndpointUpdate) isToDataplane_Payload()    {}
func (*ToDataplane_WorkloadEndpointRemove) isToDataplane_Payload()    {}
func (*ToDataplane_ConfigUpdate) isToDataplane_Payload()              {}
func (*ToDataplane_HostMetadataUpdate) isToDataplane_Payload()        {}
func (*ToDataplane_HostMetadataRemove) isToDataplane_Payload()        {}
func (*ToDataplane_HostMetadataV4V6Update) isToDataplane_Payload()    {}
func (*ToDataplane_HostMetadataV4V6Remove) isToDataplane_Payload()    {}
func (*ToDataplane_IpamPoolUpdate) isToDataplane_Payload()            {}
func (*ToDataplane_IpamPoolRemove) isToDataplane_Payload()            {}
func (*ToDataplane_ServiceAccountUpdate) isToDataplane_Payload()      {}
func (*ToDataplane_ServiceAccountRemove) isToDataplane_Payload()      {}
func (*ToDataplane_NamespaceUpdate) isToDataplane_Payload()           {}
func (*ToDataplane_NamespaceRemove) isToDataplane_Payload()           {}
func (*ToDataplane_RouteUpdate) isToDataplane_Payload()               {}
func (*ToDataplane_RouteRemove) isToDataplane_Payload()               {}
func (*ToDataplane_VtepUpdate) isToDataplane_Payload()                {}
func (*ToDataplane_VtepRemove) isToDataplane_Payload()                {}
func (*ToDataplane_WireguardEndpointUpdate) isToDataplane_Payload()   {}
func (*ToDataplane_WireguardEndpointRemove) isToDataplane_Payload()   {}
func (*ToDataplane_GlobalBgpConfigUpdate) isToDataplane_Payload()     {}
func (*ToDataplane_Encapsulation) isToDataplane_Payload()             {}
func (*ToDataplane_ServiceUpdate) isToDataplane_Payload()             {}
func (*ToDataplane_ServiceRemove) isToDataplane_Payload()             {}
func (*ToDataplane_WireguardEndpointV6Update) isToDataplane_Payload() {}
func (*ToDataplane_WireguardEndpointV6Remove) isToDataplane_Payload() {}
func (*ToDataplane_HostMetadataV6Update) isToDataplane_Payload()      {}
func (*ToDataplane_HostMetadataV6Remove) isToDataplane_Payload()      {}

func (m *ToDataplane) GetPayload() isToDataplane_Payload {
	if m != nil {
		return m.Payload
	}
	return nil
}

func (m *ToDataplane) GetSequenceNumber() uint64 {
	if m != nil {
		return m.SequenceNumber
	}
	return 0
}

func (m *ToDataplane) GetInSync() *InSync {
	if x, ok := m.GetPayload().(*ToDataplane_InSync); ok {
		return x.InSync
	}
	return nil
}

func (m *ToDataplane) GetIpsetUpdate() *IPSetUpdate {
	if x, ok := m.GetPayload().(*ToDataplane_IpsetUpdate); ok {
		return x.IpsetUpdate
	}
	return nil
}

func (m *ToDataplane) GetIpsetDeltaUpdate() *IPSetDeltaUpdate {
	if x, ok := m.GetPayload().(*ToDataplane_IpsetDeltaUpdate); ok {
		return x.IpsetDeltaUpdate
	}
	return nil
}

func (m *ToDataplane) GetIpsetRemove() *IPSetRemove {
	if x, ok := m.GetPayload().(*ToDataplane_IpsetRemove); ok {
		return x.IpsetRemove
	}
	return nil
}

func (m *ToDataplane) GetActiveProfileUpdate() *ActiveProfileUpdate {
	if x, ok := m.GetPayload().(*ToDataplane_ActiveProfileUpdate); ok {
		return x.ActiveProfileUpdate
	}
	return nil
}

func (m *ToDataplane) GetActiveProfileRemove() *ActiveProfileRemove {
	if x, ok := m.GetPayload().(*ToDataplane_ActiveProfileRemove); ok {
		return x.ActiveProfileRemove
	}
	return nil
}

func (m *ToDataplane) GetActivePolicyUpdate() *ActivePolicyUpdate {
	if x, ok := m.GetPayload().(*ToDataplane_ActivePolicyUpdate); ok {
		return x.ActivePolicyUpdate
	}
	return nil
}

func (m *ToDataplane) GetActivePolicyRemove() *ActivePolicyRemove {
	if x, ok := m.GetPayload().(*ToDataplane_ActivePolicyRemove); ok {
		return x.ActivePolicyRemove
	}
	return nil
}

func (m *ToDataplane) GetHostEndpointUpdate() *HostEndpointUpdate {
	if x, ok := m.GetPayload().(*ToDataplane_HostEndpointUpdate); ok {
		return x.HostEndpointUpdate
	}
	return nil
}

func (m *ToDataplane) GetHostEndpointRemove() *HostEndpointRemove {
	if x, ok := m.GetPayload().(*ToDataplane_HostEndpointRemove); ok {
		return x.HostEndpointRemove
	}
	return nil
}

func (m *ToDataplane) GetWorkloadEndpointUpdate() *WorkloadEndpointUpdate {
	if x, ok := m.GetPayload().(*ToDataplane_WorkloadEndpointUpdate); ok {
		return x.WorkloadEndpointUpdate
	}
	return nil
}

func (m *ToDataplane) GetWorkloadEndpointRemove() *WorkloadEndpointRemove {
	if x, ok := m.GetPayload().(*ToDataplane_WorkloadEndpointRemove); ok {
		return x.WorkloadEndpointRemove
	}
	return nil
}

func (m *ToDataplane) GetConfigUpdate() *ConfigUpdate {
	if x, ok := m.GetPayload().(*ToDataplane_ConfigUpdate); ok {
		return x.ConfigUpdate
	}
	return nil
}

func (m *ToDataplane) GetHostMetadataUpdate() *HostMetadataUpdate {
	if x, ok := m.GetPayload().(*ToDataplane_HostMetadataUpdate); ok {
		return x.HostMetadataUpdate
	}
	return nil
}

func (m *ToDataplane) GetHostMetadataRemove() *HostMetadataRemove {
	if x, ok := m.GetPayload().(*ToDataplane_HostMetadataRemove); ok {
		return x.HostMetadataRemove
	}
	return nil
}

func (m *ToDataplane) GetHostMetadataV4V6Update() *HostMetadataV4V6Update {
	if x, ok := m.GetPayload().(*ToDataplane_HostMetadataV4V6Update); ok {
		return x.HostMetadataV4V6Update
	}
	return nil
}

func (m *ToDataplane) GetHostMetadataV4V6Remove() *HostMetadataV4V6Remove {
	if x, ok := m.GetPayload().(*ToDataplane_HostMetadataV4V6Remove); ok {
		return x.HostMetadataV4V6Remove
	}
	return nil
}

func (m *ToDataplane) GetIpamPoolUpdate() *IPAMPoolUpdate {
	if x, ok := m.GetPayload().(*ToDataplane_IpamPoolUpdate); ok {
		return x.IpamPoolUpdate
	}
	return nil
}

func (m *ToDataplane) GetIpamPoolRemove() *IPAMPoolRemove {
	if x, ok := m.GetPayload().(*ToDataplane_IpamPoolRemove); ok {
		return x.IpamPoolRemove
	}
	return nil
}

func (m *ToDataplane) GetServiceAccountUpdate() *ServiceAccountUpdate {
	if x, ok := m.GetPayload().(*ToDataplane_ServiceAccountUpdate); ok {
		return x.ServiceAccountUpdate
	}
	return nil
}

func (m *ToDataplane) GetServiceAccountRemove() *ServiceAccountRemove {
	if x, ok := m.GetPayload().(*ToDataplane_ServiceAccountRemove); ok {
		return x.ServiceAccountRemove
	}
	return nil
}

func (m *ToDataplane) GetNamespaceUpdate() *NamespaceUpdate {
	if x, ok := m.GetPayload().(*ToDataplane_NamespaceUpdate); ok {
		return x.NamespaceUpdate
	}
	return nil
}

func (m *ToDataplane) GetNamespaceRemove() *NamespaceRemove {
	if x, ok := m.GetPayload().(*ToDataplane_NamespaceRemove); ok {
		return x.NamespaceRemove
	}
	return nil
}

func (m *ToDataplane) GetRouteUpdate() *RouteUpdate {
	if x, ok := m.GetPayload().(*ToDataplane_RouteUpdate); ok {
		return x.RouteUpdate
	}
	return nil
}

func (m *ToDataplane) GetRouteRemove() *RouteRemove {
	if x, ok := m.GetPayload().(*ToDataplane_RouteRemove); ok {
		return x.RouteRemove
	}
	return nil
}

func (m *ToDataplane) GetVtepUpdate() *VXLANTunnelEndpointUpdate {
	if x, ok := m.GetPayload().(*ToDataplane_VtepUpdate); ok {
		return x.VtepUpdate
	}
	return nil
}

func (m *ToDataplane) GetVtepRemove() *VXLANTunnelEndpointRemove {
	if x, ok := m.GetPayload().(*ToDataplane_VtepRemove); ok {
		return x.VtepRemove
	}
	return nil
}

func (m *ToDataplane) GetWireguardEndpointUpdate() *WireguardEndpointUpdate {
	if x, ok := m.GetPayload().(*ToDataplane_WireguardEndpointUpdate); ok {
		return x.WireguardEndpointUpdate
	}
	return nil
}

func (m *ToDataplane) GetWireguardEndpointRemove() *WireguardEndpointRemove {
	if x, ok := m.GetPayload().(*ToDataplane_WireguardEndpointRemove); ok {
		return x.WireguardEndpointRemove
	}
	return nil
}

func (m *ToDataplane) GetGlobalBgpConfigUpdate() *GlobalBGPConfigUpdate {
	if x, ok := m.GetPayload().(*ToDataplane_GlobalBgpConfigUpdate); ok {
		return x.GlobalBgpConfigUpdate
	}
	return nil
}

func (m *ToDataplane) GetEncapsulation() *Encapsulation {
	if x, ok := m.GetPayload().(*ToDataplane_Encapsulation); ok {
		return x.Encapsulation
	}
	return nil
}

func (m *ToDataplane) GetServiceUpdate() *ServiceUpdate {
	if x, ok := m.GetPayload().(*ToDataplane_ServiceUpdate); ok {
		return x.ServiceUpdate
	}
	return nil
}

func (m *ToDataplane) GetServiceRemove() *ServiceRemove {
	if x, ok := m.GetPayload().(*ToDataplane_ServiceRemove); ok {
		return x.ServiceRemove
	}
	return nil
}

func (m *ToDataplane) GetWireguardEndpointV6Update() *WireguardEndpointV6Update {
	if x, ok := m.GetPayload().(*ToDataplane_WireguardEndpointV6Update); ok {
		return x.WireguardEndpointV6Update
	}
	return nil
}

func (m *ToDataplane) GetWireguardEndpointV6Remove() *WireguardEndpointV6Remove {
	if x, ok := m.GetPayload().(*ToDataplane_WireguardEndpointV6Remove); ok {
		return x.WireguardEndpointV6Remove
	}
	return nil
}

func (m *ToDataplane) GetHostMetadataV6Update() *HostMetadataV6Update {
	if x, ok := m.GetPayload().(*ToDataplane_HostMetadataV6Update); ok {
		return x.HostMetadataV6Update
	}
	return nil
}

func (m *ToDataplane) GetHostMetadataV6Remove() *HostMetadataV6Remove {
	if x, ok := m.GetPayload().(*ToDataplane_HostMetadataV6Remove); ok {
		return x.HostMetadataV6Remove
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*ToDataplane) XXX_OneofFuncs() (func(msg proto1.Message, b *proto1.Buffer) error, func(msg proto1.Message, tag, wire int, b *proto1.Buffer) (bool, error), func(msg proto1.Message) (n int), []interface{}) {
	return _ToDataplane_OneofMarshaler, _ToDataplane_OneofUnmarshaler, _ToDataplane_OneofSizer, []interface{}{
		(*ToDataplane_InSync)(nil),
		(*ToDataplane_IpsetUpdate)(nil),
		(*ToDataplane_IpsetDeltaUpdate)(nil),
		(*ToDataplane_IpsetRemove)(nil),
		(*ToDataplane_ActiveProfileUpdate)(nil),
		(*ToDataplane_ActiveProfileRemove)(nil),
		(*ToDataplane_ActivePolicyUpdate)(nil),
		(*ToDataplane_ActivePolicyRemove)(nil),
		(*ToDataplane_HostEndpointUpdate)(nil),
		(*ToDataplane_HostEndpointRemove)(nil),
		(*ToDataplane_WorkloadEndpointUpdate)(nil),
		(*ToDataplane_WorkloadEndpointRemove)(nil),
		(*ToDataplane_ConfigUpdate)(nil),
		(*ToDataplane_HostMetadataUpdate)(nil),
		(*ToDataplane_HostMetadataRemove)(nil),
		(*ToDataplane_HostMetadataV4V6Update)(nil),
		(*ToDataplane_HostMetadataV4V6Remove)(nil),
		(*ToDataplane_IpamPoolUpdate)(nil),
		(*ToDataplane_IpamPoolRemove)(nil),
		(*ToDataplane_ServiceAccountUpdate)(nil),
		(*ToDataplane_ServiceAccountRemove)(nil),
		(*ToDataplane_NamespaceUpdate)(nil),
		(*ToDataplane_NamespaceRemove)(nil),
		(*ToDataplane_RouteUpdate)(nil),
		(*ToDataplane_RouteRemove)(nil),
		(*ToDataplane_VtepUpdate)(nil),
		(*ToDataplane_VtepRemove)(nil),
		(*ToDataplane_WireguardEndpointUpdate)(nil),
		(*ToDataplane_WireguardEndpointRemove)(nil),
		(*ToDataplane_GlobalBgpConfigUpdate)(nil),
		(*ToDataplane_Encapsulation)(nil),
		(*ToDataplane_ServiceUpdate)(nil),
		(*ToDataplane_ServiceRemove)(nil),
		(*ToDataplane_WireguardEndpointV6Update)(nil),
		(*ToDataplane_WireguardEndpointV6Remove)(nil),
		(*ToDataplane_HostMetadataV6Update)(nil),
		(*ToDataplane_HostMetadataV6Remove)(nil),
	}
}

func _ToDataplane_OneofMarshaler(msg proto1.Message, b *proto1.Buffer) error {
	m := msg.(*ToDataplane)
	// payload
	switch x := m.Payload.(type) {
	case *ToDataplane_InSync:
		_ = b.EncodeVarint(1<<3 | proto1.WireBytes)
		if err := b.EncodeMessage(x.InSync); err != nil {
			return err
		}
	case *ToDataplane_IpsetUpdate:
		_ = b.EncodeVarint(2<<3 | proto1.WireBytes)
		if err := b.EncodeMessage(x.IpsetUpdate); err != nil {
			return err
		}
	case *ToDataplane_IpsetDeltaUpdate:
		_ = b.EncodeVarint(3<<3 | proto1.WireBytes)
		if err := b.EncodeMessage(x.IpsetDeltaUpdate); err != nil {
			return err
		}
	case *ToDataplane_IpsetRemove:
		_ = b.EncodeVarint(4<<3 | proto1.WireBytes)
		if err := b.EncodeMessage(x.IpsetRemove); err != nil {
			return err
		}
	case *ToDataplane_ActiveProfileUpdate:
		_ = b.EncodeVarint(5<<3 | proto1.WireBytes)
		if err := b.EncodeMessage(x.ActiveProfileUpdate); err != nil {
			return err
		}
	case *ToDataplane_ActiveProfileRemove:
		_ = b.EncodeVarint(6<<3 | proto1.WireBytes)
		if err := b.EncodeMessage(x.ActiveProfileRemove); err != nil {
			return err
		}
	case *ToDataplane_ActivePolicyUpdate:
		_ = b.EncodeVarint(7<<3 | proto1.WireBytes)
		if err := b.EncodeMessage(x.ActivePolicyUpdate); err != nil {
			return err
		}
	case *ToDataplane_ActivePolicyRemove:
		_ = b.EncodeVarint(8<<3 | proto1.WireBytes)
		if err := b.EncodeMessage(x.ActivePolicyRemove); err != nil {
			return err
		}
	case *ToDataplane_HostEndpointUpdate:
		_ = b.EncodeVarint(9<<3 | proto1.WireBytes)
		if err := b.EncodeMessage(x.HostEndpointUpdate); err != nil {
			return err
		}
	case *ToDataplane_HostEndpointRemove:
		_ = b.EncodeVarint(10<<3 | proto1.WireBytes)
		if err := b.EncodeMessage(x.HostEndpointRemove); err != nil {
			return err
		}
	case *ToDataplane_WorkloadEndpointUpdate:
		_ = b.EncodeVarint(11<<3 | proto1.WireBytes)
		if err := b.EncodeMessage(x.WorkloadEndpointUpdate); err != nil {
			return err
		}
	case *ToDataplane_WorkloadEndpointRemove:
		_ = b.EncodeVarint(12<<3 | proto1.WireBytes)
		if err := b.EncodeMessage(x.WorkloadEndpointRemove); err != nil {
			return err
		}
	case *ToDataplane_ConfigUpdate:
		_ = b.EncodeVarint(13<<3 | proto1.WireBytes)
		if err := b.EncodeMessage(x.ConfigUpdate); err != nil {
			return err
		}
	case *ToDataplane_HostMetadataUpdate:
		_ = b.EncodeVarint(14<<3 | proto1.WireBytes)
		if err := b.EncodeMessage(x.HostMetadataUpdate); err != nil {
			return err
		}
	case *ToDataplane_HostMetadataRemove:
		_ = b.EncodeVarint(18<<3 | proto1.WireBytes)
		if err := b.EncodeMessage(x.HostMetadataRemove); err != nil {
			return err
		}
	case *ToDataplane_HostMetadataV4V6Update:
		_ = b.EncodeVarint(37<<3 | proto1.WireBytes)
		if err := b.EncodeMessage(x.HostMetadataV4V6Update); err != nil {
			return err
		}
	case *ToDataplane_HostMetadataV4V6Remove:
		_ = b.EncodeVarint(38<<3 | proto1.WireBytes)
		if err := b.EncodeMessage(x.HostMetadataV4V6Remove); err != nil {
			return err
		}
	case *ToDataplane_IpamPoolUpdate:
		_ = b.EncodeVarint(16<<3 | proto1.WireBytes)
		if err := b.EncodeMessage(x.IpamPoolUpdate); err != nil {
			return err
		}
	case *ToDataplane_IpamPoolRemove:
		_ = b.EncodeVarint(17<<3 | proto1.WireBytes)
		if err := b.EncodeMessage(x.IpamPoolRemove); err != nil {
			return err
		}
	case *ToDataplane_ServiceAccountUpdate:
		_ = b.EncodeVarint(19<<3 | proto1.WireBytes)
		if err := b.EncodeMessage(x.ServiceAccountUpdate); err != nil {
			return err
		}
	case *ToDataplane_ServiceAccountRemove:
		_ = b.EncodeVarint(20<<3 | proto1.WireBytes)
		if err := b.EncodeMessage(x.ServiceAccountRemove); err != nil {
			return err
		}
	case *ToDataplane_NamespaceUpdate:
		_ = b.EncodeVarint(21<<3 | proto1.WireBytes)
		if err := b.EncodeMessage(x.NamespaceUpdate); err != nil {
			return err
		}
	case *ToDataplane_NamespaceRemove:
		_ = b.EncodeVarint(22<<3 | proto1.WireBytes)
		if err := b.EncodeMessage(x.NamespaceRemove); err != nil {
			return err
		}
	case *ToDataplane_RouteUpdate:
		_ = b.EncodeVarint(23<<3 | proto1.WireBytes)
		if err := b.EncodeMessage(x.RouteUpdate); err != nil {
			return err
		}
	case *ToDataplane_RouteRemove:
		_ = b.EncodeVarint(24<<3 | proto1.WireBytes)
		if err := b.EncodeMessage(x.RouteRemove); err != nil {
			return err
		}
	case *ToDataplane_VtepUpdate:
		_ = b.EncodeVarint(25<<3 | proto1.WireBytes)
		if err := b.EncodeMessage(x.VtepUpdate); err != nil {
			return err
		}
	case *ToDataplane_VtepRemove:
		_ = b.EncodeVarint(26<<3 | proto1.WireBytes)
		if err := b.EncodeMessage(x.VtepRemove); err != nil {
			return err
		}
	case *ToDataplane_WireguardEndpointUpdate:
		_ = b.EncodeVarint(27<<3 | proto1.WireBytes)
		if err := b.EncodeMessage(x.WireguardEndpointUpdate); err != nil {
			return err
		}
	case *ToDataplane_WireguardEndpointRemove:
		_ = b.EncodeVarint(28<<3 | proto1.WireBytes)
		if err := b.EncodeMessage(x.WireguardEndpointRemove); err != nil {
			return err
		}
	case *ToDataplane_GlobalBgpConfigUpdate:
		_ = b.EncodeVarint(29<<3 | proto1.WireBytes)
		if err := b.EncodeMessage(x.GlobalBgpConfigUpdate); err != nil {
			return err
		}
	case *ToDataplane_Encapsulation:
		_ = b.EncodeVarint(30<<3 | proto1.WireBytes)
		if err := b.EncodeMessage(x.Encapsulation); err != nil {
			return err
		}
	case *ToDataplane_ServiceUpdate:
		_ = b.EncodeVarint(31<<3 | proto1.WireBytes)
		if err := b.EncodeMessage(x.ServiceUpdate); err != nil {
			return err
		}
	case *ToDataplane_ServiceRemove:
		_ = b.EncodeVarint(32<<3 | proto1.WireBytes)
		if err := b.EncodeMessage(x.ServiceRemove); err != nil {
			return err
		}
	case *ToDataplane_WireguardEndpointV6Update:
		_ = b.EncodeVarint(33<<3 | proto1.WireBytes)
		if err := b.EncodeMessage(x.WireguardEndpointV6Update); err != nil {
			return err
		}
	case *ToDataplane_WireguardEndpointV6Remove:
		_ = b.EncodeVarint(34<<3 | proto1.WireBytes)
		if err := b.EncodeMessage(x.WireguardEndpointV6Remove); err != nil {
			return err
		}
	case *ToDataplane_HostMetadataV6Update:
		_ = b.EncodeVarint(35<<3 | proto1.WireBytes)
		if err := b.EncodeMessage(x.HostMetadataV6Update); err != nil {
			return err
		}
	case *ToDataplane_HostMetadataV6Remove:
		_ = b.EncodeVarint(36<<3 | proto1.WireBytes)
		if err := b.EncodeMessage(x.HostMetadataV6Remove); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("ToDataplane.Payload has unexpected type %T", x)
	}
	return nil
}

func _ToDataplane_OneofUnmarshaler(msg proto1.Message, tag, wire int, b *proto1.Buffer) (bool, error) {
	m := msg.(*ToDataplane)
	switch tag {
	case 1: // payload.in_sync
		if wire != proto1.WireBytes {
			return true, proto1.ErrInternalBadWireType
		}
		msg := new(InSync)
		err := b.DecodeMessage(msg)
		m.Payload = &ToDataplane_InSync{msg}
		return true, err
	case 2: // payload.ipset_update
		if wire != proto1.WireBytes {
			return true, proto1.ErrInternalBadWireType
		}
		msg := new(IPSetUpdate)
		err := b.DecodeMessage(msg)
		m.Payload = &ToDataplane_IpsetUpdate{msg}
		return true, err
	case 3: // payload.ipset_delta_update
		if wire != proto1.WireBytes {
			return true, proto1.ErrInternalBadWireType
		}
		msg := new(IPSetDeltaUpdate)
		err := b.DecodeMessage(msg)
		m.Payload = &ToDataplane_IpsetDeltaUpdate{msg}
		return true, err
	case 4: // payload.ipset_remove
		if wire != proto1.WireBytes {
			return true, proto1.ErrInternalBadWireType
		}
		msg := new(IPSetRemove)
		err := b.DecodeMessage(msg)
		m.Payload = &ToDataplane_IpsetRemove{msg}
		return true, err
	case 5: // payload.active_profile_update
		if wire != proto1.WireBytes {
			return true, proto1.ErrInternalBadWireType
		}
		msg := new(ActiveProfileUpdate)
		err := b.DecodeMessage(msg)
		m.Payload = &ToDataplane_ActiveProfileUpdate{msg}
		return true, err
	case 6: // payload.active_profile_remove
		if wire != proto1.WireBytes {
			return true, proto1.ErrInternalBadWireType
		}
		msg := new(ActiveProfileRemove)
		err := b.DecodeMessage(msg)
		m.Payload = &ToDataplane_ActiveProfileRemove{msg}
		return true, err
	case 7: // payload.active_policy_update
		if wire != proto1.WireBytes {
			return true, proto1.ErrInternalBadWireType
		}
		msg := new(ActivePolicyUpdate)
		err := b.DecodeMessage(msg)
		m.Payload = &ToDataplane_ActivePolicyUpdate{msg}
		return true, err
	case 8: // payload.active_policy_remove
		if wire != proto1.WireBytes {
			return true, proto1.ErrInternalBadWireType
		}
		msg := new(ActivePolicyRemove)
		err := b.DecodeMessage(msg)
		m.Payload = &ToDataplane_ActivePolicyRemove{msg}
		return true, err
	case 9: // payload.host_endpoint_update
		if wire != proto1.WireBytes {
			return true, proto1.ErrInternalBadWireType
		}
		msg := new(HostEndpointUpdate)
		err := b.DecodeMessage(msg)
		m.Payload = &ToDataplane_HostEndpointUpdate{msg}
		return true, err
	case 10: // payload.host_endpoint_remove
		if wire != proto1.WireBytes {
			return true, proto1.ErrInternalBadWireType
		}
		msg := new(HostEndpointRemove)
		err := b.DecodeMessage(msg)
		m.Payload = &ToDataplane_HostEndpointRemove{msg}
		return true, err
	case 11: // payload.workload_endpoint_update
		if wire != proto1.WireBytes {
			return true, proto1.ErrInternalBadWireType
		}
		msg := new(WorkloadEndpointUpdate)
		err := b.DecodeMessage(msg)
		m.Payload = &ToDataplane_WorkloadEndpointUpdate{msg}
		return true, err
	case 12: // payload.workload_endpoint_remove
		if wire != proto1.WireBytes {
			return true, proto1.ErrInternalBadWireType
		}
		msg := new(WorkloadEndpointRemove)
		err := b.DecodeMessage(msg)
		m.Payload = &ToDataplane_WorkloadEndpointRemove{msg}
		return true, err
	case 13: // payload.config_update
		if wire != proto1.WireBytes {
			return true, proto1.ErrInternalBadWireType
		}
		msg := new(ConfigUpdate)
		err := b.DecodeMessage(msg)
		m.Payload = &ToDataplane_ConfigUpdate{msg}
		return true, err
	case 14: // payload.host_metadata_update
		if wire != proto1.WireBytes {
			return true, proto1.ErrInternalBadWireType
		}
		msg := new(HostMetadataUpdate)
		err := b.DecodeMessage(msg)
		m.Payload = &ToDataplane_HostMetadataUpdate{msg}
		return true, err
	case 18: // payload.host_metadata_remove
		if wire != proto1.WireBytes {
			return true, proto1.ErrInternalBadWireType
		}
		msg := new(HostMetadataRemove)
		err := b.DecodeMessage(msg)
		m.Payload = &ToDataplane_HostMetadataRemove{msg}
		return true, err
	case 37: // payload.host_metadata_v4v6_update
		if wire != proto1.WireBytes {
			return true, proto1.ErrInternalBadWireType
		}
		msg := new(HostMetadataV4V6Update)
		err := b.DecodeMessage(msg)
		m.Payload = &ToDataplane_HostMetadataV4V6Update{msg}
		return true, err
	case 38: // payload.host_metadata_v4v6_remove
		if wire != proto1.WireBytes {
			return true, proto1.ErrInternalBadWireType
		}
		msg := new(HostMetadataV4V6Remove)
		err := b.DecodeMessage(msg)
		m.Payload = &ToDataplane_HostMetadataV4V6Remove{msg}
		return true, err
	case 16: // payload.ipam_pool_update
		if wire != proto1.WireBytes {
			return true, proto1.ErrInternalBadWireType
		}
		msg := new(IPAMPoolUpdate)
		err := b.DecodeMessage(msg)
		m.Payload = &ToDataplane_IpamPoolUpdate{msg}
		return true, err
	case 17: // payload.ipam_pool_remove
		if wire != proto1.WireBytes {
			return true, proto1.ErrInternalBadWireType
		}
		msg := new(IPAMPoolRemove)
		err := b.DecodeMessage(msg)
		m.Payload = &ToDataplane_IpamPoolRemove{msg}
		return true, err
	case 19: // payload.service_account_update
		if wire != proto1.WireBytes {
			return true, proto1.ErrInternalBadWireType
		}
		msg := new(ServiceAccountUpdate)
		err := b.DecodeMessage(msg)
		m.Payload = &ToDataplane_ServiceAccountUpdate{msg}
		return true, err
	case 20: // payload.service_account_remove
		if wire != proto1.WireBytes {
			return true, proto1.ErrInternalBadWireType
		}
		msg := new(ServiceAccountRemove)
		err := b.DecodeMessage(msg)
		m.Payload = &ToDataplane_ServiceAccountRemove{msg}
		return true, err
	case 21: // payload.namespace_update
		if wire != proto1.WireBytes {
			return true, proto1.ErrInternalBadWireType
		}
		msg := new(NamespaceUpdate)
		err := b.DecodeMessage(msg)
		m.Payload = &ToDataplane_NamespaceUpdate{msg}
		return true, err
	case 22: // payload.namespace_remove
		if wire != proto1.WireBytes {
			return true, proto1.ErrInternalBadWireType
		}
		msg := new(NamespaceRemove)
		err := b.DecodeMessage(msg)
		m.Payload = &ToDataplane_NamespaceRemove{msg}
		return true, err
	case 23: // payload.route_update
		if wire != proto1.WireBytes {
			return true, proto1.ErrInternalBadWireType
		}
		msg := new(RouteUpdate)
		err := b.DecodeMessage(msg)
		m.Payload = &ToDataplane_RouteUpdate{msg}
		return true, err
	case 24: // payload.route_remove
		if wire != proto1.WireBytes {
			return true, proto1.ErrInternalBadWireType
		}
		msg := new(RouteRemove)
		err := b.DecodeMessage(msg)
		m.Payload = &ToDataplane_RouteRemove{msg}
		return true, err
	case 25: // payload.vtep_update
		if wire != proto1.WireBytes {
			return true, proto1.ErrInternalBadWireType
		}
		msg := new(VXLANTunnelEndpointUpdate)
		err := b.DecodeMessage(msg)
		m.Payload = &ToDataplane_VtepUpdate{msg}
		return true, err
	case 26: // payload.vtep_remove
		if wire != proto1.WireBytes {
			return true, proto1.ErrInternalBadWireType
		}
		msg := new(VXLANTunnelEndpointRemove)
		err := b.DecodeMessage(msg)
		m.Payload = &ToDataplane_VtepRemove{msg}
		return true, err
	case 27: // payload.wireguard_endpoint_update
		if wire != proto1.WireBytes {
			return true, proto1.ErrInternalBadWireType
		}
		msg := new(WireguardEndpointUpdate)
		err := b.DecodeMessage(msg)
		m.Payload = &ToDataplane_WireguardEndpointUpdate{msg}
		return true, err
	case 28: // payload.wireguard_endpoint_remove
		if wire != proto1.WireBytes {
			return true, proto1.ErrInternalBadWireType
		}
		msg := new(WireguardEndpointRemove)
		err := b.DecodeMessage(msg)
		m.Payload = &ToDataplane_WireguardEndpointRemove{msg}
		return true, err
	case 29: // payload.global_bgp_config_update
		if wire != proto1.WireBytes {
			return true, proto1.ErrInternalBadWireType
		}
		msg := new(GlobalBGPConfigUpdate)
		err := b.DecodeMessage(msg)
		m.Payload = &ToDataplane_GlobalBgpConfigUpdate{msg}
		return true, err
	case 30: // payload.encapsulation
		if wire != proto1.WireBytes {
			return true, proto1.ErrInternalBadWireType
		}
		msg := new(Encapsulation)
		err := b.DecodeMessage(msg)
		m.Payload = &ToDataplane_Encapsulation{msg}
		return true, err
	case 31: // payload.service_update
		if wire != proto1.WireBytes {
			return true, proto1.ErrInternalBadWireType
		}
		msg := new(ServiceUpdate)
		err := b.DecodeMessage(msg)
		m.Payload = &ToDataplane_ServiceUpdate{msg}
		return true, err
	case 32: // payload.service_remove
		if wire != proto1.WireBytes {
			return true, proto1.ErrInternalBadWireType
		}
		msg := new(ServiceRemove)
		err := b.DecodeMessage(msg)
		m.Payload = &ToDataplane_ServiceRemove{msg}
		return true, err
	case 33: // payload.wireguard_endpoint_v6_update
		if wire != proto1.WireBytes {
			return true, proto1.ErrInternalBadWireType
		}
		msg := new(WireguardEndpointV6Update)
		err := b.DecodeMessage(msg)
		m.Payload = &ToDataplane_WireguardEndpointV6Update{msg}
		return true, err
	case 34: // payload.wireguard_endpoint_v6_remove
		if wire != proto1.WireBytes {
			return true, proto1.ErrInternalBadWireType
		}
		msg := new(WireguardEndpointV6Remove)
		err := b.DecodeMessage(msg)
		m.Payload = &ToDataplane_WireguardEndpointV6Remove{msg}
		return true, err
	case 35: // payload.host_metadata_v6_update
		if wire != proto1.WireBytes {
			return true, proto1.ErrInternalBadWireType
		}
		msg := new(HostMetadataV6Update)
		err := b.DecodeMessage(msg)
		m.Payload = &ToDataplane_HostMetadataV6Update{msg}
		return true, err
	case 36: // payload.host_metadata_v6_remove
		if wire != proto1.WireBytes {
			return true, proto1.ErrInternalBadWireType
		}
		msg := new(HostMetadataV6Remove)
		err := b.DecodeMessage(msg)
		m.Payload = &ToDataplane_HostMetadataV6Remove{msg}
		return true, err
	default:
		return false, nil
	}
}

func _ToDataplane_OneofSizer(msg proto1.Message) (n int) {
	m := msg.(*ToDataplane)
	// payload
	switch x := m.Payload.(type) {
	case *ToDataplane_InSync:
		s := proto1.Size(x.InSync)
		n += proto1.SizeVarint(1<<3 | proto1.WireBytes)
		n += proto1.SizeVarint(uint64(s))
		n += s
	case *ToDataplane_IpsetUpdate:
		s := proto1.Size(x.IpsetUpdate)
		n += proto1.SizeVarint(2<<3 | proto1.WireBytes)
		n += proto1.SizeVarint(uint64(s))
		n += s
	case *ToDataplane_IpsetDeltaUpdate:
		s := proto1.Size(x.IpsetDeltaUpdate)
		n += proto1.SizeVarint(3<<3 | proto1.WireBytes)
		n += proto1.SizeVarint(uint64(s))
		n += s
	case *ToDataplane_IpsetRemove:
		s := proto1.Size(x.IpsetRemove)
		n += proto1.SizeVarint(4<<3 | proto1.WireBytes)
		n += proto1.SizeVarint(uint64(s))
		n += s
	case *ToDataplane_ActiveProfileUpdate:
		s := proto1.Size(x.ActiveProfileUpdate)
		n += proto1.SizeVarint(5<<3 | proto1.WireBytes)
		n += proto1.SizeVarint(uint64(s))
		n += s
	case *ToDataplane_ActiveProfileRemove:
		s := proto1.Size(x.ActiveProfileRemove)
		n += proto1.SizeVarint(6<<3 | proto1.WireBytes)
		n += proto1.SizeVarint(uint64(s))
		n += s
	case *ToDataplane_ActivePolicyUpdate:
		s := proto1.Size(x.ActivePolicyUpdate)
		n += proto1.SizeVarint(7<<3 | proto1.WireBytes)
		n += proto1.SizeVarint(uint64(s))
		n += s
	case *ToDataplane_ActivePolicyRemove:
		s := proto1.Size(x.ActivePolicyRemove)
		n += proto1.SizeVarint(8<<3 | proto1.WireBytes)
		n += proto1.SizeVarint(uint64(s))
		n += s
	case *ToDataplane_HostEndpointUpdate:
		s := proto1.Size(x.HostEndpointUpdate)
		n += proto1.SizeVarint(9<<3 | proto1.WireBytes)
		n += proto1.SizeVarint(uint64(s))
		n += s
	case *ToDataplane_HostEndpointRemove:
		s := proto1.Size(x.HostEndpointRemove)
		n += proto1.SizeVarint(10<<3 | proto1.WireBytes)
		n += proto1.SizeVarint(uint64(s))
		n += s
	case *ToDataplane_WorkloadEndpointUpdate:
		s := proto1.Size(x.WorkloadEndpointUpdate)
		n += proto1.SizeVarint(11<<3 | proto1.WireBytes)
		n += proto1.SizeVarint(uint64(s))
		n += s
	case *ToDataplane_WorkloadEndpointRemove:
		s := proto1.Size(x.WorkloadEndpointRemove)
		n += proto1.SizeVarint(12<<3 | proto1.WireBytes)
		n += proto1.SizeVarint(uint64(s))
		n += s
	case *ToDataplane_ConfigUpdate:
		s := proto1.Size(x.ConfigUpdate)
		n += proto1.SizeVarint(13<<3 | proto1.WireBytes)
		n += proto1.SizeVarint(uint64(s))
		n += s
	case *ToDataplane_HostMetadataUpdate:
		s := proto1.Size(x.HostMetadataUpdate)
		n += proto1.SizeVarint(14<<3 | proto1.WireBytes)
		n += proto1.SizeVarint(uint64(s))
		n += s
	case *ToDataplane_HostMetadataRemove:
		s := proto1.Size(x.HostMetadataRemove)
		n += proto1.SizeVarint(18<<3 | proto1.WireBytes)
		n += proto1.SizeVarint(uint64(s))
		n += s
	case *ToDataplane_HostMetadataV4V6Update:
		s := proto1.Size(x.HostMetadataV4V6Update)
		n += proto1.SizeVarint(37<<3 | proto1.WireBytes)
		n += proto1.SizeVarint(uint64(s))
		n += s
	case *ToDataplane_HostMetadataV4V6Remove:
		s := proto1.Size(x.HostMetadataV4V6Remove)
		n += proto1.SizeVarint(38<<3 | proto1.WireBytes)
		n += proto1.SizeVarint(uint64(s))
		n += s
	case *ToDataplane_IpamPoolUpdate:
		s := proto1.Size(x.IpamPoolUpdate)
		n += proto1.SizeVarint(16<<3 | proto1.WireBytes)
		n += proto1.SizeVarint(uint64(s))
		n += s
	case *ToDataplane_IpamPoolRemove:
		s := proto1.Size(x.IpamPoolRemove)
		n += proto1.SizeVarint(17<<3 | proto1.WireBytes)
		n += proto1.SizeVarint(uint64(s))
		n += s
	case *ToDataplane_ServiceAccountUpdate:
		s := proto1.Size(x.ServiceAccountUpdate)
		n += proto1.SizeVarint(19<<3 | proto1.WireBytes)
		n += proto1.SizeVarint(uint64(s))
		n += s
	case *ToDataplane_ServiceAccountRemove:
		s := proto1.Size(x.ServiceAccountRemove)
		n += proto1.SizeVarint(20<<3 | proto1.WireBytes)
		n += proto1.SizeVarint(uint64(s))
		n += s
	case *ToDataplane_NamespaceUpdate:
		s := proto1.Size(x.NamespaceUpdate)
		n += proto1.SizeVarint(21<<3 | proto1.WireBytes)
		n += proto1.SizeVarint(uint64(s))
		n += s
	case *ToDataplane_NamespaceRemove:
		s := proto1.Size(x.NamespaceRemove)
		n += proto1.SizeVarint(22<<3 | proto1.WireBytes)
		n += proto1.SizeVarint(uint64(s))
		n += s
	case *ToDataplane_RouteUpdate:
		s := proto1.Size(x.RouteUpdate)
		n += proto1.SizeVarint(23<<3 | proto1.WireBytes)
		n += proto1.SizeVarint(uint64(s))
		n += s
	case *ToDataplane_RouteRemove:
		s := proto1.Size(x.RouteRemove)
		n += proto1.SizeVarint(24<<3 | proto1.WireBytes)
		n += proto1.SizeVarint(uint64(s))
		n += s
	case *ToDataplane_VtepUpdate:
		s := proto1.Size(x.VtepUpdate)
		n += proto1.SizeVarint(25<<3 | proto1.WireBytes)
		n += proto1.SizeVarint(uint64(s))
		n += s
	case *ToDataplane_VtepRemove:
		s := proto1.Size(x.VtepRemove)
		n += proto1.SizeVarint(26<<3 | proto1.WireBytes)
		n += proto1.SizeVarint(uint64(s))
		n += s
	case *ToDataplane_WireguardEndpointUpdate:
		s := proto1.Size(x.WireguardEndpointUpdate)
		n += proto1.SizeVarint(27<<3 | proto1.WireBytes)
		n += proto1.SizeVarint(uint64(s))
		n += s
	case *ToDataplane_WireguardEndpointRemove:
		s := proto1.Size(x.WireguardEndpointRemove)
		n += proto1.SizeVarint(28<<3 | proto1.WireBytes)
		n += proto1.SizeVarint(uint64(s))
		n += s
	case *ToDataplane_GlobalBgpConfigUpdate:
		s := proto1.Size(x.GlobalBgpConfigUpdate)
		n += proto1.SizeVarint(29<<3 | proto1.WireBytes)
		n += proto1.SizeVarint(uint64(s))
		n += s
	case *ToDataplane_Encapsulation:
		s := proto1.Size(x.Encapsulation)
		n += proto1.SizeVarint(30<<3 | proto1.WireBytes)
		n += proto1.SizeVarint(uint64(s))
		n += s
	case *ToDataplane_ServiceUpdate:
		s := proto1.Size(x.ServiceUpdate)
		n += proto1.SizeVarint(31<<3 | proto1.WireBytes)
		n += proto1.SizeVarint(uint64(s))
		n += s
	case *ToDataplane_ServiceRemove:
		s := proto1.Size(x.ServiceRemove)
		n += proto1.SizeVarint(32<<3 | proto1.WireBytes)
		n += proto1.SizeVarint(uint64(s))
		n += s
	case *ToDataplane_WireguardEndpointV6Update:
		s := proto1.Size(x.WireguardEndpointV6Update)
		n += proto1.SizeVarint(33<<3 | proto1.WireBytes)
		n += proto1.SizeVarint(uint64(s))
		n += s
	case *ToDataplane_WireguardEndpointV6Remove:
		s := proto1.Size(x.WireguardEndpointV6Remove)
		n += proto1.SizeVarint(34<<3 | proto1.WireBytes)
		n += proto1.SizeVarint(uint64(s))
		n += s
	case *ToDataplane_HostMetadataV6Update:
		s := proto1.Size(x.HostMetadataV6Update)
		n += proto1.SizeVarint(35<<3 | proto1.WireBytes)
		n += proto1.SizeVarint(uint64(s))
		n += s
	case *ToDataplane_HostMetadataV6Remove:
		s := proto1.Size(x.HostMetadataV6Remove)
		n += proto1.SizeVarint(36<<3 | proto1.WireBytes)
		n += proto1.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

type FromDataplane struct {
	SequenceNumber uint64 `protobuf:"varint,8,opt,name=sequence_number,json=sequenceNumber,proto3" json:"sequence_number,omitempty"`
	// Types that are valid to be assigned to Payload:
	//	*FromDataplane_ProcessStatusUpdate
	//	*FromDataplane_HostEndpointStatusUpdate
	//	*FromDataplane_HostEndpointStatusRemove
	//	*FromDataplane_WorkloadEndpointStatusUpdate
	//	*FromDataplane_WorkloadEndpointStatusRemove
	//	*FromDataplane_WireguardStatusUpdate
	//	*FromDataplane_DataplaneInSync
	Payload isFromDataplane_Payload `protobuf_oneof:"payload"`
}

func (m *FromDataplane) Reset()                    { *m = FromDataplane{} }
func (m *FromDataplane) String() string            { return proto1.CompactTextString(m) }
func (*FromDataplane) ProtoMessage()               {}
func (*FromDataplane) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{2} }

type isFromDataplane_Payload interface {
	isFromDataplane_Payload()
	MarshalTo([]byte) (int, error)
	Size() int
}

type FromDataplane_ProcessStatusUpdate struct {
	ProcessStatusUpdate *ProcessStatusUpdate `protobuf:"bytes,3,opt,name=process_status_update,json=processStatusUpdate,oneof"`
}
type FromDataplane_HostEndpointStatusUpdate struct {
	HostEndpointStatusUpdate *HostEndpointStatusUpdate `protobuf:"bytes,4,opt,name=host_endpoint_status_update,json=hostEndpointStatusUpdate,oneof"`
}
type FromDataplane_HostEndpointStatusRemove struct {
	HostEndpointStatusRemove *HostEndpointStatusRemove `protobuf:"bytes,5,opt,name=host_endpoint_status_remove,json=hostEndpointStatusRemove,oneof"`
}
type FromDataplane_WorkloadEndpointStatusUpdate struct {
	WorkloadEndpointStatusUpdate *WorkloadEndpointStatusUpdate `protobuf:"bytes,6,opt,name=workload_endpoint_status_update,json=workloadEndpointStatusUpdate,oneof"`
}
type FromDataplane_WorkloadEndpointStatusRemove struct {
	WorkloadEndpointStatusRemove *WorkloadEndpointStatusRemove `protobuf:"bytes,7,opt,name=workload_endpoint_status_remove,json=workloadEndpointStatusRemove,oneof"`
}
type FromDataplane_WireguardStatusUpdate struct {
	WireguardStatusUpdate *WireguardStatusUpdate `protobuf:"bytes,9,opt,name=wireguard_status_update,json=wireguardStatusUpdate,oneof"`
}
type FromDataplane_DataplaneInSync struct {
	DataplaneInSync *DataplaneInSync `protobuf:"bytes,10,opt,name=dataplane_in_sync,json=dataplaneInSync,oneof"`
}

func (*FromDataplane_ProcessStatusUpdate) isFromDataplane_Payload()          {}
func (*FromDataplane_HostEndpointStatusUpdate) isFromDataplane_Payload()     {}
func (*FromDataplane_HostEndpointStatusRemove) isFromDataplane_Payload()     {}
func (*FromDataplane_WorkloadEndpointStatusUpdate) isFromDataplane_Payload() {}
func (*FromDataplane_WorkloadEndpointStatusRemove) isFromDataplane_Payload() {}
func (*FromDataplane_WireguardStatusUpdate) isFromDataplane_Payload()        {}
func (*FromDataplane_DataplaneInSync) isFromDataplane_Payload()              {}

func (m *FromDataplane) GetPayload() isFromDataplane_Payload {
	if m != nil {
		return m.Payload
	}
	return nil
}

func (m *FromDataplane) GetSequenceNumber() uint64 {
	if m != nil {
		return m.SequenceNumber
	}
	return 0
}

func (m *FromDataplane) GetProcessStatusUpdate() *ProcessStatusUpdate {
	if x, ok := m.GetPayload().(*FromDataplane_ProcessStatusUpdate); ok {
		return x.ProcessStatusUpdate
	}
	return nil
}

func (m *FromDataplane) GetHostEndpointStatusUpdate() *HostEndpointStatusUpdate {
	if x, ok := m.GetPayload().(*FromDataplane_HostEndpointStatusUpdate); ok {
		return x.HostEndpointStatusUpdate
	}
	return nil
}

func (m *FromDataplane) GetHostEndpointStatusRemove() *HostEndpointStatusRemove {
	if x, ok := m.GetPayload().(*FromDataplane_HostEndpointStatusRemove); ok {
		return x.HostEndpointStatusRemove
	}
	return nil
}

func (m *FromDataplane) GetWorkloadEndpointStatusUpdate() *WorkloadEndpointStatusUpdate {
	if x, ok := m.GetPayload().(*FromDataplane_WorkloadEndpointStatusUpdate); ok {
		return x.WorkloadEndpointStatusUpdate
	}
	return nil
}

func (m *FromDataplane) GetWorkloadEndpointStatusRemove() *WorkloadEndpointStatusRemove {
	if x, ok := m.GetPayload().(*FromDataplane_WorkloadEndpointStatusRemove); ok {
		return x.WorkloadEndpointStatusRemove
	}
	return nil
}

func (m *FromDataplane) GetWireguardStatusUpdate() *WireguardStatusUpdate {
	if x, ok := m.GetPayload().(*FromDataplane_WireguardStatusUpdate); ok {
		return x.WireguardStatusUpdate
	}
	return nil
}

func (m *FromDataplane) GetDataplaneInSync() *DataplaneInSync {
	if x, ok := m.GetPayload().(*FromDataplane_DataplaneInSync); ok {
		return x.DataplaneInSync
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*FromDataplane) XXX_OneofFuncs() (func(msg proto1.Message, b *proto1.Buffer) error, func(msg proto1.Message, tag, wire int, b *proto1.Buffer) (bool, error), func(msg proto1.Message) (n int), []interface{}) {
	return _FromDataplane_OneofMarshaler, _FromDataplane_OneofUnmarshaler, _FromDataplane_OneofSizer, []interface{}{
		(*FromDataplane_ProcessStatusUpdate)(nil),
		(*FromDataplane_HostEndpointStatusUpdate)(nil),
		(*FromDataplane_HostEndpointStatusRemove)(nil),
		(*FromDataplane_WorkloadEndpointStatusUpdate)(nil),
		(*FromDataplane_WorkloadEndpointStatusRemove)(nil),
		(*FromDataplane_WireguardStatusUpdate)(nil),
		(*FromDataplane_DataplaneInSync)(nil),
	}
}

func _FromDataplane_OneofMarshaler(msg proto1.Message, b *proto1.Buffer) error {
	m := msg.(*FromDataplane)
	// payload
	switch x := m.Payload.(type) {
	case *FromDataplane_ProcessStatusUpdate:
		_ = b.EncodeVarint(3<<3 | proto1.WireBytes)
		if err := b.EncodeMessage(x.ProcessStatusUpdate); err != nil {
			return err
		}
	case *FromDataplane_HostEndpointStatusUpdate:
		_ = b.EncodeVarint(4<<3 | proto1.WireBytes)
		if err := b.EncodeMessage(x.HostEndpointStatusUpdate); err != nil {
			return err
		}
	case *FromDataplane_HostEndpointStatusRemove:
		_ = b.EncodeVarint(5<<3 | proto1.WireBytes)
		if err := b.EncodeMessage(x.HostEndpointStatusRemove); err != nil {
			return err
		}
	case *FromDataplane_WorkloadEndpointStatusUpdate:
		_ = b.EncodeVarint(6<<3 | proto1.WireBytes)
		if err := b.EncodeMessage(x.WorkloadEndpointStatusUpdate); err != nil {
			return err
		}
	case *FromDataplane_WorkloadEndpointStatusRemove:
		_ = b.EncodeVarint(7<<3 | proto1.WireBytes)
		if err := b.EncodeMessage(x.WorkloadEndpointStatusRemove); err != nil {
			return err
		}
	case *FromDataplane_WireguardStatusUpdate:
		_ = b.EncodeVarint(9<<3 | proto1.WireBytes)
		if err := b.EncodeMessage(x.WireguardStatusUpdate); err != nil {
			return err
		}
	case *FromDataplane_DataplaneInSync:
		_ = b.EncodeVarint(10<<3 | proto1.WireBytes)
		if err := b.EncodeMessage(x.DataplaneInSync); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("FromDataplane.Payload has unexpected type %T", x)
	}
	return nil
}

func _FromDataplane_OneofUnmarshaler(msg proto1.Message, tag, wire int, b *proto1.Buffer) (bool, error) {
	m := msg.(*FromDataplane)
	switch tag {
	case 3: // payload.process_status_update
		if wire != proto1.WireBytes {
			return true, proto1.ErrInternalBadWireType
		}
		msg := new(ProcessStatusUpdate)
		err := b.DecodeMessage(msg)
		m.Payload = &FromDataplane_ProcessStatusUpdate{msg}
		return true, err
	case 4: // payload.host_endpoint_status_update
		if wire != proto1.WireBytes {
			return true, proto1.ErrInternalBadWireType
		}
		msg := new(HostEndpointStatusUpdate)
		err := b.DecodeMessage(msg)
		m.Payload = &FromDataplane_HostEndpointStatusUpdate{msg}
		return true, err
	case 5: // payload.host_endpoint_status_remove
		if wire != proto1.WireBytes {
			return true, proto1.ErrInternalBadWireType
		}
		msg := new(HostEndpointStatusRemove)
		err := b.DecodeMessage(msg)
		m.Payload = &FromDataplane_HostEndpointStatusRemove{msg}
		return true, err
	case 6: // payload.workload_endpoint_status_update
		if wire != proto1.WireBytes {
			return true, proto1.ErrInternalBadWireType
		}
		msg := new(WorkloadEndpointStatusUpdate)
		err := b.DecodeMessage(msg)
		m.Payload = &FromDataplane_WorkloadEndpointStatusUpdate{msg}
		return true, err
	case 7: // payload.workload_endpoint_status_remove
		if wire != proto1.WireBytes {
			return true, proto1.ErrInternalBadWireType
		}
		msg := new(WorkloadEndpointStatusRemove)
		err := b.DecodeMessage(msg)
		m.Payload = &FromDataplane_WorkloadEndpointStatusRemove{msg}
		return true, err
	case 9: // payload.wireguard_status_update
		if wire != proto1.WireBytes {
			return true, proto1.ErrInternalBadWireType
		}
		msg := new(WireguardStatusUpdate)
		err := b.DecodeMessage(msg)
		m.Payload = &FromDataplane_WireguardStatusUpdate{msg}
		return true, err
	case 10: // payload.dataplane_in_sync
		if wire != proto1.WireBytes {
			return true, proto1.ErrInternalBadWireType
		}
		msg := new(DataplaneInSync)
		err := b.DecodeMessage(msg)
		m.Payload = &FromDataplane_DataplaneInSync{msg}
		return true, err
	default:
		return false, nil
	}
}

func _FromDataplane_OneofSizer(msg proto1.Message) (n int) {
	m := msg.(*FromDataplane)
	// payload
	switch x := m.Payload.(type) {
	case *FromDataplane_ProcessStatusUpdate:
		s := proto1.Size(x.ProcessStatusUpdate)
		n += proto1.SizeVarint(3<<3 | proto1.WireBytes)
		n += proto1.SizeVarint(uint64(s))
		n += s
	case *FromDataplane_HostEndpointStatusUpdate:
		s := proto1.Size(x.HostEndpointStatusUpdate)
		n += proto1.SizeVarint(4<<3 | proto1.WireBytes)
		n += proto1.SizeVarint(uint64(s))
		n += s
	case *FromDataplane_HostEndpointStatusRemove:
		s := proto1.Size(x.HostEndpointStatusRemove)
		n += proto1.SizeVarint(5<<3 | proto1.WireBytes)
		n += proto1.SizeVarint(uint64(s))
		n += s
	case *FromDataplane_WorkloadEndpointStatusUpdate:
		s := proto1.Size(x.WorkloadEndpointStatusUpdate)
		n += proto1.SizeVarint(6<<3 | proto1.WireBytes)
		n += proto1.SizeVarint(uint64(s))
		n += s
	case *FromDataplane_WorkloadEndpointStatusRemove:
		s := proto1.Size(x.WorkloadEndpointStatusRemove)
		n += proto1.SizeVarint(7<<3 | proto1.WireBytes)
		n += proto1.SizeVarint(uint64(s))
		n += s
	case *FromDataplane_WireguardStatusUpdate:
		s := proto1.Size(x.WireguardStatusUpdate)
		n += proto1.SizeVarint(9<<3 | proto1.WireBytes)
		n += proto1.SizeVarint(uint64(s))
		n += s
	case *FromDataplane_DataplaneInSync:
		s := proto1.Size(x.DataplaneInSync)
		n += proto1.SizeVarint(10<<3 | proto1.WireBytes)
		n += proto1.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

type ConfigUpdate struct {
	Message           string                `protobuf:"bytes,3,opt,name=message,proto3" json:"message,omitempty"`
	Config            map[string]string     `protobuf:"bytes,1,rep,name=config" json:"config,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	SourceToRawConfig map[uint32]*RawConfig `protobuf:"bytes,2,rep,name=source_to_raw_config,json=sourceToRawConfig" json:"source_to_raw_config,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"`
}

func (m *ConfigUpdate) Reset()                    { *m = ConfigUpdate{} }
func (m *ConfigUpdate) String() string            { return proto1.CompactTextString(m) }
func (*ConfigUpdate) ProtoMessage()               {}
func (*ConfigUpdate) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{3} }

func (m *ConfigUpdate) GetMessage() string {
	if m != nil {
		return m.Message
	}
	return ""
}

func (m *ConfigUpdate) GetConfig() map[string]string {
	if m != nil {
		return m.Config
	}
	return nil
}

func (m *ConfigUpdate) GetSourceToRawConfig() map[uint32]*RawConfig {
	if m != nil {
		return m.SourceToRawConfig
	}
	return nil
}

type RawConfig struct {
	Source string            `protobuf:"bytes,1,opt,name=source,proto3" json:"source,omitempty"`
	Config map[string]string `protobuf:"bytes,2,rep,name=config" json:"config,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}

func (m *RawConfig) Reset()                    { *m = RawConfig{} }
func (m *RawConfig) String() string            { return proto1.CompactTextString(m) }
func (*RawConfig) ProtoMessage()               {}
func (*RawConfig) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{4} }

func (m *RawConfig) GetSource() string {
	if m != nil {
		return m.Source
	}
	return ""
}

func (m *RawConfig) GetConfig() map[string]string {
	if m != nil {
		return m.Config
	}
	return nil
}

type InSync struct {
}

func (m *InSync) Reset()                    { *m = InSync{} }
func (m *InSync) String() string            { return proto1.CompactTextString(m) }
func (*InSync) ProtoMessage()               {}
func (*InSync) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{5} }

type IPSetUpdate struct {
	Id      string                `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Members []string              `protobuf:"bytes,2,rep,name=members" json:"members,omitempty"`
	Type    IPSetUpdate_IPSetType `protobuf:"varint,3,opt,name=type,proto3,enum=felix.IPSetUpdate_IPSetType" json:"type,omitempty"`
}

func (m *IPSetUpdate) Reset()                    { *m = IPSetUpdate{} }
func (m *IPSetUpdate) String() string            { return proto1.CompactTextString(m) }
func (*IPSetUpdate) ProtoMessage()               {}
func (*IPSetUpdate) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{6} }

func (m *IPSetUpdate) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *IPSetUpdate) GetMembers() []string {
	if m != nil {
		return m.Members
	}
	return nil
}

func (m *IPSetUpdate) GetType() IPSetUpdate_IPSetType {
	if m != nil {
		return m.Type
	}
	return IPSetUpdate_IP
}

type IPSetDeltaUpdate struct {
	Id             string   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	AddedMembers   []string `protobuf:"bytes,2,rep,name=added_members,json=addedMembers" json:"added_members,omitempty"`
	RemovedMembers []string `protobuf:"bytes,3,rep,name=removed_members,json=removedMembers" json:"removed_members,omitempty"`
}

func (m *IPSetDeltaUpdate) Reset()                    { *m = IPSetDeltaUpdate{} }
func (m *IPSetDeltaUpdate) String() string            { return proto1.CompactTextString(m) }
func (*IPSetDeltaUpdate) ProtoMessage()               {}
func (*IPSetDeltaUpdate) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{7} }

func (m *IPSetDeltaUpdate) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *IPSetDeltaUpdate) GetAddedMembers() []string {
	if m != nil {
		return m.AddedMembers
	}
	return nil
}

func (m *IPSetDeltaUpdate) GetRemovedMembers() []string {
	if m != nil {
		return m.RemovedMembers
	}
	return nil
}

type IPSetRemove struct {
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
}

func (m *IPSetRemove) Reset()                    { *m = IPSetRemove{} }
func (m *IPSetRemove) String() string            { return proto1.CompactTextString(m) }
func (*IPSetRemove) ProtoMessage()               {}
func (*IPSetRemove) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{8} }

func (m *IPSetRemove) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

type ActiveProfileUpdate struct {
	Id      *ProfileID `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
	Profile *Profile   `protobuf:"bytes,2,opt,name=profile" json:"profile,omitempty"`
}

func (m *ActiveProfileUpdate) Reset()                    { *m = ActiveProfileUpdate{} }
func (m *ActiveProfileUpdate) String() string            { return proto1.CompactTextString(m) }
func (*ActiveProfileUpdate) ProtoMessage()               {}
func (*ActiveProfileUpdate) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{9} }

func (m *ActiveProfileUpdate) GetId() *ProfileID {
	if m != nil {
		return m.Id
	}
	return nil
}

func (m *ActiveProfileUpdate) GetProfile() *Profile {
	if m != nil {
		return m.Profile
	}
	return nil
}

type ActiveProfileRemove struct {
	Id *ProfileID `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
}

func (m *ActiveProfileRemove) Reset()         { *m = ActiveProfileRemove{} }
func (m *ActiveProfileRemove) String() string { return proto1.CompactTextString(m) }
func (*ActiveProfileRemove) ProtoMessage()    {}
func (*ActiveProfileRemove) Descriptor() ([]byte, []int) {
	return fileDescriptorFelixbackend, []int{10}
}

func (m *ActiveProfileRemove) GetId() *ProfileID {
	if m != nil {
		return m.Id
	}
	return nil
}

type ProfileID struct {
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
}

func (m *ProfileID) Reset()                    { *m = ProfileID{} }
func (m *ProfileID) String() string            { return proto1.CompactTextString(m) }
func (*ProfileID) ProtoMessage()               {}
func (*ProfileID) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{11} }

func (m *ProfileID) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

type Profile struct {
	InboundRules  []*Rule `protobuf:"bytes,1,rep,name=inbound_rules,json=inboundRules" json:"inbound_rules,omitempty"`
	OutboundRules []*Rule `protobuf:"bytes,2,rep,name=outbound_rules,json=outboundRules" json:"outbound_rules,omitempty"`
}

func (m *Profile) Reset()                    { *m = Profile{} }
func (m *Profile) String() string            { return proto1.CompactTextString(m) }
func (*Profile) ProtoMessage()               {}
func (*Profile) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{12} }

func (m *Profile) GetInboundRules() []*Rule {
	if m != nil {
		return m.InboundRules
	}
	return nil
}

func (m *Profile) GetOutboundRules() []*Rule {
	if m != nil {
		return m.OutboundRules
	}
	return nil
}

type ActivePolicyUpdate struct {
	Id     *PolicyID `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
	Policy *Policy   `protobuf:"bytes,2,opt,name=policy" json:"policy,omitempty"`
}

func (m *ActivePolicyUpdate) Reset()                    { *m = ActivePolicyUpdate{} }
func (m *ActivePolicyUpdate) String() string            { return proto1.CompactTextString(m) }
func (*ActivePolicyUpdate) ProtoMessage()               {}
func (*ActivePolicyUpdate) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{13} }

func (m *ActivePolicyUpdate) GetId() *PolicyID {
	if m != nil {
		return m.Id
	}
	return nil
}

func (m *ActivePolicyUpdate) GetPolicy() *Policy {
	if m != nil {
		return m.Policy
	}
	return nil
}

type ActivePolicyRemove struct {
	Id *PolicyID `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
}

func (m *ActivePolicyRemove) Reset()                    { *m = ActivePolicyRemove{} }
func (m *ActivePolicyRemove) String() string            { return proto1.CompactTextString(m) }
func (*ActivePolicyRemove) ProtoMessage()               {}
func (*ActivePolicyRemove) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{14} }

func (m *ActivePolicyRemove) GetId() *PolicyID {
	if m != nil {
		return m.Id
	}
	return nil
}

type PolicyID struct {
	Tier string `protobuf:"bytes,1,opt,name=tier,proto3" json:"tier,omitempty"`
	Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
}

func (m *PolicyID) Reset()                    { *m = PolicyID{} }
func (m *PolicyID) String() string            { return proto1.CompactTextString(m) }
func (*PolicyID) ProtoMessage()               {}
func (*PolicyID) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{15} }

func (m *PolicyID) GetTier() string {
	if m != nil {
		return m.Tier
	}
	return ""
}

func (m *PolicyID) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

type Policy struct {
	// If the Policy represents a NetworkPolicy, this contains the namespace that the policy came
	// from.  Otherwise, empty.
	Namespace        string  `protobuf:"bytes,5,opt,name=namespace,proto3" json:"namespace,omitempty"`
	InboundRules     []*Rule `protobuf:"bytes,1,rep,name=inbound_rules,json=inboundRules" json:"inbound_rules,omitempty"`
	OutboundRules    []*Rule `protobuf:"bytes,2,rep,name=outbound_rules,json=outboundRules" json:"outbound_rules,omitempty"`
	Untracked        bool    `protobuf:"varint,3,opt,name=untracked,proto3" json:"untracked,omitempty"`
	PreDnat          bool    `protobuf:"varint,4,opt,name=pre_dnat,json=preDnat,proto3" json:"pre_dnat,omitempty"`
	OriginalSelector string  `protobuf:"bytes,6,opt,name=original_selector,json=originalSelector,proto3" json:"original_selector,omitempty"`
}

func (m *Policy) Reset()                    { *m = Policy{} }
func (m *Policy) String() string            { return proto1.CompactTextString(m) }
func (*Policy) ProtoMessage()               {}
func (*Policy) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{16} }

func (m *Policy) GetNamespace() string {
	if m != nil {
		return m.Namespace
	}
	return ""
}

func (m *Policy) GetInboundRules() []*Rule {
	if m != nil {
		return m.InboundRules
	}
	return nil
}

func (m *Policy) GetOutboundRules() []*Rule {
	if m != nil {
		return m.OutboundRules
	}
	return nil
}

func (m *Policy) GetUntracked() bool {
	if m != nil {
		return m.Untracked
	}
	return false
}

func (m *Policy) GetPreDnat() bool {
	if m != nil {
		return m.PreDnat
	}
	return false
}

func (m *Policy) GetOriginalSelector() string {
	if m != nil {
		return m.OriginalSelector
	}
	return ""
}

type Rule struct {
	Action    string    `protobuf:"bytes,1,opt,name=action,proto3" json:"action,omitempty"`
	IpVersion IPVersion `protobuf:"varint,2,opt,name=ip_version,json=ipVersion,proto3,enum=felix.IPVersion" json:"ip_version,omitempty"`
	Protocol  *Protocol `protobuf:"bytes,3,opt,name=protocol" json:"protocol,omitempty"`
	SrcNet    []string  `protobuf:"bytes,4,rep,name=src_net,json=srcNet" json:"src_net,omitempty"`
	// The list of ports is split into numeric and named ports, where named ports are represented
	// by (IP, port) IP sets.  A packet matches this rule if it matches any numeric port range *or*
	// any listed named port IP set.
	SrcPorts             []*PortRange `protobuf:"bytes,5,rep,name=src_ports,json=srcPorts" json:"src_ports,omitempty"`
	SrcNamedPortIpSetIds []string     `protobuf:"bytes,12,rep,name=src_named_port_ip_set_ids,json=srcNamedPortIpSetIds" json:"src_named_port_ip_set_ids,omitempty"`
	DstNet               []string     `protobuf:"bytes,6,rep,name=dst_net,json=dstNet" json:"dst_net,omitempty"`
	DstPorts             []*PortRange `protobuf:"bytes,7,rep,name=dst_ports,json=dstPorts" json:"dst_ports,omitempty"`
	DstNamedPortIpSetIds []string     `protobuf:"bytes,13,rep,name=dst_named_port_ip_set_ids,json=dstNamedPortIpSetIds" json:"dst_named_port_ip_set_ids,omitempty"`
	// Types that are valid to be assigned to Icmp:
	//	*Rule_IcmpType
	//	*Rule_IcmpTypeCode
	Icmp        isRule_Icmp `protobuf_oneof:"icmp"`
	SrcIpSetIds []string    `protobuf:"bytes,10,rep,name=src_ip_set_ids,json=srcIpSetIds" json:"src_ip_set_ids,omitempty"`
	DstIpSetIds []string    `protobuf:"bytes,11,rep,name=dst_ip_set_ids,json=dstIpSetIds" json:"dst_ip_set_ids,omitempty"`
	// IP sets on which we should match both IP and port.
	DstIpPortSetIds []string     `protobuf:"bytes,15,rep,name=dst_ip_port_set_ids,json=dstIpPortSetIds" json:"dst_ip_port_set_ids,omitempty"`
	NotProtocol     *Protocol    `protobuf:"bytes,102,opt,name=not_protocol,json=notProtocol" json:"not_protocol,omitempty"`
	NotSrcNet       []string     `protobuf:"bytes,103,rep,name=not_src_net,json=notSrcNet" json:"not_src_net,omitempty"`
	NotSrcPorts     []*PortRange `protobuf:"bytes,104,rep,name=not_src_ports,json=notSrcPorts" json:"not_src_ports,omitempty"`
	NotDstNet       []string     `protobuf:"bytes,105,rep,name=not_dst_net,json=notDstNet" json:"not_dst_net,omitempty"`
	NotDstPorts     []*PortRange `protobuf:"bytes,106,rep,name=not_dst_ports,json=notDstPorts" json:"not_dst_ports,omitempty"`
	// Types that are valid to be assigned to NotIcmp:
	//	*Rule_NotIcmpType
	//	*Rule_NotIcmpTypeCode
	NotIcmp                 isRule_NotIcmp `protobuf_oneof:"not_icmp"`
	NotSrcIpSetIds          []string       `protobuf:"bytes,109,rep,name=not_src_ip_set_ids,json=notSrcIpSetIds" json:"not_src_ip_set_ids,omitempty"`
	NotDstIpSetIds          []string       `protobuf:"bytes,110,rep,name=not_dst_ip_set_ids,json=notDstIpSetIds" json:"not_dst_ip_set_ids,omitempty"`
	NotSrcNamedPortIpSetIds []string       `protobuf:"bytes,112,rep,name=not_src_named_port_ip_set_ids,json=notSrcNamedPortIpSetIds" json:"not_src_named_port_ip_set_ids,omitempty"`
	NotDstNamedPortIpSetIds []string       `protobuf:"bytes,113,rep,name=not_dst_named_port_ip_set_ids,json=notDstNamedPortIpSetIds" json:"not_dst_named_port_ip_set_ids,omitempty"`
	// These fields pass through the original selectors from the v3 datamodel unmodified as required
	// for the policy sync API.
	OriginalSrcSelector          string `protobuf:"bytes,114,opt,name=original_src_selector,json=originalSrcSelector,proto3" json:"original_src_selector,omitempty"`
	OriginalDstSelector          string `protobuf:"bytes,115,opt,name=original_dst_selector,json=originalDstSelector,proto3" json:"original_dst_selector,omitempty"`
	OriginalSrcNamespaceSelector string `protobuf:"bytes,116,opt,name=original_src_namespace_selector,json=originalSrcNamespaceSelector,proto3" json:"original_src_namespace_selector,omitempty"`
	OriginalDstNamespaceSelector string `protobuf:"bytes,117,opt,name=original_dst_namespace_selector,json=originalDstNamespaceSelector,proto3" json:"original_dst_namespace_selector,omitempty"`
	OriginalNotSrcSelector       string `protobuf:"bytes,118,opt,name=original_not_src_selector,json=originalNotSrcSelector,proto3" json:"original_not_src_selector,omitempty"`
	OriginalNotDstSelector       string `protobuf:"bytes,119,opt,name=original_not_dst_selector,json=originalNotDstSelector,proto3" json:"original_not_dst_selector,omitempty"`
	// Original source service match criteria.
	OriginalSrcService          string `protobuf:"bytes,132,opt,name=original_src_service,json=originalSrcService,proto3" json:"original_src_service,omitempty"`
	OriginalSrcServiceNamespace string `protobuf:"bytes,133,opt,name=original_src_service_namespace,json=originalSrcServiceNamespace,proto3" json:"original_src_service_namespace,omitempty"`
	// Original destination service match criteria.
	OriginalDstService          string `protobuf:"bytes,130,opt,name=original_dst_service,json=originalDstService,proto3" json:"original_dst_service,omitempty"`
	OriginalDstServiceNamespace string `protobuf:"bytes,131,opt,name=original_dst_service_namespace,json=originalDstServiceNamespace,proto3" json:"original_dst_service_namespace,omitempty"`
	// Pass through of the v3 datamodel service account match criteria.
	SrcServiceAccountMatch *ServiceAccountMatch `protobuf:"bytes,120,opt,name=src_service_account_match,json=srcServiceAccountMatch" json:"src_service_account_match,omitempty"`
	DstServiceAccountMatch *ServiceAccountMatch `protobuf:"bytes,121,opt,name=dst_service_account_match,json=dstServiceAccountMatch" json:"dst_service_account_match,omitempty"`
	// Pass through of the v3 datamodel HTTP match criteria.
	HttpMatch *HTTPMatch    `protobuf:"bytes,122,opt,name=http_match,json=httpMatch" json:"http_match,omitempty"`
	Metadata  *RuleMetadata `protobuf:"bytes,123,opt,name=metadata" json:"metadata,omitempty"`
	// An opaque ID/hash for the rule.
	RuleId string `protobuf:"bytes,201,opt,name=rule_id,json=ruleId,proto3" json:"rule_id,omitempty"`
}

func (m *Rule) Reset()                    { *m = Rule{} }
func (m *Rule) String() string            { return proto1.CompactTextString(m) }
func (*Rule) ProtoMessage()               {}
func (*Rule) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{17} }

type isRule_Icmp interface {
	isRule_Icmp()
	MarshalTo([]byte) (int, error)
	Size() int
}
type isRule_NotIcmp interface {
	isRule_NotIcmp()
	MarshalTo([]byte) (int, error)
	Size() int
}

type Rule_IcmpType struct {
	IcmpType int32 `protobuf:"varint,8,opt,name=icmp_type,json=icmpType,proto3,oneof"`
}
type Rule_IcmpTypeCode struct {
	IcmpTypeCode *IcmpTypeAndCode `protobuf:"bytes,9,opt,name=icmp_type_code,json=icmpTypeCode,oneof"`
}
type Rule_NotIcmpType struct {
	NotIcmpType int32 `protobuf:"varint,107,opt,name=not_icmp_type,json=notIcmpType,proto3,oneof"`
}
type Rule_NotIcmpTypeCode struct {
	NotIcmpTypeCode *IcmpTypeAndCode `protobuf:"bytes,108,opt,name=not_icmp_type_code,json=notIcmpTypeCode,oneof"`
}

func (*Rule_IcmpType) isRule_Icmp()           {}
func (*Rule_IcmpTypeCode) isRule_Icmp()       {}
func (*Rule_NotIcmpType) isRule_NotIcmp()     {}
func (*Rule_NotIcmpTypeCode) isRule_NotIcmp() {}

func (m *Rule) GetIcmp() isRule_Icmp {
	if m != nil {
		return m.Icmp
	}
	return nil
}
func (m *Rule) GetNotIcmp() isRule_NotIcmp {
	if m != nil {
		return m.NotIcmp
	}
	return nil
}

func (m *Rule) GetAction() string {
	if m != nil {
		return m.Action
	}
	return ""
}

func (m *Rule) GetIpVersion() IPVersion {
	if m != nil {
		return m.IpVersion
	}
	return IPVersion_ANY
}

func (m *Rule) GetProtocol() *Protocol {
	if m != nil {
		return m.Protocol
	}
	return nil
}

func (m *Rule) GetSrcNet() []string {
	if m != nil {
		return m.SrcNet
	}
	return nil
}

func (m *Rule) GetSrcPorts() []*PortRange {
	if m != nil {
		return m.SrcPorts
	}
	return nil
}

func (m *Rule) GetSrcNamedPortIpSetIds() []string {
	if m != nil {
		return m.SrcNamedPortIpSetIds
	}
	return nil
}

func (m *Rule) GetDstNet() []string {
	if m != nil {
		return m.DstNet
	}
	return nil
}

func (m *Rule) GetDstPorts() []*PortRange {
	if m != nil {
		return m.DstPorts
	}
	return nil
}

func (m *Rule) GetDstNamedPortIpSetIds() []string {
	if m != nil {
		return m.DstNamedPortIpSetIds
	}
	return nil
}

func (m *Rule) GetIcmpType() int32 {
	if x, ok := m.GetIcmp().(*Rule_IcmpType); ok {
		return x.IcmpType
	}
	return 0
}

func (m *Rule) GetIcmpTypeCode() *IcmpTypeAndCode {
	if x, ok := m.GetIcmp().(*Rule_IcmpTypeCode); ok {
		return x.IcmpTypeCode
	}
	return nil
}

func (m *Rule) GetSrcIpSetIds() []string {
	if m != nil {
		return m.SrcIpSetIds
	}
	return nil
}

func (m *Rule) GetDstIpSetIds() []string {
	if m != nil {
		return m.DstIpSetIds
	}
	return nil
}

func (m *Rule) GetDstIpPortSetIds() []string {
	if m != nil {
		return m.DstIpPortSetIds
	}
	return nil
}

func (m *Rule) GetNotProtocol() *Protocol {
	if m != nil {
		return m.NotProtocol
	}
	return nil
}

func (m *Rule) GetNotSrcNet() []string {
	if m != nil {
		return m.NotSrcNet
	}
	return nil
}

func (m *Rule) GetNotSrcPorts() []*PortRange {
	if m != nil {
		return m.NotSrcPorts
	}
	return nil
}

func (m *Rule) GetNotDstNet() []string {
	if m != nil {
		return m.NotDstNet
	}
	return nil
}

func (m *Rule) GetNotDstPorts() []*PortRange {
	if m != nil {
		return m.NotDstPorts
	}
	return nil
}

func (m *Rule) GetNotIcmpType() int32 {
	if x, ok := m.GetNotIcmp().(*Rule_NotIcmpType); ok {
		return x.NotIcmpType
	}
	return 0
}

func (m *Rule) GetNotIcmpTypeCode() *IcmpTypeAndCode {
	if x, ok := m.GetNotIcmp().(*Rule_NotIcmpTypeCode); ok {
		return x.NotIcmpTypeCode
	}
	return nil
}

func (m *Rule) GetNotSrcIpSetIds() []string {
	if m != nil {
		return m.NotSrcIpSetIds
	}
	return nil
}

func (m *Rule) GetNotDstIpSetIds() []string {
	if m != nil {
		return m.NotDstIpSetIds
	}
	return nil
}

func (m *Rule) GetNotSrcNamedPortIpSetIds() []string {
	if m != nil {
		return m.NotSrcNamedPortIpSetIds
	}
	return nil
}

func (m *Rule) GetNotDstNamedPortIpSetIds() []string {
	if m != nil {
		return m.NotDstNamedPortIpSetIds
	}
	return nil
}

func (m *Rule) GetOriginalSrcSelector() string {
	if m != nil {
		return m.OriginalSrcSelector
	}
	return ""
}

func (m *Rule) GetOriginalDstSelector() string {
	if m != nil {
		return m.OriginalDstSelector
	}
	return ""
}

func (m *Rule) GetOriginalSrcNamespaceSelector() string {
	if m != nil {
		return m.OriginalSrcNamespaceSelector
	}
	return ""
}

func (m *Rule) GetOriginalDstNamespaceSelector() string {
	if m != nil {
		return m.OriginalDstNamespaceSelector
	}
	return ""
}

func (m *Rule) GetOriginalNotSrcSelector() string {
	if m != nil {
		return m.OriginalNotSrcSelector
	}
	return ""
}

func (m *Rule) GetOriginalNotDstSelector() string {
	if m != nil {
		return m.OriginalNotDstSelector
	}
	return ""
}

func (m *Rule) GetOriginalSrcService() string {
	if m != nil {
		return m.OriginalSrcService
	}
	return ""
}

func (m *Rule) GetOriginalSrcServiceNamespace() string {
	if m != nil {
		return m.OriginalSrcServiceNamespace
	}
	return ""
}

func (m *Rule) GetOriginalDstService() string {
	if m != nil {
		return m.OriginalDstService
	}
	return ""
}

func (m *Rule) GetOriginalDstServiceNamespace() string {
	if m != nil {
		return m.OriginalDstServiceNamespace
	}
	return ""
}

func (m *Rule) GetSrcServiceAccountMatch() *ServiceAccountMatch {
	if m != nil {
		return m.SrcServiceAccountMatch
	}
	return nil
}

func (m *Rule) GetDstServiceAccountMatch() *ServiceAccountMatch {
	if m != nil {
		return m.DstServiceAccountMatch
	}
	return nil
}

func (m *Rule) GetHttpMatch() *HTTPMatch {
	if m != nil {
		return m.HttpMatch
	}
	return nil
}

func (m *Rule) GetMetadata() *RuleMetadata {
	if m != nil {
		return m.Metadata
	}
	return nil
}

func (m *Rule) GetRuleId() string {
	if m != nil {
		return m.RuleId
	}
	return ""
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*Rule) XXX_OneofFuncs() (func(msg proto1.Message, b *proto1.Buffer) error, func(msg proto1.Message, tag, wire int, b *proto1.Buffer) (bool, error), func(msg proto1.Message) (n int), []interface{}) {
	return _Rule_OneofMarshaler, _Rule_OneofUnmarshaler, _Rule_OneofSizer, []interface{}{
		(*Rule_IcmpType)(nil),
		(*Rule_IcmpTypeCode)(nil),
		(*Rule_NotIcmpType)(nil),
		(*Rule_NotIcmpTypeCode)(nil),
	}
}

func _Rule_OneofMarshaler(msg proto1.Message, b *proto1.Buffer) error {
	m := msg.(*Rule)
	// icmp
	switch x := m.Icmp.(type) {
	case *Rule_IcmpType:
		_ = b.EncodeVarint(8<<3 | proto1.WireVarint)
		_ = b.EncodeVarint(uint64(x.IcmpType))
	case *Rule_IcmpTypeCode:
		_ = b.EncodeVarint(9<<3 | proto1.WireBytes)
		if err := b.EncodeMessage(x.IcmpTypeCode); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("Rule.Icmp has unexpected type %T", x)
	}
	// not_icmp
	switch x := m.NotIcmp.(type) {
	case *Rule_NotIcmpType:
		_ = b.EncodeVarint(107<<3 | proto1.WireVarint)
		_ = b.EncodeVarint(uint64(x.NotIcmpType))
	case *Rule_NotIcmpTypeCode:
		_ = b.EncodeVarint(108<<3 | proto1.WireBytes)
		if err := b.EncodeMessage(x.NotIcmpTypeCode); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("Rule.NotIcmp has unexpected type %T", x)
	}
	return nil
}

func _Rule_OneofUnmarshaler(msg proto1.Message, tag, wire int, b *proto1.Buffer) (bool, error) {
	m := msg.(*Rule)
	switch tag {
	case 8: // icmp.icmp_type
		if wire != proto1.WireVarint {
			return true, proto1.ErrInternalBadWireType
		}
		x, err := b.DecodeVarint()
		m.Icmp = &Rule_IcmpType{int32(x)}
		return true, err
	case 9: // icmp.icmp_type_code
		if wire != proto1.WireBytes {
			return true, proto1.ErrInternalBadWireType
		}
		msg := new(IcmpTypeAndCode)
		err := b.DecodeMessage(msg)
		m.Icmp = &Rule_IcmpTypeCode{msg}
		return true, err
	case 107: // not_icmp.not_icmp_type
		if wire != proto1.WireVarint {
			return true, proto1.ErrInternalBadWireType
		}
		x, err := b.DecodeVarint()
		m.NotIcmp = &Rule_NotIcmpType{int32(x)}
		return true, err
	case 108: // not_icmp.not_icmp_type_code
		if wire != proto1.WireBytes {
			return true, proto1.ErrInternalBadWireType
		}
		msg := new(IcmpTypeAndCode)
		err := b.DecodeMessage(msg)
		m.NotIcmp = &Rule_NotIcmpTypeCode{msg}
		return true, err
	default:
		return false, nil
	}
}

func _Rule_OneofSizer(msg proto1.Message) (n int) {
	m := msg.(*Rule)
	// icmp
	switch x := m.Icmp.(type) {
	case *Rule_IcmpType:
		n += proto1.SizeVarint(8<<3 | proto1.WireVarint)
		n += proto1.SizeVarint(uint64(x.IcmpType))
	case *Rule_IcmpTypeCode:
		s := proto1.Size(x.IcmpTypeCode)
		n += proto1.SizeVarint(9<<3 | proto1.WireBytes)
		n += proto1.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	// not_icmp
	switch x := m.NotIcmp.(type) {
	case *Rule_NotIcmpType:
		n += proto1.SizeVarint(107<<3 | proto1.WireVarint)
		n += proto1.SizeVarint(uint64(x.NotIcmpType))
	case *Rule_NotIcmpTypeCode:
		s := proto1.Size(x.NotIcmpTypeCode)
		n += proto1.SizeVarint(108<<3 | proto1.WireBytes)
		n += proto1.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

type ServiceAccountMatch struct {
	Selector string   `protobuf:"bytes,1,opt,name=selector,proto3" json:"selector,omitempty"`
	Names    []string `protobuf:"bytes,2,rep,name=names" json:"names,omitempty"`
}

func (m *ServiceAccountMatch) Reset()         { *m = ServiceAccountMatch{} }
func (m *ServiceAccountMatch) String() string { return proto1.CompactTextString(m) }
func (*ServiceAccountMatch) ProtoMessage()    {}
func (*ServiceAccountMatch) Descriptor() ([]byte, []int) {
	return fileDescriptorFelixbackend, []int{18}
}

func (m *ServiceAccountMatch) GetSelector() string {
	if m != nil {
		return m.Selector
	}
	return ""
}

func (m *ServiceAccountMatch) GetNames() []string {
	if m != nil {
		return m.Names
	}
	return nil
}

type HTTPMatch struct {
	Methods []string               `protobuf:"bytes,1,rep,name=methods" json:"methods,omitempty"`
	Paths   []*HTTPMatch_PathMatch `protobuf:"bytes,2,rep,name=paths" json:"paths,omitempty"`
}

func (m *HTTPMatch) Reset()                    { *m = HTTPMatch{} }
func (m *HTTPMatch) String() string            { return proto1.CompactTextString(m) }
func (*HTTPMatch) ProtoMessage()               {}
func (*HTTPMatch) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{19} }

func (m *HTTPMatch) GetMethods() []string {
	if m != nil {
		return m.Methods
	}
	return nil
}

func (m *HTTPMatch) GetPaths() []*HTTPMatch_PathMatch {
	if m != nil {
		return m.Paths
	}
	return nil
}

type HTTPMatch_PathMatch struct {
	// Types that are valid to be assigned to PathMatch:
	//	*HTTPMatch_PathMatch_Exact
	//	*HTTPMatch_PathMatch_Prefix
	PathMatch isHTTPMatch_PathMatch_PathMatch `protobuf_oneof:"path_match"`
}

func (m *HTTPMatch_PathMatch) Reset()         { *m = HTTPMatch_PathMatch{} }
func (m *HTTPMatch_PathMatch) String() string { return proto1.CompactTextString(m) }
func (*HTTPMatch_PathMatch) ProtoMessage()    {}
func (*HTTPMatch_PathMatch) Descriptor() ([]byte, []int) {
	return fileDescriptorFelixbackend, []int{19, 0}
}

type isHTTPMatch_PathMatch_PathMatch interface {
	isHTTPMatch_PathMatch_PathMatch()
	MarshalTo([]byte) (int, error)
	Size() int
}

type HTTPMatch_PathMatch_Exact struct {
	Exact string `protobuf:"bytes,1,opt,name=exact,proto3,oneof"`
}
type HTTPMatch_PathMatch_Prefix struct {
	Prefix string `protobuf:"bytes,2,opt,name=prefix,proto3,oneof"`
}

func (*HTTPMatch_PathMatch_Exact) isHTTPMatch_PathMatch_PathMatch()  {}
func (*HTTPMatch_PathMatch_Prefix) isHTTPMatch_PathMatch_PathMatch() {}

func (m *HTTPMatch_PathMatch) GetPathMatch() isHTTPMatch_PathMatch_PathMatch {
	if m != nil {
		return m.PathMatch
	}
	return nil
}

func (m *HTTPMatch_PathMatch) GetExact() string {
	if x, ok := m.GetPathMatch().(*HTTPMatch_PathMatch_Exact); ok {
		return x.Exact
	}
	return ""
}

func (m *HTTPMatch_PathMatch) GetPrefix() string {
	if x, ok := m.GetPathMatch().(*HTTPMatch_PathMatch_Prefix); ok {
		return x.Prefix
	}
	return ""
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*HTTPMatch_PathMatch) XXX_OneofFuncs() (func(msg proto1.Message, b *proto1.Buffer) error, func(msg proto1.Message, tag, wire int, b *proto1.Buffer) (bool, error), func(msg proto1.Message) (n int), []interface{}) {
	return _HTTPMatch_PathMatch_OneofMarshaler, _HTTPMatch_PathMatch_OneofUnmarshaler, _HTTPMatch_PathMatch_OneofSizer, []interface{}{
		(*HTTPMatch_PathMatch_Exact)(nil),
		(*HTTPMatch_PathMatch_Prefix)(nil),
	}
}

func _HTTPMatch_PathMatch_OneofMarshaler(msg proto1.Message, b *proto1.Buffer) error {
	m := msg.(*HTTPMatch_PathMatch)
	// path_match
	switch x := m.PathMatch.(type) {
	case *HTTPMatch_PathMatch_Exact:
		_ = b.EncodeVarint(1<<3 | proto1.WireBytes)
		_ = b.EncodeStringBytes(x.Exact)
	case *HTTPMatch_PathMatch_Prefix:
		_ = b.EncodeVarint(2<<3 | proto1.WireBytes)
		_ = b.EncodeStringBytes(x.Prefix)
	case nil:
	default:
		return fmt.Errorf("HTTPMatch_PathMatch.PathMatch has unexpected type %T", x)
	}
	return nil
}

func _HTTPMatch_PathMatch_OneofUnmarshaler(msg proto1.Message, tag, wire int, b *proto1.Buffer) (bool, error) {
	m := msg.(*HTTPMatch_PathMatch)
	switch tag {
	case 1: // path_match.exact
		if wire != proto1.WireBytes {
			return true, proto1.ErrInternalBadWireType
		}
		x, err := b.DecodeStringBytes()
		m.PathMatch = &HTTPMatch_PathMatch_Exact{x}
		return true, err
	case 2: // path_match.prefix
		if wire != proto1.WireBytes {
			return true, proto1.ErrInternalBadWireType
		}
		x, err := b.DecodeStringBytes()
		m.PathMatch = &HTTPMatch_PathMatch_Prefix{x}
		return true, err
	default:
		return false, nil
	}
}

func _HTTPMatch_PathMatch_OneofSizer(msg proto1.Message) (n int) {
	m := msg.(*HTTPMatch_PathMatch)
	// path_match
	switch x := m.PathMatch.(type) {
	case *HTTPMatch_PathMatch_Exact:
		n += proto1.SizeVarint(1<<3 | proto1.WireBytes)
		n += proto1.SizeVarint(uint64(len(x.Exact)))
		n += len(x.Exact)
	case *HTTPMatch_PathMatch_Prefix:
		n += proto1.SizeVarint(2<<3 | proto1.WireBytes)
		n += proto1.SizeVarint(uint64(len(x.Prefix)))
		n += len(x.Prefix)
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

type RuleMetadata struct {
	Annotations map[string]string `protobuf:"bytes,1,rep,name=annotations" json:"annotations,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}

func (m *RuleMetadata) Reset()                    { *m = RuleMetadata{} }
func (m *RuleMetadata) String() string            { return proto1.CompactTextString(m) }
func (*RuleMetadata) ProtoMessage()               {}
func (*RuleMetadata) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{20} }

func (m *RuleMetadata) GetAnnotations() map[string]string {
	if m != nil {
		return m.Annotations
	}
	return nil
}

type IcmpTypeAndCode struct {
	Type int32 `protobuf:"varint,1,opt,name=type,proto3" json:"type,omitempty"`
	Code int32 `protobuf:"varint,2,opt,name=code,proto3" json:"code,omitempty"`
}

func (m *IcmpTypeAndCode) Reset()                    { *m = IcmpTypeAndCode{} }
func (m *IcmpTypeAndCode) String() string            { return proto1.CompactTextString(m) }
func (*IcmpTypeAndCode) ProtoMessage()               {}
func (*IcmpTypeAndCode) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{21} }

func (m *IcmpTypeAndCode) GetType() int32 {
	if m != nil {
		return m.Type
	}
	return 0
}

func (m *IcmpTypeAndCode) GetCode() int32 {
	if m != nil {
		return m.Code
	}
	return 0
}

type Protocol struct {
	// Types that are valid to be assigned to NumberOrName:
	//	*Protocol_Number
	//	*Protocol_Name
	NumberOrName isProtocol_NumberOrName `protobuf_oneof:"number_or_name"`
}

func (m *Protocol) Reset()                    { *m = Protocol{} }
func (m *Protocol) String() string            { return proto1.CompactTextString(m) }
func (*Protocol) ProtoMessage()               {}
func (*Protocol) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{22} }

type isProtocol_NumberOrName interface {
	isProtocol_NumberOrName()
	MarshalTo([]byte) (int, error)
	Size() int
}

type Protocol_Number struct {
	Number int32 `protobuf:"varint,1,opt,name=number,proto3,oneof"`
}
type Protocol_Name struct {
	Name string `protobuf:"bytes,2,opt,name=name,proto3,oneof"`
}

func (*Protocol_Number) isProtocol_NumberOrName() {}
func (*Protocol_Name) isProtocol_NumberOrName()   {}

func (m *Protocol) GetNumberOrName() isProtocol_NumberOrName {
	if m != nil {
		return m.NumberOrName
	}
	return nil
}

func (m *Protocol) GetNumber() int32 {
	if x, ok := m.GetNumberOrName().(*Protocol_Number); ok {
		return x.Number
	}
	return 0
}

func (m *Protocol) GetName() string {
	if x, ok := m.GetNumberOrName().(*Protocol_Name); ok {
		return x.Name
	}
	return ""
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*Protocol) XXX_OneofFuncs() (func(msg proto1.Message, b *proto1.Buffer) error, func(msg proto1.Message, tag, wire int, b *proto1.Buffer) (bool, error), func(msg proto1.Message) (n int), []interface{}) {
	return _Protocol_OneofMarshaler, _Protocol_OneofUnmarshaler, _Protocol_OneofSizer, []interface{}{
		(*Protocol_Number)(nil),
		(*Protocol_Name)(nil),
	}
}

func _Protocol_OneofMarshaler(msg proto1.Message, b *proto1.Buffer) error {
	m := msg.(*Protocol)
	// number_or_name
	switch x := m.NumberOrName.(type) {
	case *Protocol_Number:
		_ = b.EncodeVarint(1<<3 | proto1.WireVarint)
		_ = b.EncodeVarint(uint64(x.Number))
	case *Protocol_Name:
		_ = b.EncodeVarint(2<<3 | proto1.WireBytes)
		_ = b.EncodeStringBytes(x.Name)
	case nil:
	default:
		return fmt.Errorf("Protocol.NumberOrName has unexpected type %T", x)
	}
	return nil
}

func _Protocol_OneofUnmarshaler(msg proto1.Message, tag, wire int, b *proto1.Buffer) (bool, error) {
	m := msg.(*Protocol)
	switch tag {
	case 1: // number_or_name.number
		if wire != proto1.WireVarint {
			return true, proto1.ErrInternalBadWireType
		}
		x, err := b.DecodeVarint()
		m.NumberOrName = &Protocol_Number{int32(x)}
		return true, err
	case 2: // number_or_name.name
		if wire != proto1.WireBytes {
			return true, proto1.ErrInternalBadWireType
		}
		x, err := b.DecodeStringBytes()
		m.NumberOrName = &Protocol_Name{x}
		return true, err
	default:
		return false, nil
	}
}

func _Protocol_OneofSizer(msg proto1.Message) (n int) {
	m := msg.(*Protocol)
	// number_or_name
	switch x := m.NumberOrName.(type) {
	case *Protocol_Number:
		n += proto1.SizeVarint(1<<3 | proto1.WireVarint)
		n += proto1.SizeVarint(uint64(x.Number))
	case *Protocol_Name:
		n += proto1.SizeVarint(2<<3 | proto1.WireBytes)
		n += proto1.SizeVarint(uint64(len(x.Name)))
		n += len(x.Name)
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

// Individual ports are sent with first == last.
type PortRange struct {
	First int32 `protobuf:"varint,1,opt,name=first,proto3" json:"first,omitempty"`
	Last  int32 `protobuf:"varint,2,opt,name=last,proto3" json:"last,omitempty"`
}

func (m *PortRange) Reset()                    { *m = PortRange{} }
func (m *PortRange) String() string            { return proto1.CompactTextString(m) }
func (*PortRange) ProtoMessage()               {}
func (*PortRange) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{23} }

func (m *PortRange) GetFirst() int32 {
	if m != nil {
		return m.First
	}
	return 0
}

func (m *PortRange) GetLast() int32 {
	if m != nil {
		return m.Last
	}
	return 0
}

type WorkloadEndpointID struct {
	OrchestratorId string `protobuf:"bytes,2,opt,name=orchestrator_id,json=orchestratorId,proto3" json:"orchestrator_id,omitempty"`
	WorkloadId     string `protobuf:"bytes,3,opt,name=workload_id,json=workloadId,proto3" json:"workload_id,omitempty"`
	EndpointId     string `protobuf:"bytes,4,opt,name=endpoint_id,json=endpointId,proto3" json:"endpoint_id,omitempty"`
}

func (m *WorkloadEndpointID) Reset()                    { *m = WorkloadEndpointID{} }
func (m *WorkloadEndpointID) String() string            { return proto1.CompactTextString(m) }
func (*WorkloadEndpointID) ProtoMessage()               {}
func (*WorkloadEndpointID) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{24} }

func (m *WorkloadEndpointID) GetOrchestratorId() string {
	if m != nil {
		return m.OrchestratorId
	}
	return ""
}

func (m *WorkloadEndpointID) GetWorkloadId() string {
	if m != nil {
		return m.WorkloadId
	}
	return ""
}

func (m *WorkloadEndpointID) GetEndpointId() string {
	if m != nil {
		return m.EndpointId
	}
	return ""
}

type WorkloadEndpointUpdate struct {
	Id       *WorkloadEndpointID `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
	Endpoint *WorkloadEndpoint   `protobuf:"bytes,5,opt,name=endpoint" json:"endpoint,omitempty"`
}

func (m *WorkloadEndpointUpdate) Reset()         { *m = WorkloadEndpointUpdate{} }
func (m *WorkloadEndpointUpdate) String() string { return proto1.CompactTextString(m) }
func (*WorkloadEndpointUpdate) ProtoMessage()    {}
func (*WorkloadEndpointUpdate) Descriptor() ([]byte, []int) {
	return fileDescriptorFelixbackend, []int{25}
}

func (m *WorkloadEndpointUpdate) GetId() *WorkloadEndpointID {
	if m != nil {
		return m.Id
	}
	return nil
}

func (m *WorkloadEndpointUpdate) GetEndpoint() *WorkloadEndpoint {
	if m != nil {
		return m.Endpoint
	}
	return nil
}

type WorkloadEndpoint struct {
	State                      string            `protobuf:"bytes,1,opt,name=state,proto3" json:"state,omitempty"`
	Name                       string            `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	Mac                        string            `protobuf:"bytes,3,opt,name=mac,proto3" json:"mac,omitempty"`
	ProfileIds                 []string          `protobuf:"bytes,4,rep,name=profile_ids,json=profileIds" json:"profile_ids,omitempty"`
	Ipv4Nets                   []string          `protobuf:"bytes,5,rep,name=ipv4_nets,json=ipv4Nets" json:"ipv4_nets,omitempty"`
	Ipv6Nets                   []string          `protobuf:"bytes,6,rep,name=ipv6_nets,json=ipv6Nets" json:"ipv6_nets,omitempty"`
	Tiers                      []*TierInfo       `protobuf:"bytes,7,rep,name=tiers" json:"tiers,omitempty"`
	Ipv4Nat                    []*NatInfo        `protobuf:"bytes,8,rep,name=ipv4_nat,json=ipv4Nat" json:"ipv4_nat,omitempty"`
	Ipv6Nat                    []*NatInfo        `protobuf:"bytes,9,rep,name=ipv6_nat,json=ipv6Nat" json:"ipv6_nat,omitempty"`
	AllowSpoofedSourcePrefixes []string          `protobuf:"bytes,10,rep,name=allow_spoofed_source_prefixes,json=allowSpoofedSourcePrefixes" json:"allow_spoofed_source_prefixes,omitempty"`
	Annotations                map[string]string `protobuf:"bytes,11,rep,name=annotations" json:"annotations,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}

func (m *WorkloadEndpoint) Reset()                    { *m = WorkloadEndpoint{} }
func (m *WorkloadEndpoint) String() string            { return proto1.CompactTextString(m) }
func (*WorkloadEndpoint) ProtoMessage()               {}
func (*WorkloadEndpoint) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{26} }

func (m *WorkloadEndpoint) GetState() string {
	if m != nil {
		return m.State
	}
	return ""
}

func (m *WorkloadEndpoint) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *WorkloadEndpoint) GetMac() string {
	if m != nil {
		return m.Mac
	}
	return ""
}

func (m *WorkloadEndpoint) GetProfileIds() []string {
	if m != nil {
		return m.ProfileIds
	}
	return nil
}

func (m *WorkloadEndpoint) GetIpv4Nets() []string {
	if m != nil {
		return m.Ipv4Nets
	}
	return nil
}

func (m *WorkloadEndpoint) GetIpv6Nets() []string {
	if m != nil {
		return m.Ipv6Nets
	}
	return nil
}

func (m *WorkloadEndpoint) GetTiers() []*TierInfo {
	if m != nil {
		return m.Tiers
	}
	return nil
}

func (m *WorkloadEndpoint) GetIpv4Nat() []*NatInfo {
	if m != nil {
		return m.Ipv4Nat
	}
	return nil
}

func (m *WorkloadEndpoint) GetIpv6Nat() []*NatInfo {
	if m != nil {
		return m.Ipv6Nat
	}
	return nil
}

func (m *WorkloadEndpoint) GetAllowSpoofedSourcePrefixes() []string {
	if m != nil {
		return m.AllowSpoofedSourcePrefixes
	}
	return nil
}

func (m *WorkloadEndpoint) GetAnnotations() map[string]string {
	if m != nil {
		return m.Annotations
	}
	return nil
}

type WorkloadEndpointRemove struct {
	Id *WorkloadEndpointID `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
}

func (m *WorkloadEndpointRemove) Reset()         { *m = WorkloadEndpointRemove{} }
func (m *WorkloadEndpointRemove) String() string { return proto1.CompactTextString(m) }
func (*WorkloadEndpointRemove) ProtoMessage()    {}
func (*WorkloadEndpointRemove) Descriptor() ([]byte, []int) {
	return fileDescriptorFelixbackend, []int{27}
}

func (m *WorkloadEndpointRemove) GetId() *WorkloadEndpointID {
	if m != nil {
		return m.Id
	}
	return nil
}

type HostEndpointID struct {
	EndpointId string `protobuf:"bytes,2,opt,name=endpoint_id,json=endpointId,proto3" json:"endpoint_id,omitempty"`
}

func (m *HostEndpointID) Reset()                    { *m = HostEndpointID{} }
func (m *HostEndpointID) String() string            { return proto1.CompactTextString(m) }
func (*HostEndpointID) ProtoMessage()               {}
func (*HostEndpointID) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{28} }

func (m *HostEndpointID) GetEndpointId() string {
	if m != nil {
		return m.EndpointId
	}
	return ""
}

type HostEndpointUpdate struct {
	Id       *HostEndpointID `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
	Endpoint *HostEndpoint   `protobuf:"bytes,3,opt,name=endpoint" json:"endpoint,omitempty"`
}

func (m *HostEndpointUpdate) Reset()                    { *m = HostEndpointUpdate{} }
func (m *HostEndpointUpdate) String() string            { return proto1.CompactTextString(m) }
func (*HostEndpointUpdate) ProtoMessage()               {}
func (*HostEndpointUpdate) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{29} }

func (m *HostEndpointUpdate) GetId() *HostEndpointID {
	if m != nil {
		return m.Id
	}
	return nil
}

func (m *HostEndpointUpdate) GetEndpoint() *HostEndpoint {
	if m != nil {
		return m.Endpoint
	}
	return nil
}

type HostEndpoint struct {
	Name              string      `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	ProfileIds        []string    `protobuf:"bytes,2,rep,name=profile_ids,json=profileIds" json:"profile_ids,omitempty"`
	Tiers             []*TierInfo `protobuf:"bytes,3,rep,name=tiers" json:"tiers,omitempty"`
	UntrackedTiers    []*TierInfo `protobuf:"bytes,6,rep,name=untracked_tiers,json=untrackedTiers" json:"untracked_tiers,omitempty"`
	PreDnatTiers      []*TierInfo `protobuf:"bytes,7,rep,name=pre_dnat_tiers,json=preDnatTiers" json:"pre_dnat_tiers,omitempty"`
	ForwardTiers      []*TierInfo `protobuf:"bytes,8,rep,name=forward_tiers,json=forwardTiers" json:"forward_tiers,omitempty"`
	ExpectedIpv4Addrs []string    `protobuf:"bytes,4,rep,name=expected_ipv4_addrs,json=expectedIpv4Addrs" json:"expected_ipv4_addrs,omitempty"`
	ExpectedIpv6Addrs []string    `protobuf:"bytes,5,rep,name=expected_ipv6_addrs,json=expectedIpv6Addrs" json:"expected_ipv6_addrs,omitempty"`
}

func (m *HostEndpoint) Reset()                    { *m = HostEndpoint{} }
func (m *HostEndpoint) String() string            { return proto1.CompactTextString(m) }
func (*HostEndpoint) ProtoMessage()               {}
func (*HostEndpoint) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{30} }

func (m *HostEndpoint) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *HostEndpoint) GetProfileIds() []string {
	if m != nil {
		return m.ProfileIds
	}
	return nil
}

func (m *HostEndpoint) GetTiers() []*TierInfo {
	if m != nil {
		return m.Tiers
	}
	return nil
}

func (m *HostEndpoint) GetUntrackedTiers() []*TierInfo {
	if m != nil {
		return m.UntrackedTiers
	}
	return nil
}

func (m *HostEndpoint) GetPreDnatTiers() []*TierInfo {
	if m != nil {
		return m.PreDnatTiers
	}
	return nil
}

func (m *HostEndpoint) GetForwardTiers() []*TierInfo {
	if m != nil {
		return m.ForwardTiers
	}
	return nil
}

func (m *HostEndpoint) GetExpectedIpv4Addrs() []string {
	if m != nil {
		return m.ExpectedIpv4Addrs
	}
	return nil
}

func (m *HostEndpoint) GetExpectedIpv6Addrs() []string {
	if m != nil {
		return m.ExpectedIpv6Addrs
	}
	return nil
}

type HostEndpointRemove struct {
	Id *HostEndpointID `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
}

func (m *HostEndpointRemove) Reset()                    { *m = HostEndpointRemove{} }
func (m *HostEndpointRemove) String() string            { return proto1.CompactTextString(m) }
func (*HostEndpointRemove) ProtoMessage()               {}
func (*HostEndpointRemove) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{31} }

func (m *HostEndpointRemove) GetId() *HostEndpointID {
	if m != nil {
		return m.Id
	}
	return nil
}

type TierInfo struct {
	Name            string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	IngressPolicies []string `protobuf:"bytes,2,rep,name=ingress_policies,json=ingressPolicies" json:"ingress_policies,omitempty"`
	EgressPolicies  []string `protobuf:"bytes,3,rep,name=egress_policies,json=egressPolicies" json:"egress_policies,omitempty"`
	DefaultAction   string   `protobuf:"bytes,4,opt,name=default_action,json=defaultAction,proto3" json:"default_action,omitempty"`
}

func (m *TierInfo) Reset()                    { *m = TierInfo{} }
func (m *TierInfo) String() string            { return proto1.CompactTextString(m) }
func (*TierInfo) ProtoMessage()               {}
func (*TierInfo) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{32} }

func (m *TierInfo) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *TierInfo) GetIngressPolicies() []string {
	if m != nil {
		return m.IngressPolicies
	}
	return nil
}

func (m *TierInfo) GetEgressPolicies() []string {
	if m != nil {
		return m.EgressPolicies
	}
	return nil
}

func (m *TierInfo) GetDefaultAction() string {
	if m != nil {
		return m.DefaultAction
	}
	return ""
}

type NatInfo struct {
	ExtIp string `protobuf:"bytes,1,opt,name=ext_ip,json=extIp,proto3" json:"ext_ip,omitempty"`
	IntIp string `protobuf:"bytes,2,opt,name=int_ip,json=intIp,proto3" json:"int_ip,omitempty"`
}

func (m *NatInfo) Reset()                    { *m = NatInfo{} }
func (m *NatInfo) String() string            { return proto1.CompactTextString(m) }
func (*NatInfo) ProtoMessage()               {}
func (*NatInfo) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{33} }

func (m *NatInfo) GetExtIp() string {
	if m != nil {
		return m.ExtIp
	}
	return ""
}

func (m *NatInfo) GetIntIp() string {
	if m != nil {
		return m.IntIp
	}
	return ""
}

type ProcessStatusUpdate struct {
	IsoTimestamp string  `protobuf:"bytes,1,opt,name=iso_timestamp,json=isoTimestamp,proto3" json:"iso_timestamp,omitempty"`
	Uptime       float64 `protobuf:"fixed64,2,opt,name=uptime,proto3" json:"uptime,omitempty"`
}

func (m *ProcessStatusUpdate) Reset()         { *m = ProcessStatusUpdate{} }
func (m *ProcessStatusUpdate) String() string { return proto1.CompactTextString(m) }
func (*ProcessStatusUpdate) ProtoMessage()    {}
func (*ProcessStatusUpdate) Descriptor() ([]byte, []int) {
	return fileDescriptorFelixbackend, []int{34}
}

func (m *ProcessStatusUpdate) GetIsoTimestamp() string {
	if m != nil {
		return m.IsoTimestamp
	}
	return ""
}

func (m *ProcessStatusUpdate) GetUptime() float64 {
	if m != nil {
		return m.Uptime
	}
	return 0
}

type HostEndpointStatusUpdate struct {
	Id     *HostEndpointID `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
	Status *EndpointStatus `protobuf:"bytes,2,opt,name=status" json:"status,omitempty"`
}

func (m *HostEndpointStatusUpdate) Reset()         { *m = HostEndpointStatusUpdate{} }
func (m *HostEndpointStatusUpdate) String() string { return proto1.CompactTextString(m) }
func (*HostEndpointStatusUpdate) ProtoMessage()    {}
func (*HostEndpointStatusUpdate) Descriptor() ([]byte, []int) {
	return fileDescriptorFelixbackend, []int{35}
}

func (m *HostEndpointStatusUpdate) GetId() *HostEndpointID {
	if m != nil {
		return m.Id
	}
	return nil
}

func (m *HostEndpointStatusUpdate) GetStatus() *EndpointStatus {
	if m != nil {
		return m.Status
	}
	return nil
}

type EndpointStatus struct {
	Status string `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
}

func (m *EndpointStatus) Reset()                    { *m = EndpointStatus{} }
func (m *EndpointStatus) String() string            { return proto1.CompactTextString(m) }
func (*EndpointStatus) ProtoMessage()               {}
func (*EndpointStatus) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{36} }

func (m *EndpointStatus) GetStatus() string {
	if m != nil {
		return m.Status
	}
	return ""
}

type HostEndpointStatusRemove struct {
	Id *HostEndpointID `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
}

func (m *HostEndpointStatusRemove) Reset()         { *m = HostEndpointStatusRemove{} }
func (m *HostEndpointStatusRemove) String() string { return proto1.CompactTextString(m) }
func (*HostEndpointStatusRemove) ProtoMessage()    {}
func (*HostEndpointStatusRemove) Descriptor() ([]byte, []int) {
	return fileDescriptorFelixbackend, []int{37}
}

func (m *HostEndpointStatusRemove) GetId() *HostEndpointID {
	if m != nil {
		return m.Id
	}
	return nil
}

type WorkloadEndpointStatusUpdate struct {
	Id     *WorkloadEndpointID `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
	Status *EndpointStatus     `protobuf:"bytes,2,opt,name=status" json:"status,omitempty"`
}

func (m *WorkloadEndpointStatusUpdate) Reset()         { *m = WorkloadEndpointStatusUpdate{} }
func (m *WorkloadEndpointStatusUpdate) String() string { return proto1.CompactTextString(m) }
func (*WorkloadEndpointStatusUpdate) ProtoMessage()    {}
func (*WorkloadEndpointStatusUpdate) Descriptor() ([]byte, []int) {
	return fileDescriptorFelixbackend, []int{38}
}

func (m *WorkloadEndpointStatusUpdate) GetId() *WorkloadEndpointID {
	if m != nil {
		return m.Id
	}
	return nil
}

func (m *WorkloadEndpointStatusUpdate) GetStatus() *EndpointStatus {
	if m != nil {
		return m.Status
	}
	return nil
}

type WorkloadEndpointStatusRemove struct {
	Id *WorkloadEndpointID `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
}

func (m *WorkloadEndpointStatusRemove) Reset()         { *m = WorkloadEndpointStatusRemove{} }
func (m *WorkloadEndpointStatusRemove) String() string { return proto1.CompactTextString(m) }
func (*WorkloadEndpointStatusRemove) ProtoMessage()    {}
func (*WorkloadEndpointStatusRemove) Descriptor() ([]byte, []int) {
	return fileDescriptorFelixbackend, []int{39}
}

func (m *WorkloadEndpointStatusRemove) GetId() *WorkloadEndpointID {
	if m != nil {
		return m.Id
	}
	return nil
}

type WireguardStatusUpdate struct {
	// Wireguard public-key set on the interface.
	PublicKey string `protobuf:"bytes,1,opt,name=public_key,json=publicKey,proto3" json:"public_key,omitempty"`
	// The IP version of this update
	IpVersion IPVersion `protobuf:"varint,2,opt,name=ip_version,json=ipVersion,proto3,enum=felix.IPVersion" json:"ip_version,omitempty"`
}

func (m *WireguardStatusUpdate) Reset()         { *m = WireguardStatusUpdate{} }
func (m *WireguardStatusUpdate) String() string { return proto1.CompactTextString(m) }
func (*WireguardStatusUpdate) ProtoMessage()    {}
func (*WireguardStatusUpdate) Descriptor() ([]byte, []int) {
	return fileDescriptorFelixbackend, []int{40}
}

func (m *WireguardStatusUpdate) GetPublicKey() string {
	if m != nil {
		return m.PublicKey
	}
	return ""
}

func (m *WireguardStatusUpdate) GetIpVersion() IPVersion {
	if m != nil {
		return m.IpVersion
	}
	return IPVersion_ANY
}

type DataplaneInSync struct {
}

func (m *DataplaneInSync) Reset()                    { *m = DataplaneInSync{} }
func (m *DataplaneInSync) String() string            { return proto1.CompactTextString(m) }
func (*DataplaneInSync) ProtoMessage()               {}
func (*DataplaneInSync) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{41} }

type HostMetadataV4V6Update struct {
	Hostname string            `protobuf:"bytes,1,opt,name=hostname,proto3" json:"hostname,omitempty"`
	Ipv4Addr string            `protobuf:"bytes,2,opt,name=ipv4_addr,json=ipv4Addr,proto3" json:"ipv4_addr,omitempty"`
	Ipv6Addr string            `protobuf:"bytes,3,opt,name=ipv6_addr,json=ipv6Addr,proto3" json:"ipv6_addr,omitempty"`
	Asnumber string            `protobuf:"bytes,4,opt,name=asnumber,proto3" json:"asnumber,omitempty"`
	Labels   map[string]string `protobuf:"bytes,5,rep,name=labels" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}

func (m *HostMetadataV4V6Update) Reset()         { *m = HostMetadataV4V6Update{} }
func (m *HostMetadataV4V6Update) String() string { return proto1.CompactTextString(m) }
func (*HostMetadataV4V6Update) ProtoMessage()    {}
func (*HostMetadataV4V6Update) Descriptor() ([]byte, []int) {
	return fileDescriptorFelixbackend, []int{42}
}

func (m *HostMetadataV4V6Update) GetHostname() string {
	if m != nil {
		return m.Hostname
	}
	return ""
}

func (m *HostMetadataV4V6Update) GetIpv4Addr() string {
	if m != nil {
		return m.Ipv4Addr
	}
	return ""
}

func (m *HostMetadataV4V6Update) GetIpv6Addr() string {
	if m != nil {
		return m.Ipv6Addr
	}
	return ""
}

func (m *HostMetadataV4V6Update) GetAsnumber() string {
	if m != nil {
		return m.Asnumber
	}
	return ""
}

func (m *HostMetadataV4V6Update) GetLabels() map[string]string {
	if m != nil {
		return m.Labels
	}
	return nil
}

type HostMetadataV4V6Remove struct {
	Hostname string `protobuf:"bytes,1,opt,name=hostname,proto3" json:"hostname,omitempty"`
	Ipv4Addr string `protobuf:"bytes,2,opt,name=ipv4_addr,json=ipv4Addr,proto3" json:"ipv4_addr,omitempty"`
}

func (m *HostMetadataV4V6Remove) Reset()         { *m = HostMetadataV4V6Remove{} }
func (m *HostMetadataV4V6Remove) String() string { return proto1.CompactTextString(m) }
func (*HostMetadataV4V6Remove) ProtoMessage()    {}
func (*HostMetadataV4V6Remove) Descriptor() ([]byte, []int) {
	return fileDescriptorFelixbackend, []int{43}
}

func (m *HostMetadataV4V6Remove) GetHostname() string {
	if m != nil {
		return m.Hostname
	}
	return ""
}

func (m *HostMetadataV4V6Remove) GetIpv4Addr() string {
	if m != nil {
		return m.Ipv4Addr
	}
	return ""
}

type HostMetadataUpdate struct {
	Hostname string `protobuf:"bytes,1,opt,name=hostname,proto3" json:"hostname,omitempty"`
	Ipv4Addr string `protobuf:"bytes,2,opt,name=ipv4_addr,json=ipv4Addr,proto3" json:"ipv4_addr,omitempty"`
}

func (m *HostMetadataUpdate) Reset()                    { *m = HostMetadataUpdate{} }
func (m *HostMetadataUpdate) String() string            { return proto1.CompactTextString(m) }
func (*HostMetadataUpdate) ProtoMessage()               {}
func (*HostMetadataUpdate) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{44} }

func (m *HostMetadataUpdate) GetHostname() string {
	if m != nil {
		return m.Hostname
	}
	return ""
}

func (m *HostMetadataUpdate) GetIpv4Addr() string {
	if m != nil {
		return m.Ipv4Addr
	}
	return ""
}

type HostMetadataRemove struct {
	Hostname string `protobuf:"bytes,1,opt,name=hostname,proto3" json:"hostname,omitempty"`
	Ipv4Addr string `protobuf:"bytes,2,opt,name=ipv4_addr,json=ipv4Addr,proto3" json:"ipv4_addr,omitempty"`
}

func (m *HostMetadataRemove) Reset()                    { *m = HostMetadataRemove{} }
func (m *HostMetadataRemove) String() string            { return proto1.CompactTextString(m) }
func (*HostMetadataRemove) ProtoMessage()               {}
func (*HostMetadataRemove) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{45} }

func (m *HostMetadataRemove) GetHostname() string {
	if m != nil {
		return m.Hostname
	}
	return ""
}

func (m *HostMetadataRemove) GetIpv4Addr() string {
	if m != nil {
		return m.Ipv4Addr
	}
	return ""
}

type HostMetadataV6Update struct {
	Hostname string `protobuf:"bytes,1,opt,name=hostname,proto3" json:"hostname,omitempty"`
	Ipv6Addr string `protobuf:"bytes,2,opt,name=ipv6_addr,json=ipv6Addr,proto3" json:"ipv6_addr,omitempty"`
}

func (m *HostMetadataV6Update) Reset()         { *m = HostMetadataV6Update{} }
func (m *HostMetadataV6Update) String() string { return proto1.CompactTextString(m) }
func (*HostMetadataV6Update) ProtoMessage()    {}
func (*HostMetadataV6Update) Descriptor() ([]byte, []int) {
	return fileDescriptorFelixbackend, []int{46}
}

func (m *HostMetadataV6Update) GetHostname() string {
	if m != nil {
		return m.Hostname
	}
	return ""
}

func (m *HostMetadataV6Update) GetIpv6Addr() string {
	if m != nil {
		return m.Ipv6Addr
	}
	return ""
}

type HostMetadataV6Remove struct {
	Hostname string `protobuf:"bytes,1,opt,name=hostname,proto3" json:"hostname,omitempty"`
	Ipv6Addr string `protobuf:"bytes,2,opt,name=ipv6_addr,json=ipv6Addr,proto3" json:"ipv6_addr,omitempty"`
}

func (m *HostMetadataV6Remove) Reset()         { *m = HostMetadataV6Remove{} }
func (m *HostMetadataV6Remove) String() string { return proto1.CompactTextString(m) }
func (*HostMetadataV6Remove) ProtoMessage()    {}
func (*HostMetadataV6Remove) Descriptor() ([]byte, []int) {
	return fileDescriptorFelixbackend, []int{47}
}

func (m *HostMetadataV6Remove) GetHostname() string {
	if m != nil {
		return m.Hostname
	}
	return ""
}

func (m *HostMetadataV6Remove) GetIpv6Addr() string {
	if m != nil {
		return m.Ipv6Addr
	}
	return ""
}

type IPAMPoolUpdate struct {
	Id   string    `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Pool *IPAMPool `protobuf:"bytes,2,opt,name=pool" json:"pool,omitempty"`
}

func (m *IPAMPoolUpdate) Reset()                    { *m = IPAMPoolUpdate{} }
func (m *IPAMPoolUpdate) String() string            { return proto1.CompactTextString(m) }
func (*IPAMPoolUpdate) ProtoMessage()               {}
func (*IPAMPoolUpdate) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{48} }

func (m *IPAMPoolUpdate) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *IPAMPoolUpdate) GetPool() *IPAMPool {
	if m != nil {
		return m.Pool
	}
	return nil
}

type IPAMPoolRemove struct {
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
}

func (m *IPAMPoolRemove) Reset()                    { *m = IPAMPoolRemove{} }
func (m *IPAMPoolRemove) String() string            { return proto1.CompactTextString(m) }
func (*IPAMPoolRemove) ProtoMessage()               {}
func (*IPAMPoolRemove) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{49} }

func (m *IPAMPoolRemove) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

type IPAMPool struct {
	Cidr       string `protobuf:"bytes,1,opt,name=cidr,proto3" json:"cidr,omitempty"`
	Masquerade bool   `protobuf:"varint,2,opt,name=masquerade,proto3" json:"masquerade,omitempty"`
	IpipMode   string `protobuf:"bytes,3,opt,name=ipip_mode,json=ipipMode,proto3" json:"ipip_mode,omitempty"`
	VxlanMode  string `protobuf:"bytes,4,opt,name=vxlan_mode,json=vxlanMode,proto3" json:"vxlan_mode,omitempty"`
}

func (m *IPAMPool) Reset()                    { *m = IPAMPool{} }
func (m *IPAMPool) String() string            { return proto1.CompactTextString(m) }
func (*IPAMPool) ProtoMessage()               {}
func (*IPAMPool) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{50} }

func (m *IPAMPool) GetCidr() string {
	if m != nil {
		return m.Cidr
	}
	return ""
}

func (m *IPAMPool) GetMasquerade() bool {
	if m != nil {
		return m.Masquerade
	}
	return false
}

func (m *IPAMPool) GetIpipMode() string {
	if m != nil {
		return m.IpipMode
	}
	return ""
}

func (m *IPAMPool) GetVxlanMode() string {
	if m != nil {
		return m.VxlanMode
	}
	return ""
}

type Encapsulation struct {
	IpipEnabled    bool `protobuf:"varint,1,opt,name=ipip_enabled,json=ipipEnabled,proto3" json:"ipip_enabled,omitempty"`
	VxlanEnabled   bool `protobuf:"varint,2,opt,name=vxlan_enabled,json=vxlanEnabled,proto3" json:"vxlan_enabled,omitempty"`
	VxlanEnabledV6 bool `protobuf:"varint,3,opt,name=vxlan_enabled_v6,json=vxlanEnabledV6,proto3" json:"vxlan_enabled_v6,omitempty"`
}

func (m *Encapsulation) Reset()                    { *m = Encapsulation{} }
func (m *Encapsulation) String() string            { return proto1.CompactTextString(m) }
func (*Encapsulation) ProtoMessage()               {}
func (*Encapsulation) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{51} }

func (m *Encapsulation) GetIpipEnabled() bool {
	if m != nil {
		return m.IpipEnabled
	}
	return false
}

func (m *Encapsulation) GetVxlanEnabled() bool {
	if m != nil {
		return m.VxlanEnabled
	}
	return false
}

func (m *Encapsulation) GetVxlanEnabledV6() bool {
	if m != nil {
		return m.VxlanEnabledV6
	}
	return false
}

type ServiceAccountUpdate struct {
	Id     *ServiceAccountID `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
	Labels map[string]string `protobuf:"bytes,2,rep,name=labels" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}

func (m *ServiceAccountUpdate) Reset()         { *m = ServiceAccountUpdate{} }
func (m *ServiceAccountUpdate) String() string { return proto1.CompactTextString(m) }
func (*ServiceAccountUpdate) ProtoMessage()    {}
func (*ServiceAccountUpdate) Descriptor() ([]byte, []int) {
	return fileDescriptorFelixbackend, []int{52}
}

func (m *ServiceAccountUpdate) GetId() *ServiceAccountID {
	if m != nil {
		return m.Id
	}
	return nil
}

func (m *ServiceAccountUpdate) GetLabels() map[string]string {
	if m != nil {
		return m.Labels
	}
	return nil
}

type ServiceAccountRemove struct {
	Id *ServiceAccountID `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
}

func (m *ServiceAccountRemove) Reset()         { *m = ServiceAccountRemove{} }
func (m *ServiceAccountRemove) String() string { return proto1.CompactTextString(m) }
func (*ServiceAccountRemove) ProtoMessage()    {}
func (*ServiceAccountRemove) Descriptor() ([]byte, []int) {
	return fileDescriptorFelixbackend, []int{53}
}

func (m *ServiceAccountRemove) GetId() *ServiceAccountID {
	if m != nil {
		return m.Id
	}
	return nil
}

type ServiceAccountID struct {
	Namespace string `protobuf:"bytes,1,opt,name=namespace,proto3" json:"namespace,omitempty"`
	Name      string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
}

func (m *ServiceAccountID) Reset()                    { *m = ServiceAccountID{} }
func (m *ServiceAccountID) String() string            { return proto1.CompactTextString(m) }
func (*ServiceAccountID) ProtoMessage()               {}
func (*ServiceAccountID) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{54} }

func (m *ServiceAccountID) GetNamespace() string {
	if m != nil {
		return m.Namespace
	}
	return ""
}

func (m *ServiceAccountID) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

type NamespaceUpdate struct {
	Id     *NamespaceID      `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
	Labels map[string]string `protobuf:"bytes,2,rep,name=labels" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}

func (m *NamespaceUpdate) Reset()                    { *m = NamespaceUpdate{} }
func (m *NamespaceUpdate) String() string            { return proto1.CompactTextString(m) }
func (*NamespaceUpdate) ProtoMessage()               {}
func (*NamespaceUpdate) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{55} }

func (m *NamespaceUpdate) GetId() *NamespaceID {
	if m != nil {
		return m.Id
	}
	return nil
}

func (m *NamespaceUpdate) GetLabels() map[string]string {
	if m != nil {
		return m.Labels
	}
	return nil
}

type NamespaceRemove struct {
	Id *NamespaceID `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
}

func (m *NamespaceRemove) Reset()                    { *m = NamespaceRemove{} }
func (m *NamespaceRemove) String() string            { return proto1.CompactTextString(m) }
func (*NamespaceRemove) ProtoMessage()               {}
func (*NamespaceRemove) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{56} }

func (m *NamespaceRemove) GetId() *NamespaceID {
	if m != nil {
		return m.Id
	}
	return nil
}

type NamespaceID struct {
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
}

func (m *NamespaceID) Reset()                    { *m = NamespaceID{} }
func (m *NamespaceID) String() string            { return proto1.CompactTextString(m) }
func (*NamespaceID) ProtoMessage()               {}
func (*NamespaceID) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{57} }

func (m *NamespaceID) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

type TunnelType struct {
	Ipip      bool `protobuf:"varint,1,opt,name=ipip,proto3" json:"ipip,omitempty"`
	Vxlan     bool `protobuf:"varint,2,opt,name=vxlan,proto3" json:"vxlan,omitempty"`
	Wireguard bool `protobuf:"varint,3,opt,name=wireguard,proto3" json:"wireguard,omitempty"`
}

func (m *TunnelType) Reset()                    { *m = TunnelType{} }
func (m *TunnelType) String() string            { return proto1.CompactTextString(m) }
func (*TunnelType) ProtoMessage()               {}
func (*TunnelType) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{58} }

func (m *TunnelType) GetIpip() bool {
	if m != nil {
		return m.Ipip
	}
	return false
}

func (m *TunnelType) GetVxlan() bool {
	if m != nil {
		return m.Vxlan
	}
	return false
}

func (m *TunnelType) GetWireguard() bool {
	if m != nil {
		return m.Wireguard
	}
	return false
}

type RouteUpdate struct {
	Type       RouteType  `protobuf:"varint,1,opt,name=type,proto3,enum=felix.RouteType" json:"type,omitempty"`
	IpPoolType IPPoolType `protobuf:"varint,2,opt,name=ip_pool_type,json=ipPoolType,proto3,enum=felix.IPPoolType" json:"ip_pool_type,omitempty"`
	Dst        string     `protobuf:"bytes,3,opt,name=dst,proto3" json:"dst,omitempty"`
	// The name of the node holding this destination, if this route targets a calico node.
	DstNodeName string `protobuf:"bytes,4,opt,name=dst_node_name,json=dstNodeName,proto3" json:"dst_node_name,omitempty"`
	// IP of the node holding this destination.
	DstNodeIp     string      `protobuf:"bytes,5,opt,name=dst_node_ip,json=dstNodeIp,proto3" json:"dst_node_ip,omitempty"`
	SameSubnet    bool        `protobuf:"varint,7,opt,name=same_subnet,json=sameSubnet,proto3" json:"same_subnet,omitempty"`
	NatOutgoing   bool        `protobuf:"varint,8,opt,name=nat_outgoing,json=natOutgoing,proto3" json:"nat_outgoing,omitempty"`
	LocalWorkload bool        `protobuf:"varint,9,opt,name=local_workload,json=localWorkload,proto3" json:"local_workload,omitempty"`
	TunnelType    *TunnelType `protobuf:"bytes,10,opt,name=tunnel_type,json=tunnelType" json:"tunnel_type,omitempty"`
	Borrowed      bool        `protobuf:"varint,11,opt,name=borrowed,proto3" json:"borrowed,omitempty"`
}

func (m *RouteUpdate) Reset()                    { *m = RouteUpdate{} }
func (m *RouteUpdate) String() string            { return proto1.CompactTextString(m) }
func (*RouteUpdate) ProtoMessage()               {}
func (*RouteUpdate) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{59} }

func (m *RouteUpdate) GetType() RouteType {
	if m != nil {
		return m.Type
	}
	return RouteType_CIDR_INFO
}

func (m *RouteUpdate) GetIpPoolType() IPPoolType {
	if m != nil {
		return m.IpPoolType
	}
	return IPPoolType_NONE
}

func (m *RouteUpdate) GetDst() string {
	if m != nil {
		return m.Dst
	}
	return ""
}

func (m *RouteUpdate) GetDstNodeName() string {
	if m != nil {
		return m.DstNodeName
	}
	return ""
}

func (m *RouteUpdate) GetDstNodeIp() string {
	if m != nil {
		return m.DstNodeIp
	}
	return ""
}

func (m *RouteUpdate) GetSameSubnet() bool {
	if m != nil {
		return m.SameSubnet
	}
	return false
}

func (m *RouteUpdate) GetNatOutgoing() bool {
	if m != nil {
		return m.NatOutgoing
	}
	return false
}

func (m *RouteUpdate) GetLocalWorkload() bool {
	if m != nil {
		return m.LocalWorkload
	}
	return false
}

func (m *RouteUpdate) GetTunnelType() *TunnelType {
	if m != nil {
		return m.TunnelType
	}
	return nil
}

func (m *RouteUpdate) GetBorrowed() bool {
	if m != nil {
		return m.Borrowed
	}
	return false
}

type RouteRemove struct {
	Dst string `protobuf:"bytes,2,opt,name=dst,proto3" json:"dst,omitempty"`
}

func (m *RouteRemove) Reset()                    { *m = RouteRemove{} }
func (m *RouteRemove) String() string            { return proto1.CompactTextString(m) }
func (*RouteRemove) ProtoMessage()               {}
func (*RouteRemove) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{60} }

func (m *RouteRemove) GetDst() string {
	if m != nil {
		return m.Dst
	}
	return ""
}

type VXLANTunnelEndpointUpdate struct {
	Node             string `protobuf:"bytes,1,opt,name=node,proto3" json:"node,omitempty"`
	Mac              string `protobuf:"bytes,2,opt,name=mac,proto3" json:"mac,omitempty"`
	Ipv4Addr         string `protobuf:"bytes,3,opt,name=ipv4_addr,json=ipv4Addr,proto3" json:"ipv4_addr,omitempty"`
	ParentDeviceIp   string `protobuf:"bytes,4,opt,name=parent_device_ip,json=parentDeviceIp,proto3" json:"parent_device_ip,omitempty"`
	MacV6            string `protobuf:"bytes,5,opt,name=mac_v6,json=macV6,proto3" json:"mac_v6,omitempty"`
	Ipv6Addr         string `protobuf:"bytes,6,opt,name=ipv6_addr,json=ipv6Addr,proto3" json:"ipv6_addr,omitempty"`
	ParentDeviceIpv6 string `protobuf:"bytes,7,opt,name=parent_device_ipv6,json=parentDeviceIpv6,proto3" json:"parent_device_ipv6,omitempty"`
}

func (m *VXLANTunnelEndpointUpdate) Reset()         { *m = VXLANTunnelEndpointUpdate{} }
func (m *VXLANTunnelEndpointUpdate) String() string { return proto1.CompactTextString(m) }
func (*VXLANTunnelEndpointUpdate) ProtoMessage()    {}
func (*VXLANTunnelEndpointUpdate) Descriptor() ([]byte, []int) {
	return fileDescriptorFelixbackend, []int{61}
}

func (m *VXLANTunnelEndpointUpdate) GetNode() string {
	if m != nil {
		return m.Node
	}
	return ""
}

func (m *VXLANTunnelEndpointUpdate) GetMac() string {
	if m != nil {
		return m.Mac
	}
	return ""
}

func (m *VXLANTunnelEndpointUpdate) GetIpv4Addr() string {
	if m != nil {
		return m.Ipv4Addr
	}
	return ""
}

func (m *VXLANTunnelEndpointUpdate) GetParentDeviceIp() string {
	if m != nil {
		return m.ParentDeviceIp
	}
	return ""
}

func (m *VXLANTunnelEndpointUpdate) GetMacV6() string {
	if m != nil {
		return m.MacV6
	}
	return ""
}

func (m *VXLANTunnelEndpointUpdate) GetIpv6Addr() string {
	if m != nil {
		return m.Ipv6Addr
	}
	return ""
}

func (m *VXLANTunnelEndpointUpdate) GetParentDeviceIpv6() string {
	if m != nil {
		return m.ParentDeviceIpv6
	}
	return ""
}

type VXLANTunnelEndpointRemove struct {
	Node string `protobuf:"bytes,1,opt,name=node,proto3" json:"node,omitempty"`
}

func (m *VXLANTunnelEndpointRemove) Reset()         { *m = VXLANTunnelEndpointRemove{} }
func (m *VXLANTunnelEndpointRemove) String() string { return proto1.CompactTextString(m) }
func (*VXLANTunnelEndpointRemove) ProtoMessage()    {}
func (*VXLANTunnelEndpointRemove) Descriptor() ([]byte, []int) {
	return fileDescriptorFelixbackend, []int{62}
}

func (m *VXLANTunnelEndpointRemove) GetNode() string {
	if m != nil {
		return m.Node
	}
	return ""
}

type WireguardEndpointUpdate struct {
	// The name of the IPv4 wireguard host.
	Hostname string `protobuf:"bytes,1,opt,name=hostname,proto3" json:"hostname,omitempty"`
	// The public key for IPv4 wireguard on this endpoint.
	PublicKey string `protobuf:"bytes,2,opt,name=public_key,json=publicKey,proto3" json:"public_key,omitempty"`
	// The IP address of the IPv4 wireguard interface.
	InterfaceIpv4Addr string `protobuf:"bytes,3,opt,name=interface_ipv4_addr,json=interfaceIpv4Addr,proto3" json:"interface_ipv4_addr,omitempty"`
}

func (m *WireguardEndpointUpdate) Reset()         { *m = WireguardEndpointUpdate{} }
func (m *WireguardEndpointUpdate) String() string { return proto1.CompactTextString(m) }
func (*WireguardEndpointUpdate) ProtoMessage()    {}
func (*WireguardEndpointUpdate) Descriptor() ([]byte, []int) {
	return fileDescriptorFelixbackend, []int{63}
}

func (m *WireguardEndpointUpdate) GetHostname() string {
	if m != nil {
		return m.Hostname
	}
	return ""
}

func (m *WireguardEndpointUpdate) GetPublicKey() string {
	if m != nil {
		return m.PublicKey
	}
	return ""
}

func (m *WireguardEndpointUpdate) GetInterfaceIpv4Addr() string {
	if m != nil {
		return m.InterfaceIpv4Addr
	}
	return ""
}

type WireguardEndpointRemove struct {
	// The name of the IPv4 wireguard host.
	Hostname string `protobuf:"bytes,1,opt,name=hostname,proto3" json:"hostname,omitempty"`
}

func (m *WireguardEndpointRemove) Reset()         { *m = WireguardEndpointRemove{} }
func (m *WireguardEndpointRemove) String() string { return proto1.CompactTextString(m) }
func (*WireguardEndpointRemove) ProtoMessage()    {}
func (*WireguardEndpointRemove) Descriptor() ([]byte, []int) {
	return fileDescriptorFelixbackend, []int{64}
}

func (m *WireguardEndpointRemove) GetHostname() string {
	if m != nil {
		return m.Hostname
	}
	return ""
}

type WireguardEndpointV6Update struct {
	// The name of the IPv6 wireguard host.
	Hostname string `protobuf:"bytes,1,opt,name=hostname,proto3" json:"hostname,omitempty"`
	// The public key for IPv6 wireguard on this endpoint.
	PublicKeyV6 string `protobuf:"bytes,2,opt,name=public_key_v6,json=publicKeyV6,proto3" json:"public_key_v6,omitempty"`
	// The IP address of the IPv6 wireguard interface.
	InterfaceIpv6Addr string `protobuf:"bytes,3,opt,name=interface_ipv6_addr,json=interfaceIpv6Addr,proto3" json:"interface_ipv6_addr,omitempty"`
}

func (m *WireguardEndpointV6Update) Reset()         { *m = WireguardEndpointV6Update{} }
func (m *WireguardEndpointV6Update) String() string { return proto1.CompactTextString(m) }
func (*WireguardEndpointV6Update) ProtoMessage()    {}
func (*WireguardEndpointV6Update) Descriptor() ([]byte, []int) {
	return fileDescriptorFelixbackend, []int{65}
}

func (m *WireguardEndpointV6Update) GetHostname() string {
	if m != nil {
		return m.Hostname
	}
	return ""
}

func (m *WireguardEndpointV6Update) GetPublicKeyV6() string {
	if m != nil {
		return m.PublicKeyV6
	}
	return ""
}

func (m *WireguardEndpointV6Update) GetInterfaceIpv6Addr() string {
	if m != nil {
		return m.InterfaceIpv6Addr
	}
	return ""
}

type WireguardEndpointV6Remove struct {
	// The name of the IPv6 wireguard host.
	Hostname string `protobuf:"bytes,1,opt,name=hostname,proto3" json:"hostname,omitempty"`
}

func (m *WireguardEndpointV6Remove) Reset()         { *m = WireguardEndpointV6Remove{} }
func (m *WireguardEndpointV6Remove) String() string { return proto1.CompactTextString(m) }
func (*WireguardEndpointV6Remove) ProtoMessage()    {}
func (*WireguardEndpointV6Remove) Descriptor() ([]byte, []int) {
	return fileDescriptorFelixbackend, []int{66}
}

func (m *WireguardEndpointV6Remove) GetHostname() string {
	if m != nil {
		return m.Hostname
	}
	return ""
}

type GlobalBGPConfigUpdate struct {
	ServiceClusterCidrs      []string `protobuf:"bytes,1,rep,name=service_cluster_cidrs,json=serviceClusterCidrs" json:"service_cluster_cidrs,omitempty"`
	ServiceExternalCidrs     []string `protobuf:"bytes,2,rep,name=service_external_cidrs,json=serviceExternalCidrs" json:"service_external_cidrs,omitempty"`
	ServiceLoadbalancerCidrs []string `protobuf:"bytes,3,rep,name=service_loadbalancer_cidrs,json=serviceLoadbalancerCidrs" json:"service_loadbalancer_cidrs,omitempty"`
}

func (m *GlobalBGPConfigUpdate) Reset()         { *m = GlobalBGPConfigUpdate{} }
func (m *GlobalBGPConfigUpdate) String() string { return proto1.CompactTextString(m) }
func (*GlobalBGPConfigUpdate) ProtoMessage()    {}
func (*GlobalBGPConfigUpdate) Descriptor() ([]byte, []int) {
	return fileDescriptorFelixbackend, []int{67}
}

func (m *GlobalBGPConfigUpdate) GetServiceClusterCidrs() []string {
	if m != nil {
		return m.ServiceClusterCidrs
	}
	return nil
}

func (m *GlobalBGPConfigUpdate) GetServiceExternalCidrs() []string {
	if m != nil {
		return m.ServiceExternalCidrs
	}
	return nil
}

func (m *GlobalBGPConfigUpdate) GetServiceLoadbalancerCidrs() []string {
	if m != nil {
		return m.ServiceLoadbalancerCidrs
	}
	return nil
}

type ServicePort struct {
	Protocol string `protobuf:"bytes,1,opt,name=Protocol,proto3" json:"Protocol,omitempty"`
	Port     int32  `protobuf:"varint,2,opt,name=Port,proto3" json:"Port,omitempty"`
	NodePort int32  `protobuf:"varint,3,opt,name=NodePort,proto3" json:"NodePort,omitempty"`
}

func (m *ServicePort) Reset()                    { *m = ServicePort{} }
func (m *ServicePort) String() string            { return proto1.CompactTextString(m) }
func (*ServicePort) ProtoMessage()               {}
func (*ServicePort) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{68} }

func (m *ServicePort) GetProtocol() string {
	if m != nil {
		return m.Protocol
	}
	return ""
}

func (m *ServicePort) GetPort() int32 {
	if m != nil {
		return m.Port
	}
	return 0
}

func (m *ServicePort) GetNodePort() int32 {
	if m != nil {
		return m.NodePort
	}
	return 0
}

type ServiceUpdate struct {
	Name           string         `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Namespace      string         `protobuf:"bytes,2,opt,name=namespace,proto3" json:"namespace,omitempty"`
	Type           string         `protobuf:"bytes,3,opt,name=type,proto3" json:"type,omitempty"`
	ClusterIps     []string       `protobuf:"bytes,4,rep,name=cluster_ips,json=clusterIps" json:"cluster_ips,omitempty"`
	LoadbalancerIp string         `protobuf:"bytes,5,opt,name=loadbalancer_ip,json=loadbalancerIp,proto3" json:"loadbalancer_ip,omitempty"`
	ExternalIps    []string       `protobuf:"bytes,6,rep,name=external_ips,json=externalIps" json:"external_ips,omitempty"`
	Ports          []*ServicePort `protobuf:"bytes,7,rep,name=ports" json:"ports,omitempty"`
}

func (m *ServiceUpdate) Reset()                    { *m = ServiceUpdate{} }
func (m *ServiceUpdate) String() string            { return proto1.CompactTextString(m) }
func (*ServiceUpdate) ProtoMessage()               {}
func (*ServiceUpdate) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{69} }

func (m *ServiceUpdate) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *ServiceUpdate) GetNamespace() string {
	if m != nil {
		return m.Namespace
	}
	return ""
}

func (m *ServiceUpdate) GetType() string {
	if m != nil {
		return m.Type
	}
	return ""
}

func (m *ServiceUpdate) GetClusterIps() []string {
	if m != nil {
		return m.ClusterIps
	}
	return nil
}

func (m *ServiceUpdate) GetLoadbalancerIp() string {
	if m != nil {
		return m.LoadbalancerIp
	}
	return ""
}

func (m *ServiceUpdate) GetExternalIps() []string {
	if m != nil {
		return m.ExternalIps
	}
	return nil
}

func (m *ServiceUpdate) GetPorts() []*ServicePort {
	if m != nil {
		return m.Ports
	}
	return nil
}

type ServiceRemove struct {
	Name      string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Namespace string `protobuf:"bytes,2,opt,name=namespace,proto3" json:"namespace,omitempty"`
}

func (m *ServiceRemove) Reset()                    { *m = ServiceRemove{} }
func (m *ServiceRemove) String() string            { return proto1.CompactTextString(m) }
func (*ServiceRemove) ProtoMessage()               {}
func (*ServiceRemove) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{70} }

func (m *ServiceRemove) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *ServiceRemove) GetNamespace() string {
	if m != nil {
		return m.Namespace
	}
	return ""
}

func init() {
	proto1.RegisterType((*SyncRequest)(nil), "felix.SyncRequest")
	proto1.RegisterType((*ToDataplane)(nil), "felix.ToDataplane")
	proto1.RegisterType((*FromDataplane)(nil), "felix.FromDataplane")
	proto1.RegisterType((*ConfigUpdate)(nil), "felix.ConfigUpdate")
	proto1.RegisterType((*RawConfig)(nil), "felix.RawConfig")
	proto1.RegisterType((*InSync)(nil), "felix.InSync")
	proto1.RegisterType((*IPSetUpdate)(nil), "felix.IPSetUpdate")
	proto1.RegisterType((*IPSetDeltaUpdate)(nil), "felix.IPSetDeltaUpdate")
	proto1.RegisterType((*IPSetRemove)(nil), "felix.IPSetRemove")
	proto1.RegisterType((*ActiveProfileUpdate)(nil), "felix.ActiveProfileUpdate")
	proto1.RegisterType((*ActiveProfileRemove)(nil), "felix.ActiveProfileRemove")
	proto1.RegisterType((*ProfileID)(nil), "felix.ProfileID")
	proto1.RegisterType((*Profile)(nil), "felix.Profile")
	proto1.RegisterType((*ActivePolicyUpdate)(nil), "felix.ActivePolicyUpdate")
	proto1.RegisterType((*ActivePolicyRemove)(nil), "felix.ActivePolicyRemove")
	proto1.RegisterType((*PolicyID)(nil), "felix.PolicyID")
	proto1.RegisterType((*Policy)(nil), "felix.Policy")
	proto1.RegisterType((*Rule)(nil), "felix.Rule")
	proto1.RegisterType((*ServiceAccountMatch)(nil), "felix.ServiceAccountMatch")
	proto1.RegisterType((*HTTPMatch)(nil), "felix.HTTPMatch")
	proto1.RegisterType((*HTTPMatch_PathMatch)(nil), "felix.HTTPMatch.PathMatch")
	proto1.RegisterType((*RuleMetadata)(nil), "felix.RuleMetadata")
	proto1.RegisterType((*IcmpTypeAndCode)(nil), "felix.IcmpTypeAndCode")
	proto1.RegisterType((*Protocol)(nil), "felix.Protocol")
	proto1.RegisterType((*PortRange)(nil), "felix.PortRange")
	proto1.RegisterType((*WorkloadEndpointID)(nil), "felix.WorkloadEndpointID")
	proto1.RegisterType((*WorkloadEndpointUpdate)(nil), "felix.WorkloadEndpointUpdate")
	proto1.RegisterType((*WorkloadEndpoint)(nil), "felix.WorkloadEndpoint")
	proto1.RegisterType((*WorkloadEndpointRemove)(nil), "felix.WorkloadEndpointRemove")
	proto1.RegisterType((*HostEndpointID)(nil), "felix.HostEndpointID")
	proto1.RegisterType((*HostEndpointUpdate)(nil), "felix.HostEndpointUpdate")
	proto1.RegisterType((*HostEndpoint)(nil), "felix.HostEndpoint")
	proto1.RegisterType((*HostEndpointRemove)(nil), "felix.HostEndpointRemove")
	proto1.RegisterType((*TierInfo)(nil), "felix.TierInfo")
	proto1.RegisterType((*NatInfo)(nil), "felix.NatInfo")
	proto1.RegisterType((*ProcessStatusUpdate)(nil), "felix.ProcessStatusUpdate")
	proto1.RegisterType((*HostEndpointStatusUpdate)(nil), "felix.HostEndpointStatusUpdate")
	proto1.RegisterType((*EndpointStatus)(nil), "felix.EndpointStatus")
	proto1.RegisterType((*HostEndpointStatusRemove)(nil), "felix.HostEndpointStatusRemove")
	proto1.RegisterType((*WorkloadEndpointStatusUpdate)(nil), "felix.WorkloadEndpointStatusUpdate")
	proto1.RegisterType((*WorkloadEndpointStatusRemove)(nil), "felix.WorkloadEndpointStatusRemove")
	proto1.RegisterType((*WireguardStatusUpdate)(nil), "felix.WireguardStatusUpdate")
	proto1.RegisterType((*DataplaneInSync)(nil), "felix.DataplaneInSync")
	proto1.RegisterType((*HostMetadataV4V6Update)(nil), "felix.HostMetadataV4V6Update")
	proto1.RegisterType((*HostMetadataV4V6Remove)(nil), "felix.HostMetadataV4V6Remove")
	proto1.RegisterType((*HostMetadataUpdate)(nil), "felix.HostMetadataUpdate")
	proto1.RegisterType((*HostMetadataRemove)(nil), "felix.HostMetadataRemove")
	proto1.RegisterType((*HostMetadataV6Update)(nil), "felix.HostMetadataV6Update")
	proto1.RegisterType((*HostMetadataV6Remove)(nil), "felix.HostMetadataV6Remove")
	proto1.RegisterType((*IPAMPoolUpdate)(nil), "felix.IPAMPoolUpdate")
	proto1.RegisterType((*IPAMPoolRemove)(nil), "felix.IPAMPoolRemove")
	proto1.RegisterType((*IPAMPool)(nil), "felix.IPAMPool")
	proto1.RegisterType((*Encapsulation)(nil), "felix.Encapsulation")
	proto1.RegisterType((*ServiceAccountUpdate)(nil), "felix.ServiceAccountUpdate")
	proto1.RegisterType((*ServiceAccountRemove)(nil), "felix.ServiceAccountRemove")
	proto1.RegisterType((*ServiceAccountID)(nil), "felix.ServiceAccountID")
	proto1.RegisterType((*NamespaceUpdate)(nil), "felix.NamespaceUpdate")
	proto1.RegisterType((*NamespaceRemove)(nil), "felix.NamespaceRemove")
	proto1.RegisterType((*NamespaceID)(nil), "felix.NamespaceID")
	proto1.RegisterType((*TunnelType)(nil), "felix.TunnelType")
	proto1.RegisterType((*RouteUpdate)(nil), "felix.RouteUpdate")
	proto1.RegisterType((*RouteRemove)(nil), "felix.RouteRemove")
	proto1.RegisterType((*VXLANTunnelEndpointUpdate)(nil), "felix.VXLANTunnelEndpointUpdate")
	proto1.RegisterType((*VXLANTunnelEndpointRemove)(nil), "felix.VXLANTunnelEndpointRemove")
	proto1.RegisterType((*WireguardEndpointUpdate)(nil), "felix.WireguardEndpointUpdate")
	proto1.RegisterType((*WireguardEndpointRemove)(nil), "felix.WireguardEndpointRemove")
	proto1.RegisterType((*WireguardEndpointV6Update)(nil), "felix.WireguardEndpointV6Update")
	proto1.RegisterType((*WireguardEndpointV6Remove)(nil), "felix.WireguardEndpointV6Remove")
	proto1.RegisterType((*GlobalBGPConfigUpdate)(nil), "felix.GlobalBGPConfigUpdate")
	proto1.RegisterType((*ServicePort)(nil), "felix.ServicePort")
	proto1.RegisterType((*ServiceUpdate)(nil), "felix.ServiceUpdate")
	proto1.RegisterType((*ServiceRemove)(nil), "felix.ServiceRemove")
	proto1.RegisterEnum("felix.IPVersion", IPVersion_name, IPVersion_value)
	proto1.RegisterEnum("felix.RouteType", RouteType_name, RouteType_value)
	proto1.RegisterEnum("felix.IPPoolType", IPPoolType_name, IPPoolType_value)
	proto1.RegisterEnum("felix.IPSetUpdate_IPSetType", IPSetUpdate_IPSetType_name, IPSetUpdate_IPSetType_value)
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// Client API for PolicySync service

type PolicySyncClient interface {
	// On this API, only the following payloads will be sent:
	//  - InSync
	//  - IPSetUpdate
	//  - IPSetDeltaUpdate
	//  - IPSetRemove
	//  - ActiveProfileUpdate
	//  - ActiveProfileRemove
	//  - ActivePolicyUpdate
	//  - ActivePolicyRemove
	//  - WorkloadEndpointUpdate
	//  - WorkloadEndpointRemove
	//  - ServiceAccountUpdate
	//  - ServiceAccountRemove
	//  - NamespaceUpdate
	//  - NamespaceRemove
	//  - RouteUpdate
	//  - RouteRemove
	//  - VXLANTunnelEndpointUpdate
	//  - VXLANTunnelEndpointRemove
	Sync(ctx context.Context, in *SyncRequest, opts ...grpc.CallOption) (PolicySync_SyncClient, error)
}

type policySyncClient struct {
	cc *grpc.ClientConn
}

func NewPolicySyncClient(cc *grpc.ClientConn) PolicySyncClient {
	return &policySyncClient{cc}
}

func (c *policySyncClient) Sync(ctx context.Context, in *SyncRequest, opts ...grpc.CallOption) (PolicySync_SyncClient, error) {
	stream, err := grpc.NewClientStream(ctx, &_PolicySync_serviceDesc.Streams[0], c.cc, "/felix.PolicySync/Sync", opts...)
	if err != nil {
		return nil, err
	}
	x := &policySyncSyncClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type PolicySync_SyncClient interface {
	Recv() (*ToDataplane, error)
	grpc.ClientStream
}

type policySyncSyncClient struct {
	grpc.ClientStream
}

func (x *policySyncSyncClient) Recv() (*ToDataplane, error) {
	m := new(ToDataplane)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

// Server API for PolicySync service

type PolicySyncServer interface {
	// On this API, only the following payloads will be sent:
	//  - InSync
	//  - IPSetUpdate
	//  - IPSetDeltaUpdate
	//  - IPSetRemove
	//  - ActiveProfileUpdate
	//  - ActiveProfileRemove
	//  - ActivePolicyUpdate
	//  - ActivePolicyRemove
	//  - WorkloadEndpointUpdate
	//  - WorkloadEndpointRemove
	//  - ServiceAccountUpdate
	//  - ServiceAccountRemove
	//  - NamespaceUpdate
	//  - NamespaceRemove
	//  - RouteUpdate
	//  - RouteRemove
	//  - VXLANTunnelEndpointUpdate
	//  - VXLANTunnelEndpointRemove
	Sync(*SyncRequest, PolicySync_SyncServer) error
}

func RegisterPolicySyncServer(s *grpc.Server, srv PolicySyncServer) {
	s.RegisterService(&_PolicySync_serviceDesc, srv)
}

func _PolicySync_Sync_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(SyncRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(PolicySyncServer).Sync(m, &policySyncSyncServer{stream})
}

type PolicySync_SyncServer interface {
	Send(*ToDataplane) error
	grpc.ServerStream
}

type policySyncSyncServer struct {
	grpc.ServerStream
}

func (x *policySyncSyncServer) Send(m *ToDataplane) error {
	return x.ServerStream.SendMsg(m)
}

var _PolicySync_serviceDesc = grpc.ServiceDesc{
	ServiceName: "felix.PolicySync",
	HandlerType: (*PolicySyncServer)(nil),
	Methods:     []grpc.MethodDesc{},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "Sync",
			Handler:       _PolicySync_Sync_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "felixbackend.proto",
}

func (m *SyncRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *SyncRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	return i, nil
}

func (m *ToDataplane) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ToDataplane) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Payload != nil {
		nn1, err := m.Payload.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += nn1
	}
	if m.SequenceNumber != 0 {
		dAtA[i] = 0x78
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.SequenceNumber))
	}
	return i, nil
}

func (m *ToDataplane_InSync) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.InSync != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.InSync.Size()))
		n2, err := m.InSync.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n2
	}
	return i, nil
}
func (m *ToDataplane_IpsetUpdate) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.IpsetUpdate != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.IpsetUpdate.Size()))
		n3, err := m.IpsetUpdate.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n3
	}
	return i, nil
}
func (m *ToDataplane_IpsetDeltaUpdate) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.IpsetDeltaUpdate != nil {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.IpsetDeltaUpdate.Size()))
		n4, err := m.IpsetDeltaUpdate.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n4
	}
	return i, nil
}
func (m *ToDataplane_IpsetRemove) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.IpsetRemove != nil {
		dAtA[i] = 0x22
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.IpsetRemove.Size()))
		n5, err := m.IpsetRemove.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n5
	}
	return i, nil
}
func (m *ToDataplane_ActiveProfileUpdate) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.ActiveProfileUpdate != nil {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.ActiveProfileUpdate.Size()))
		n6, err := m.ActiveProfileUpdate.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n6
	}
	return i, nil
}
func (m *ToDataplane_ActiveProfileRemove) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.ActiveProfileRemove != nil {
		dAtA[i] = 0x32
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.ActiveProfileRemove.Size()))
		n7, err := m.ActiveProfileRemove.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n7
	}
	return i, nil
}
func (m *ToDataplane_ActivePolicyUpdate) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.ActivePolicyUpdate != nil {
		dAtA[i] = 0x3a
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.ActivePolicyUpdate.Size()))
		n8, err := m.ActivePolicyUpdate.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n8
	}
	return i, nil
}
func (m *ToDataplane_ActivePolicyRemove) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.ActivePolicyRemove != nil {
		dAtA[i] = 0x42
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.ActivePolicyRemove.Size()))
		n9, err := m.ActivePolicyRemove.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n9
	}
	return i, nil
}
func (m *ToDataplane_HostEndpointUpdate) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.HostEndpointUpdate != nil {
		dAtA[i] = 0x4a
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.HostEndpointUpdate.Size()))
		n10, err := m.HostEndpointUpdate.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n10
	}
	return i, nil
}
func (m *ToDataplane_HostEndpointRemove) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.HostEndpointRemove != nil {
		dAtA[i] = 0x52
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.HostEndpointRemove.Size()))
		n11, err := m.HostEndpointRemove.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n11
	}
	return i, nil
}
func (m *ToDataplane_WorkloadEndpointUpdate) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.WorkloadEndpointUpdate != nil {
		dAtA[i] = 0x5a
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.WorkloadEndpointUpdate.Size()))
		n12, err := m.WorkloadEndpointUpdate.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n12
	}
	return i, nil
}
func (m *ToDataplane_WorkloadEndpointRemove) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.WorkloadEndpointRemove != nil {
		dAtA[i] = 0x62
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.WorkloadEndpointRemove.Size()))
		n13, err := m.WorkloadEndpointRemove.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n13
	}
	return i, nil
}
func (m *ToDataplane_ConfigUpdate) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.ConfigUpdate != nil {
		dAtA[i] = 0x6a
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.ConfigUpdate.Size()))
		n14, err := m.ConfigUpdate.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n14
	}
	return i, nil
}
func (m *ToDataplane_HostMetadataUpdate) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.HostMetadataUpdate != nil {
		dAtA[i] = 0x72
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.HostMetadataUpdate.Size()))
		n15, err := m.HostMetadataUpdate.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n15
	}
	return i, nil
}
func (m *ToDataplane_IpamPoolUpdate) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.IpamPoolUpdate != nil {
		dAtA[i] = 0x82
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.IpamPoolUpdate.Size()))
		n16, err := m.IpamPoolUpdate.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n16
	}
	return i, nil
}
func (m *ToDataplane_IpamPoolRemove) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.IpamPoolRemove != nil {
		dAtA[i] = 0x8a
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.IpamPoolRemove.Size()))
		n17, err := m.IpamPoolRemove.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n17
	}
	return i, nil
}
func (m *ToDataplane_HostMetadataRemove) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.HostMetadataRemove != nil {
		dAtA[i] = 0x92
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.HostMetadataRemove.Size()))
		n18, err := m.HostMetadataRemove.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n18
	}
	return i, nil
}
func (m *ToDataplane_ServiceAccountUpdate) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.ServiceAccountUpdate != nil {
		dAtA[i] = 0x9a
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.ServiceAccountUpdate.Size()))
		n19, err := m.ServiceAccountUpdate.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n19
	}
	return i, nil
}
func (m *ToDataplane_ServiceAccountRemove) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.ServiceAccountRemove != nil {
		dAtA[i] = 0xa2
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.ServiceAccountRemove.Size()))
		n20, err := m.ServiceAccountRemove.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n20
	}
	return i, nil
}
func (m *ToDataplane_NamespaceUpdate) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.NamespaceUpdate != nil {
		dAtA[i] = 0xaa
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.NamespaceUpdate.Size()))
		n21, err := m.NamespaceUpdate.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n21
	}
	return i, nil
}
func (m *ToDataplane_NamespaceRemove) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.NamespaceRemove != nil {
		dAtA[i] = 0xb2
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.NamespaceRemove.Size()))
		n22, err := m.NamespaceRemove.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n22
	}
	return i, nil
}
func (m *ToDataplane_RouteUpdate) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.RouteUpdate != nil {
		dAtA[i] = 0xba
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.RouteUpdate.Size()))
		n23, err := m.RouteUpdate.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n23
	}
	return i, nil
}
func (m *ToDataplane_RouteRemove) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.RouteRemove != nil {
		dAtA[i] = 0xc2
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.RouteRemove.Size()))
		n24, err := m.RouteRemove.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n24
	}
	return i, nil
}
func (m *ToDataplane_VtepUpdate) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.VtepUpdate != nil {
		dAtA[i] = 0xca
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.VtepUpdate.Size()))
		n25, err := m.VtepUpdate.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n25
	}
	return i, nil
}
func (m *ToDataplane_VtepRemove) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.VtepRemove != nil {
		dAtA[i] = 0xd2
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.VtepRemove.Size()))
		n26, err := m.VtepRemove.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n26
	}
	return i, nil
}
func (m *ToDataplane_WireguardEndpointUpdate) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.WireguardEndpointUpdate != nil {
		dAtA[i] = 0xda
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.WireguardEndpointUpdate.Size()))
		n27, err := m.WireguardEndpointUpdate.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n27
	}
	return i, nil
}
func (m *ToDataplane_WireguardEndpointRemove) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.WireguardEndpointRemove != nil {
		dAtA[i] = 0xe2
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.WireguardEndpointRemove.Size()))
		n28, err := m.WireguardEndpointRemove.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n28
	}
	return i, nil
}
func (m *ToDataplane_GlobalBgpConfigUpdate) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.GlobalBgpConfigUpdate != nil {
		dAtA[i] = 0xea
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.GlobalBgpConfigUpdate.Size()))
		n29, err := m.GlobalBgpConfigUpdate.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n29
	}
	return i, nil
}
func (m *ToDataplane_Encapsulation) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.Encapsulation != nil {
		dAtA[i] = 0xf2
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.Encapsulation.Size()))
		n30, err := m.Encapsulation.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n30
	}
	return i, nil
}
func (m *ToDataplane_ServiceUpdate) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.ServiceUpdate != nil {
		dAtA[i] = 0xfa
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.ServiceUpdate.Size()))
		n31, err := m.ServiceUpdate.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n31
	}
	return i, nil
}
func (m *ToDataplane_ServiceRemove) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.ServiceRemove != nil {
		dAtA[i] = 0x82
		i++
		dAtA[i] = 0x2
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.ServiceRemove.Size()))
		n32, err := m.ServiceRemove.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n32
	}
	return i, nil
}
func (m *ToDataplane_WireguardEndpointV6Update) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.WireguardEndpointV6Update != nil {
		dAtA[i] = 0x8a
		i++
		dAtA[i] = 0x2
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.WireguardEndpointV6Update.Size()))
		n33, err := m.WireguardEndpointV6Update.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n33
	}
	return i, nil
}
func (m *ToDataplane_WireguardEndpointV6Remove) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.WireguardEndpointV6Remove != nil {
		dAtA[i] = 0x92
		i++
		dAtA[i] = 0x2
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.WireguardEndpointV6Remove.Size()))
		n34, err := m.WireguardEndpointV6Remove.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n34
	}
	return i, nil
}
func (m *ToDataplane_HostMetadataV6Update) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.HostMetadataV6Update != nil {
		dAtA[i] = 0x9a
		i++
		dAtA[i] = 0x2
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.HostMetadataV6Update.Size()))
		n35, err := m.HostMetadataV6Update.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n35
	}
	return i, nil
}
func (m *ToDataplane_HostMetadataV6Remove) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.HostMetadataV6Remove != nil {
		dAtA[i] = 0xa2
		i++
		dAtA[i] = 0x2
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.HostMetadataV6Remove.Size()))
		n36, err := m.HostMetadataV6Remove.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n36
	}
	return i, nil
}
func (m *ToDataplane_HostMetadataV4V6Update) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.HostMetadataV4V6Update != nil {
		dAtA[i] = 0xaa
		i++
		dAtA[i] = 0x2
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.HostMetadataV4V6Update.Size()))
		n37, err := m.HostMetadataV4V6Update.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n37
	}
	return i, nil
}
func (m *ToDataplane_HostMetadataV4V6Remove) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.HostMetadataV4V6Remove != nil {
		dAtA[i] = 0xb2
		i++
		dAtA[i] = 0x2
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.HostMetadataV4V6Remove.Size()))
		n38, err := m.HostMetadataV4V6Remove.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n38
	}
	return i, nil
}
func (m *FromDataplane) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *FromDataplane) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Payload != nil {
		nn39, err := m.Payload.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += nn39
	}
	if m.SequenceNumber != 0 {
		dAtA[i] = 0x40
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.SequenceNumber))
	}
	return i, nil
}

func (m *FromDataplane_ProcessStatusUpdate) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.ProcessStatusUpdate != nil {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.ProcessStatusUpdate.Size()))
		n40, err := m.ProcessStatusUpdate.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n40
	}
	return i, nil
}
func (m *FromDataplane_HostEndpointStatusUpdate) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.HostEndpointStatusUpdate != nil {
		dAtA[i] = 0x22
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.HostEndpointStatusUpdate.Size()))
		n41, err := m.HostEndpointStatusUpdate.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n41
	}
	return i, nil
}
func (m *FromDataplane_HostEndpointStatusRemove) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.HostEndpointStatusRemove != nil {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.HostEndpointStatusRemove.Size()))
		n42, err := m.HostEndpointStatusRemove.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n42
	}
	return i, nil
}
func (m *FromDataplane_WorkloadEndpointStatusUpdate) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.WorkloadEndpointStatusUpdate != nil {
		dAtA[i] = 0x32
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.WorkloadEndpointStatusUpdate.Size()))
		n43, err := m.WorkloadEndpointStatusUpdate.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n43
	}
	return i, nil
}
func (m *FromDataplane_WorkloadEndpointStatusRemove) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.WorkloadEndpointStatusRemove != nil {
		dAtA[i] = 0x3a
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.WorkloadEndpointStatusRemove.Size()))
		n44, err := m.WorkloadEndpointStatusRemove.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n44
	}
	return i, nil
}
func (m *FromDataplane_WireguardStatusUpdate) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.WireguardStatusUpdate != nil {
		dAtA[i] = 0x4a
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.WireguardStatusUpdate.Size()))
		n45, err := m.WireguardStatusUpdate.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n45
	}
	return i, nil
}
func (m *FromDataplane_DataplaneInSync) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.DataplaneInSync != nil {
		dAtA[i] = 0x52
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.DataplaneInSync.Size()))
		n46, err := m.DataplaneInSync.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n46
	}
	return i, nil
}
func (m *ConfigUpdate) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ConfigUpdate) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Config) > 0 {
		for k, _ := range m.Config {
			dAtA[i] = 0xa
			i++
			v := m.Config[k]
			mapSize := 1 + len(k) + sovFelixbackend(uint64(len(k))) + 1 + len(v) + sovFelixbackend(uint64(len(v)))
			i = encodeVarintFelixbackend(dAtA, i, uint64(mapSize))
			dAtA[i] = 0xa
			i++
			i = encodeVarintFelixbackend(dAtA, i, uint64(len(k)))
			i += copy(dAtA[i:], k)
			dAtA[i] = 0x12
			i++
			i = encodeVarintFelixbackend(dAtA, i, uint64(len(v)))
			i += copy(dAtA[i:], v)
		}
	}
	if len(m.SourceToRawConfig) > 0 {
		for k, _ := range m.SourceToRawConfig {
			dAtA[i] = 0x12
			i++
			v := m.SourceToRawConfig[k]
			msgSize := 0
			if v != nil {
				msgSize = v.Size()
				msgSize += 1 + sovFelixbackend(uint64(msgSize))
			}
			mapSize := 1 + sovFelixbackend(uint64(k)) + msgSize
			i = encodeVarintFelixbackend(dAtA, i, uint64(mapSize))
			dAtA[i] = 0x8
			i++
			i = encodeVarintFelixbackend(dAtA, i, uint64(k))
			if v != nil {
				dAtA[i] = 0x12
				i++
				i = encodeVarintFelixbackend(dAtA, i, uint64(v.Size()))
				n47, err := v.MarshalTo(dAtA[i:])
				if err != nil {
					return 0, err
				}
				i += n47
			}
		}
	}
	if len(m.Message) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Message)))
		i += copy(dAtA[i:], m.Message)
	}
	return i, nil
}

func (m *RawConfig) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RawConfig) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Source) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Source)))
		i += copy(dAtA[i:], m.Source)
	}
	if len(m.Config) > 0 {
		for k, _ := range m.Config {
			dAtA[i] = 0x12
			i++
			v := m.Config[k]
			mapSize := 1 + len(k) + sovFelixbackend(uint64(len(k))) + 1 + len(v) + sovFelixbackend(uint64(len(v)))
			i = encodeVarintFelixbackend(dAtA, i, uint64(mapSize))
			dAtA[i] = 0xa
			i++
			i = encodeVarintFelixbackend(dAtA, i, uint64(len(k)))
			i += copy(dAtA[i:], k)
			dAtA[i] = 0x12
			i++
			i = encodeVarintFelixbackend(dAtA, i, uint64(len(v)))
			i += copy(dAtA[i:], v)
		}
	}
	return i, nil
}

func (m *InSync) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *InSync) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	return i, nil
}

func (m *IPSetUpdate) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *IPSetUpdate) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Id) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Id)))
		i += copy(dAtA[i:], m.Id)
	}
	if len(m.Members) > 0 {
		for _, s := range m.Members {
			dAtA[i] = 0x12
			i++
			l = len(s)
			for l >= 1<<7 {
				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
				l >>= 7
				i++
			}
			dAtA[i] = uint8(l)
			i++
			i += copy(dAtA[i:], s)
		}
	}
	if m.Type != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.Type))
	}
	return i, nil
}

func (m *IPSetDeltaUpdate) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *IPSetDeltaUpdate) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Id) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Id)))
		i += copy(dAtA[i:], m.Id)
	}
	if len(m.AddedMembers) > 0 {
		for _, s := range m.AddedMembers {
			dAtA[i] = 0x12
			i++
			l = len(s)
			for l >= 1<<7 {
				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
				l >>= 7
				i++
			}
			dAtA[i] = uint8(l)
			i++
			i += copy(dAtA[i:], s)
		}
	}
	if len(m.RemovedMembers) > 0 {
		for _, s := range m.RemovedMembers {
			dAtA[i] = 0x1a
			i++
			l = len(s)
			for l >= 1<<7 {
				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
				l >>= 7
				i++
			}
			dAtA[i] = uint8(l)
			i++
			i += copy(dAtA[i:], s)
		}
	}
	return i, nil
}

func (m *IPSetRemove) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *IPSetRemove) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Id) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Id)))
		i += copy(dAtA[i:], m.Id)
	}
	return i, nil
}

func (m *ActiveProfileUpdate) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ActiveProfileUpdate) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Id != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.Id.Size()))
		n48, err := m.Id.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n48
	}
	if m.Profile != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.Profile.Size()))
		n49, err := m.Profile.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n49
	}
	return i, nil
}

func (m *ActiveProfileRemove) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ActiveProfileRemove) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Id != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.Id.Size()))
		n50, err := m.Id.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n50
	}
	return i, nil
}

func (m *ProfileID) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ProfileID) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Name) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Name)))
		i += copy(dAtA[i:], m.Name)
	}
	return i, nil
}

func (m *Profile) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Profile) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.InboundRules) > 0 {
		for _, msg := range m.InboundRules {
			dAtA[i] = 0xa
			i++
			i = encodeVarintFelixbackend(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if len(m.OutboundRules) > 0 {
		for _, msg := range m.OutboundRules {
			dAtA[i] = 0x12
			i++
			i = encodeVarintFelixbackend(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	return i, nil
}

func (m *ActivePolicyUpdate) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ActivePolicyUpdate) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Id != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.Id.Size()))
		n51, err := m.Id.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n51
	}
	if m.Policy != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.Policy.Size()))
		n52, err := m.Policy.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n52
	}
	return i, nil
}

func (m *ActivePolicyRemove) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ActivePolicyRemove) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Id != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.Id.Size()))
		n53, err := m.Id.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n53
	}
	return i, nil
}

func (m *PolicyID) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *PolicyID) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Tier) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Tier)))
		i += copy(dAtA[i:], m.Tier)
	}
	if len(m.Name) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Name)))
		i += copy(dAtA[i:], m.Name)
	}
	return i, nil
}

func (m *Policy) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Policy) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.InboundRules) > 0 {
		for _, msg := range m.InboundRules {
			dAtA[i] = 0xa
			i++
			i = encodeVarintFelixbackend(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if len(m.OutboundRules) > 0 {
		for _, msg := range m.OutboundRules {
			dAtA[i] = 0x12
			i++
			i = encodeVarintFelixbackend(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if m.Untracked {
		dAtA[i] = 0x18
		i++
		if m.Untracked {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if m.PreDnat {
		dAtA[i] = 0x20
		i++
		if m.PreDnat {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if len(m.Namespace) > 0 {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Namespace)))
		i += copy(dAtA[i:], m.Namespace)
	}
	if len(m.OriginalSelector) > 0 {
		dAtA[i] = 0x32
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.OriginalSelector)))
		i += copy(dAtA[i:], m.OriginalSelector)
	}
	return i, nil
}

func (m *Rule) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Rule) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Action) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Action)))
		i += copy(dAtA[i:], m.Action)
	}
	if m.IpVersion != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.IpVersion))
	}
	if m.Protocol != nil {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.Protocol.Size()))
		n54, err := m.Protocol.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n54
	}
	if len(m.SrcNet) > 0 {
		for _, s := range m.SrcNet {
			dAtA[i] = 0x22
			i++
			l = len(s)
			for l >= 1<<7 {
				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
				l >>= 7
				i++
			}
			dAtA[i] = uint8(l)
			i++
			i += copy(dAtA[i:], s)
		}
	}
	if len(m.SrcPorts) > 0 {
		for _, msg := range m.SrcPorts {
			dAtA[i] = 0x2a
			i++
			i = encodeVarintFelixbackend(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if len(m.DstNet) > 0 {
		for _, s := range m.DstNet {
			dAtA[i] = 0x32
			i++
			l = len(s)
			for l >= 1<<7 {
				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
				l >>= 7
				i++
			}
			dAtA[i] = uint8(l)
			i++
			i += copy(dAtA[i:], s)
		}
	}
	if len(m.DstPorts) > 0 {
		for _, msg := range m.DstPorts {
			dAtA[i] = 0x3a
			i++
			i = encodeVarintFelixbackend(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if m.Icmp != nil {
		nn55, err := m.Icmp.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += nn55
	}
	if len(m.SrcIpSetIds) > 0 {
		for _, s := range m.SrcIpSetIds {
			dAtA[i] = 0x52
			i++
			l = len(s)
			for l >= 1<<7 {
				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
				l >>= 7
				i++
			}
			dAtA[i] = uint8(l)
			i++
			i += copy(dAtA[i:], s)
		}
	}
	if len(m.DstIpSetIds) > 0 {
		for _, s := range m.DstIpSetIds {
			dAtA[i] = 0x5a
			i++
			l = len(s)
			for l >= 1<<7 {
				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
				l >>= 7
				i++
			}
			dAtA[i] = uint8(l)
			i++
			i += copy(dAtA[i:], s)
		}
	}
	if len(m.SrcNamedPortIpSetIds) > 0 {
		for _, s := range m.SrcNamedPortIpSetIds {
			dAtA[i] = 0x62
			i++
			l = len(s)
			for l >= 1<<7 {
				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
				l >>= 7
				i++
			}
			dAtA[i] = uint8(l)
			i++
			i += copy(dAtA[i:], s)
		}
	}
	if len(m.DstNamedPortIpSetIds) > 0 {
		for _, s := range m.DstNamedPortIpSetIds {
			dAtA[i] = 0x6a
			i++
			l = len(s)
			for l >= 1<<7 {
				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
				l >>= 7
				i++
			}
			dAtA[i] = uint8(l)
			i++
			i += copy(dAtA[i:], s)
		}
	}
	if len(m.DstIpPortSetIds) > 0 {
		for _, s := range m.DstIpPortSetIds {
			dAtA[i] = 0x7a
			i++
			l = len(s)
			for l >= 1<<7 {
				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
				l >>= 7
				i++
			}
			dAtA[i] = uint8(l)
			i++
			i += copy(dAtA[i:], s)
		}
	}
	if m.NotProtocol != nil {
		dAtA[i] = 0xb2
		i++
		dAtA[i] = 0x6
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.NotProtocol.Size()))
		n56, err := m.NotProtocol.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n56
	}
	if len(m.NotSrcNet) > 0 {
		for _, s := range m.NotSrcNet {
			dAtA[i] = 0xba
			i++
			dAtA[i] = 0x6
			i++
			l = len(s)
			for l >= 1<<7 {
				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
				l >>= 7
				i++
			}
			dAtA[i] = uint8(l)
			i++
			i += copy(dAtA[i:], s)
		}
	}
	if len(m.NotSrcPorts) > 0 {
		for _, msg := range m.NotSrcPorts {
			dAtA[i] = 0xc2
			i++
			dAtA[i] = 0x6
			i++
			i = encodeVarintFelixbackend(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if len(m.NotDstNet) > 0 {
		for _, s := range m.NotDstNet {
			dAtA[i] = 0xca
			i++
			dAtA[i] = 0x6
			i++
			l = len(s)
			for l >= 1<<7 {
				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
				l >>= 7
				i++
			}
			dAtA[i] = uint8(l)
			i++
			i += copy(dAtA[i:], s)
		}
	}
	if len(m.NotDstPorts) > 0 {
		for _, msg := range m.NotDstPorts {
			dAtA[i] = 0xd2
			i++
			dAtA[i] = 0x6
			i++
			i = encodeVarintFelixbackend(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if m.NotIcmp != nil {
		nn57, err := m.NotIcmp.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += nn57
	}
	if len(m.NotSrcIpSetIds) > 0 {
		for _, s := range m.NotSrcIpSetIds {
			dAtA[i] = 0xea
			i++
			dAtA[i] = 0x6
			i++
			l = len(s)
			for l >= 1<<7 {
				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
				l >>= 7
				i++
			}
			dAtA[i] = uint8(l)
			i++
			i += copy(dAtA[i:], s)
		}
	}
	if len(m.NotDstIpSetIds) > 0 {
		for _, s := range m.NotDstIpSetIds {
			dAtA[i] = 0xf2
			i++
			dAtA[i] = 0x6
			i++
			l = len(s)
			for l >= 1<<7 {
				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
				l >>= 7
				i++
			}
			dAtA[i] = uint8(l)
			i++
			i += copy(dAtA[i:], s)
		}
	}
	if len(m.NotSrcNamedPortIpSetIds) > 0 {
		for _, s := range m.NotSrcNamedPortIpSetIds {
			dAtA[i] = 0x82
			i++
			dAtA[i] = 0x7
			i++
			l = len(s)
			for l >= 1<<7 {
				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
				l >>= 7
				i++
			}
			dAtA[i] = uint8(l)
			i++
			i += copy(dAtA[i:], s)
		}
	}
	if len(m.NotDstNamedPortIpSetIds) > 0 {
		for _, s := range m.NotDstNamedPortIpSetIds {
			dAtA[i] = 0x8a
			i++
			dAtA[i] = 0x7
			i++
			l = len(s)
			for l >= 1<<7 {
				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
				l >>= 7
				i++
			}
			dAtA[i] = uint8(l)
			i++
			i += copy(dAtA[i:], s)
		}
	}
	if len(m.OriginalSrcSelector) > 0 {
		dAtA[i] = 0x92
		i++
		dAtA[i] = 0x7
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.OriginalSrcSelector)))
		i += copy(dAtA[i:], m.OriginalSrcSelector)
	}
	if len(m.OriginalDstSelector) > 0 {
		dAtA[i] = 0x9a
		i++
		dAtA[i] = 0x7
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.OriginalDstSelector)))
		i += copy(dAtA[i:], m.OriginalDstSelector)
	}
	if len(m.OriginalSrcNamespaceSelector) > 0 {
		dAtA[i] = 0xa2
		i++
		dAtA[i] = 0x7
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.OriginalSrcNamespaceSelector)))
		i += copy(dAtA[i:], m.OriginalSrcNamespaceSelector)
	}
	if len(m.OriginalDstNamespaceSelector) > 0 {
		dAtA[i] = 0xaa
		i++
		dAtA[i] = 0x7
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.OriginalDstNamespaceSelector)))
		i += copy(dAtA[i:], m.OriginalDstNamespaceSelector)
	}
	if len(m.OriginalNotSrcSelector) > 0 {
		dAtA[i] = 0xb2
		i++
		dAtA[i] = 0x7
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.OriginalNotSrcSelector)))
		i += copy(dAtA[i:], m.OriginalNotSrcSelector)
	}
	if len(m.OriginalNotDstSelector) > 0 {
		dAtA[i] = 0xba
		i++
		dAtA[i] = 0x7
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.OriginalNotDstSelector)))
		i += copy(dAtA[i:], m.OriginalNotDstSelector)
	}
	if m.SrcServiceAccountMatch != nil {
		dAtA[i] = 0xc2
		i++
		dAtA[i] = 0x7
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.SrcServiceAccountMatch.Size()))
		n58, err := m.SrcServiceAccountMatch.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n58
	}
	if m.DstServiceAccountMatch != nil {
		dAtA[i] = 0xca
		i++
		dAtA[i] = 0x7
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.DstServiceAccountMatch.Size()))
		n59, err := m.DstServiceAccountMatch.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n59
	}
	if m.HttpMatch != nil {
		dAtA[i] = 0xd2
		i++
		dAtA[i] = 0x7
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.HttpMatch.Size()))
		n60, err := m.HttpMatch.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n60
	}
	if m.Metadata != nil {
		dAtA[i] = 0xda
		i++
		dAtA[i] = 0x7
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.Metadata.Size()))
		n61, err := m.Metadata.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n61
	}
	if len(m.OriginalDstService) > 0 {
		dAtA[i] = 0x92
		i++
		dAtA[i] = 0x8
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.OriginalDstService)))
		i += copy(dAtA[i:], m.OriginalDstService)
	}
	if len(m.OriginalDstServiceNamespace) > 0 {
		dAtA[i] = 0x9a
		i++
		dAtA[i] = 0x8
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.OriginalDstServiceNamespace)))
		i += copy(dAtA[i:], m.OriginalDstServiceNamespace)
	}
	if len(m.OriginalSrcService) > 0 {
		dAtA[i] = 0xa2
		i++
		dAtA[i] = 0x8
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.OriginalSrcService)))
		i += copy(dAtA[i:], m.OriginalSrcService)
	}
	if len(m.OriginalSrcServiceNamespace) > 0 {
		dAtA[i] = 0xaa
		i++
		dAtA[i] = 0x8
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.OriginalSrcServiceNamespace)))
		i += copy(dAtA[i:], m.OriginalSrcServiceNamespace)
	}
	if len(m.RuleId) > 0 {
		dAtA[i] = 0xca
		i++
		dAtA[i] = 0xc
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.RuleId)))
		i += copy(dAtA[i:], m.RuleId)
	}
	return i, nil
}

func (m *Rule_IcmpType) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	dAtA[i] = 0x40
	i++
	i = encodeVarintFelixbackend(dAtA, i, uint64(m.IcmpType))
	return i, nil
}
func (m *Rule_IcmpTypeCode) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.IcmpTypeCode != nil {
		dAtA[i] = 0x4a
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.IcmpTypeCode.Size()))
		n62, err := m.IcmpTypeCode.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n62
	}
	return i, nil
}
func (m *Rule_NotIcmpType) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	dAtA[i] = 0xd8
	i++
	dAtA[i] = 0x6
	i++
	i = encodeVarintFelixbackend(dAtA, i, uint64(m.NotIcmpType))
	return i, nil
}
func (m *Rule_NotIcmpTypeCode) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.NotIcmpTypeCode != nil {
		dAtA[i] = 0xe2
		i++
		dAtA[i] = 0x6
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.NotIcmpTypeCode.Size()))
		n63, err := m.NotIcmpTypeCode.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n63
	}
	return i, nil
}
func (m *ServiceAccountMatch) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ServiceAccountMatch) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Selector) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Selector)))
		i += copy(dAtA[i:], m.Selector)
	}
	if len(m.Names) > 0 {
		for _, s := range m.Names {
			dAtA[i] = 0x12
			i++
			l = len(s)
			for l >= 1<<7 {
				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
				l >>= 7
				i++
			}
			dAtA[i] = uint8(l)
			i++
			i += copy(dAtA[i:], s)
		}
	}
	return i, nil
}

func (m *HTTPMatch) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *HTTPMatch) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Methods) > 0 {
		for _, s := range m.Methods {
			dAtA[i] = 0xa
			i++
			l = len(s)
			for l >= 1<<7 {
				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
				l >>= 7
				i++
			}
			dAtA[i] = uint8(l)
			i++
			i += copy(dAtA[i:], s)
		}
	}
	if len(m.Paths) > 0 {
		for _, msg := range m.Paths {
			dAtA[i] = 0x12
			i++
			i = encodeVarintFelixbackend(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	return i, nil
}

func (m *HTTPMatch_PathMatch) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *HTTPMatch_PathMatch) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.PathMatch != nil {
		nn64, err := m.PathMatch.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += nn64
	}
	return i, nil
}

func (m *HTTPMatch_PathMatch_Exact) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	dAtA[i] = 0xa
	i++
	i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Exact)))
	i += copy(dAtA[i:], m.Exact)
	return i, nil
}
func (m *HTTPMatch_PathMatch_Prefix) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	dAtA[i] = 0x12
	i++
	i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Prefix)))
	i += copy(dAtA[i:], m.Prefix)
	return i, nil
}
func (m *RuleMetadata) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RuleMetadata) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Annotations) > 0 {
		for k, _ := range m.Annotations {
			dAtA[i] = 0xa
			i++
			v := m.Annotations[k]
			mapSize := 1 + len(k) + sovFelixbackend(uint64(len(k))) + 1 + len(v) + sovFelixbackend(uint64(len(v)))
			i = encodeVarintFelixbackend(dAtA, i, uint64(mapSize))
			dAtA[i] = 0xa
			i++
			i = encodeVarintFelixbackend(dAtA, i, uint64(len(k)))
			i += copy(dAtA[i:], k)
			dAtA[i] = 0x12
			i++
			i = encodeVarintFelixbackend(dAtA, i, uint64(len(v)))
			i += copy(dAtA[i:], v)
		}
	}
	return i, nil
}

func (m *IcmpTypeAndCode) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *IcmpTypeAndCode) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Type != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.Type))
	}
	if m.Code != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.Code))
	}
	return i, nil
}

func (m *Protocol) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Protocol) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.NumberOrName != nil {
		nn65, err := m.NumberOrName.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += nn65
	}
	return i, nil
}

func (m *Protocol_Number) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	dAtA[i] = 0x8
	i++
	i = encodeVarintFelixbackend(dAtA, i, uint64(m.Number))
	return i, nil
}
func (m *Protocol_Name) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	dAtA[i] = 0x12
	i++
	i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Name)))
	i += copy(dAtA[i:], m.Name)
	return i, nil
}
func (m *PortRange) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *PortRange) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.First != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.First))
	}
	if m.Last != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.Last))
	}
	return i, nil
}

func (m *WorkloadEndpointID) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *WorkloadEndpointID) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.OrchestratorId) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.OrchestratorId)))
		i += copy(dAtA[i:], m.OrchestratorId)
	}
	if len(m.WorkloadId) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.WorkloadId)))
		i += copy(dAtA[i:], m.WorkloadId)
	}
	if len(m.EndpointId) > 0 {
		dAtA[i] = 0x22
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.EndpointId)))
		i += copy(dAtA[i:], m.EndpointId)
	}
	return i, nil
}

func (m *WorkloadEndpointUpdate) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *WorkloadEndpointUpdate) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Id != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.Id.Size()))
		n66, err := m.Id.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n66
	}
	if m.Endpoint != nil {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.Endpoint.Size()))
		n67, err := m.Endpoint.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n67
	}
	return i, nil
}

func (m *WorkloadEndpoint) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *WorkloadEndpoint) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.State) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.State)))
		i += copy(dAtA[i:], m.State)
	}
	if len(m.Name) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Name)))
		i += copy(dAtA[i:], m.Name)
	}
	if len(m.Mac) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Mac)))
		i += copy(dAtA[i:], m.Mac)
	}
	if len(m.ProfileIds) > 0 {
		for _, s := range m.ProfileIds {
			dAtA[i] = 0x22
			i++
			l = len(s)
			for l >= 1<<7 {
				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
				l >>= 7
				i++
			}
			dAtA[i] = uint8(l)
			i++
			i += copy(dAtA[i:], s)
		}
	}
	if len(m.Ipv4Nets) > 0 {
		for _, s := range m.Ipv4Nets {
			dAtA[i] = 0x2a
			i++
			l = len(s)
			for l >= 1<<7 {
				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
				l >>= 7
				i++
			}
			dAtA[i] = uint8(l)
			i++
			i += copy(dAtA[i:], s)
		}
	}
	if len(m.Ipv6Nets) > 0 {
		for _, s := range m.Ipv6Nets {
			dAtA[i] = 0x32
			i++
			l = len(s)
			for l >= 1<<7 {
				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
				l >>= 7
				i++
			}
			dAtA[i] = uint8(l)
			i++
			i += copy(dAtA[i:], s)
		}
	}
	if len(m.Tiers) > 0 {
		for _, msg := range m.Tiers {
			dAtA[i] = 0x3a
			i++
			i = encodeVarintFelixbackend(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if len(m.Ipv4Nat) > 0 {
		for _, msg := range m.Ipv4Nat {
			dAtA[i] = 0x42
			i++
			i = encodeVarintFelixbackend(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if len(m.Ipv6Nat) > 0 {
		for _, msg := range m.Ipv6Nat {
			dAtA[i] = 0x4a
			i++
			i = encodeVarintFelixbackend(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if len(m.AllowSpoofedSourcePrefixes) > 0 {
		for _, s := range m.AllowSpoofedSourcePrefixes {
			dAtA[i] = 0x52
			i++
			l = len(s)
			for l >= 1<<7 {
				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
				l >>= 7
				i++
			}
			dAtA[i] = uint8(l)
			i++
			i += copy(dAtA[i:], s)
		}
	}
	if len(m.Annotations) > 0 {
		for k, _ := range m.Annotations {
			dAtA[i] = 0x5a
			i++
			v := m.Annotations[k]
			mapSize := 1 + len(k) + sovFelixbackend(uint64(len(k))) + 1 + len(v) + sovFelixbackend(uint64(len(v)))
			i = encodeVarintFelixbackend(dAtA, i, uint64(mapSize))
			dAtA[i] = 0xa
			i++
			i = encodeVarintFelixbackend(dAtA, i, uint64(len(k)))
			i += copy(dAtA[i:], k)
			dAtA[i] = 0x12
			i++
			i = encodeVarintFelixbackend(dAtA, i, uint64(len(v)))
			i += copy(dAtA[i:], v)
		}
	}
	return i, nil
}

func (m *WorkloadEndpointRemove) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *WorkloadEndpointRemove) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Id != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.Id.Size()))
		n68, err := m.Id.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n68
	}
	return i, nil
}

func (m *HostEndpointID) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *HostEndpointID) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.EndpointId) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.EndpointId)))
		i += copy(dAtA[i:], m.EndpointId)
	}
	return i, nil
}

func (m *HostEndpointUpdate) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *HostEndpointUpdate) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Id != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.Id.Size()))
		n69, err := m.Id.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n69
	}
	if m.Endpoint != nil {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.Endpoint.Size()))
		n70, err := m.Endpoint.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n70
	}
	return i, nil
}

func (m *HostEndpoint) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *HostEndpoint) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Name) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Name)))
		i += copy(dAtA[i:], m.Name)
	}
	if len(m.ProfileIds) > 0 {
		for _, s := range m.ProfileIds {
			dAtA[i] = 0x12
			i++
			l = len(s)
			for l >= 1<<7 {
				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
				l >>= 7
				i++
			}
			dAtA[i] = uint8(l)
			i++
			i += copy(dAtA[i:], s)
		}
	}
	if len(m.Tiers) > 0 {
		for _, msg := range m.Tiers {
			dAtA[i] = 0x1a
			i++
			i = encodeVarintFelixbackend(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if len(m.ExpectedIpv4Addrs) > 0 {
		for _, s := range m.ExpectedIpv4Addrs {
			dAtA[i] = 0x22
			i++
			l = len(s)
			for l >= 1<<7 {
				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
				l >>= 7
				i++
			}
			dAtA[i] = uint8(l)
			i++
			i += copy(dAtA[i:], s)
		}
	}
	if len(m.ExpectedIpv6Addrs) > 0 {
		for _, s := range m.ExpectedIpv6Addrs {
			dAtA[i] = 0x2a
			i++
			l = len(s)
			for l >= 1<<7 {
				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
				l >>= 7
				i++
			}
			dAtA[i] = uint8(l)
			i++
			i += copy(dAtA[i:], s)
		}
	}
	if len(m.UntrackedTiers) > 0 {
		for _, msg := range m.UntrackedTiers {
			dAtA[i] = 0x32
			i++
			i = encodeVarintFelixbackend(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if len(m.PreDnatTiers) > 0 {
		for _, msg := range m.PreDnatTiers {
			dAtA[i] = 0x3a
			i++
			i = encodeVarintFelixbackend(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if len(m.ForwardTiers) > 0 {
		for _, msg := range m.ForwardTiers {
			dAtA[i] = 0x42
			i++
			i = encodeVarintFelixbackend(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	return i, nil
}

func (m *HostEndpointRemove) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *HostEndpointRemove) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Id != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.Id.Size()))
		n71, err := m.Id.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n71
	}
	return i, nil
}

func (m *TierInfo) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *TierInfo) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Name) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Name)))
		i += copy(dAtA[i:], m.Name)
	}
	if len(m.IngressPolicies) > 0 {
		for _, s := range m.IngressPolicies {
			dAtA[i] = 0x12
			i++
			l = len(s)
			for l >= 1<<7 {
				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
				l >>= 7
				i++
			}
			dAtA[i] = uint8(l)
			i++
			i += copy(dAtA[i:], s)
		}
	}
	if len(m.EgressPolicies) > 0 {
		for _, s := range m.EgressPolicies {
			dAtA[i] = 0x1a
			i++
			l = len(s)
			for l >= 1<<7 {
				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
				l >>= 7
				i++
			}
			dAtA[i] = uint8(l)
			i++
			i += copy(dAtA[i:], s)
		}
	}
	if len(m.DefaultAction) > 0 {
		dAtA[i] = 0x22
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.DefaultAction)))
		i += copy(dAtA[i:], m.DefaultAction)
	}
	return i, nil
}

func (m *NatInfo) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *NatInfo) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.ExtIp) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.ExtIp)))
		i += copy(dAtA[i:], m.ExtIp)
	}
	if len(m.IntIp) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.IntIp)))
		i += copy(dAtA[i:], m.IntIp)
	}
	return i, nil
}

func (m *ProcessStatusUpdate) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ProcessStatusUpdate) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.IsoTimestamp) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.IsoTimestamp)))
		i += copy(dAtA[i:], m.IsoTimestamp)
	}
	if m.Uptime != 0 {
		dAtA[i] = 0x11
		i++
		binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Uptime))))
		i += 8
	}
	return i, nil
}

func (m *HostEndpointStatusUpdate) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *HostEndpointStatusUpdate) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Id != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.Id.Size()))
		n72, err := m.Id.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n72
	}
	if m.Status != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.Status.Size()))
		n73, err := m.Status.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n73
	}
	return i, nil
}

func (m *EndpointStatus) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *EndpointStatus) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Status) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Status)))
		i += copy(dAtA[i:], m.Status)
	}
	return i, nil
}

func (m *HostEndpointStatusRemove) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *HostEndpointStatusRemove) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Id != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.Id.Size()))
		n74, err := m.Id.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n74
	}
	return i, nil
}

func (m *WorkloadEndpointStatusUpdate) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *WorkloadEndpointStatusUpdate) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Id != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.Id.Size()))
		n75, err := m.Id.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n75
	}
	if m.Status != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.Status.Size()))
		n76, err := m.Status.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n76
	}
	return i, nil
}

func (m *WorkloadEndpointStatusRemove) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *WorkloadEndpointStatusRemove) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Id != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.Id.Size()))
		n77, err := m.Id.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n77
	}
	return i, nil
}

func (m *WireguardStatusUpdate) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *WireguardStatusUpdate) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.PublicKey) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.PublicKey)))
		i += copy(dAtA[i:], m.PublicKey)
	}
	if m.IpVersion != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.IpVersion))
	}
	return i, nil
}

func (m *DataplaneInSync) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *DataplaneInSync) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	return i, nil
}

func (m *HostMetadataV4V6Update) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *HostMetadataV4V6Update) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Hostname) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Hostname)))
		i += copy(dAtA[i:], m.Hostname)
	}
	if len(m.Ipv4Addr) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Ipv4Addr)))
		i += copy(dAtA[i:], m.Ipv4Addr)
	}
	if len(m.Ipv6Addr) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Ipv6Addr)))
		i += copy(dAtA[i:], m.Ipv6Addr)
	}
	if len(m.Asnumber) > 0 {
		dAtA[i] = 0x22
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Asnumber)))
		i += copy(dAtA[i:], m.Asnumber)
	}
	if len(m.Labels) > 0 {
		for k, _ := range m.Labels {
			dAtA[i] = 0x2a
			i++
			v := m.Labels[k]
			mapSize := 1 + len(k) + sovFelixbackend(uint64(len(k))) + 1 + len(v) + sovFelixbackend(uint64(len(v)))
			i = encodeVarintFelixbackend(dAtA, i, uint64(mapSize))
			dAtA[i] = 0xa
			i++
			i = encodeVarintFelixbackend(dAtA, i, uint64(len(k)))
			i += copy(dAtA[i:], k)
			dAtA[i] = 0x12
			i++
			i = encodeVarintFelixbackend(dAtA, i, uint64(len(v)))
			i += copy(dAtA[i:], v)
		}
	}
	return i, nil
}

func (m *HostMetadataV4V6Remove) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *HostMetadataV4V6Remove) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Hostname) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Hostname)))
		i += copy(dAtA[i:], m.Hostname)
	}
	if len(m.Ipv4Addr) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Ipv4Addr)))
		i += copy(dAtA[i:], m.Ipv4Addr)
	}
	return i, nil
}

func (m *HostMetadataUpdate) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *HostMetadataUpdate) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Hostname) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Hostname)))
		i += copy(dAtA[i:], m.Hostname)
	}
	if len(m.Ipv4Addr) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Ipv4Addr)))
		i += copy(dAtA[i:], m.Ipv4Addr)
	}
	return i, nil
}

func (m *HostMetadataRemove) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *HostMetadataRemove) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Hostname) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Hostname)))
		i += copy(dAtA[i:], m.Hostname)
	}
	if len(m.Ipv4Addr) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Ipv4Addr)))
		i += copy(dAtA[i:], m.Ipv4Addr)
	}
	return i, nil
}

func (m *HostMetadataV6Update) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *HostMetadataV6Update) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Hostname) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Hostname)))
		i += copy(dAtA[i:], m.Hostname)
	}
	if len(m.Ipv6Addr) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Ipv6Addr)))
		i += copy(dAtA[i:], m.Ipv6Addr)
	}
	return i, nil
}

func (m *HostMetadataV6Remove) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *HostMetadataV6Remove) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Hostname) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Hostname)))
		i += copy(dAtA[i:], m.Hostname)
	}
	if len(m.Ipv6Addr) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Ipv6Addr)))
		i += copy(dAtA[i:], m.Ipv6Addr)
	}
	return i, nil
}

func (m *IPAMPoolUpdate) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *IPAMPoolUpdate) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Id) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Id)))
		i += copy(dAtA[i:], m.Id)
	}
	if m.Pool != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.Pool.Size()))
		n78, err := m.Pool.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n78
	}
	return i, nil
}

func (m *IPAMPoolRemove) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *IPAMPoolRemove) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Id) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Id)))
		i += copy(dAtA[i:], m.Id)
	}
	return i, nil
}

func (m *IPAMPool) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *IPAMPool) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Cidr) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Cidr)))
		i += copy(dAtA[i:], m.Cidr)
	}
	if m.Masquerade {
		dAtA[i] = 0x10
		i++
		if m.Masquerade {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if len(m.IpipMode) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.IpipMode)))
		i += copy(dAtA[i:], m.IpipMode)
	}
	if len(m.VxlanMode) > 0 {
		dAtA[i] = 0x22
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.VxlanMode)))
		i += copy(dAtA[i:], m.VxlanMode)
	}
	return i, nil
}

func (m *Encapsulation) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Encapsulation) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.IpipEnabled {
		dAtA[i] = 0x8
		i++
		if m.IpipEnabled {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if m.VxlanEnabled {
		dAtA[i] = 0x10
		i++
		if m.VxlanEnabled {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if m.VxlanEnabledV6 {
		dAtA[i] = 0x18
		i++
		if m.VxlanEnabledV6 {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	return i, nil
}

func (m *ServiceAccountUpdate) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ServiceAccountUpdate) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Id != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.Id.Size()))
		n79, err := m.Id.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n79
	}
	if len(m.Labels) > 0 {
		for k, _ := range m.Labels {
			dAtA[i] = 0x12
			i++
			v := m.Labels[k]
			mapSize := 1 + len(k) + sovFelixbackend(uint64(len(k))) + 1 + len(v) + sovFelixbackend(uint64(len(v)))
			i = encodeVarintFelixbackend(dAtA, i, uint64(mapSize))
			dAtA[i] = 0xa
			i++
			i = encodeVarintFelixbackend(dAtA, i, uint64(len(k)))
			i += copy(dAtA[i:], k)
			dAtA[i] = 0x12
			i++
			i = encodeVarintFelixbackend(dAtA, i, uint64(len(v)))
			i += copy(dAtA[i:], v)
		}
	}
	return i, nil
}

func (m *ServiceAccountRemove) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ServiceAccountRemove) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Id != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.Id.Size()))
		n80, err := m.Id.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n80
	}
	return i, nil
}

func (m *ServiceAccountID) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ServiceAccountID) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Namespace) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Namespace)))
		i += copy(dAtA[i:], m.Namespace)
	}
	if len(m.Name) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Name)))
		i += copy(dAtA[i:], m.Name)
	}
	return i, nil
}

func (m *NamespaceUpdate) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *NamespaceUpdate) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Id != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.Id.Size()))
		n81, err := m.Id.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n81
	}
	if len(m.Labels) > 0 {
		for k, _ := range m.Labels {
			dAtA[i] = 0x12
			i++
			v := m.Labels[k]
			mapSize := 1 + len(k) + sovFelixbackend(uint64(len(k))) + 1 + len(v) + sovFelixbackend(uint64(len(v)))
			i = encodeVarintFelixbackend(dAtA, i, uint64(mapSize))
			dAtA[i] = 0xa
			i++
			i = encodeVarintFelixbackend(dAtA, i, uint64(len(k)))
			i += copy(dAtA[i:], k)
			dAtA[i] = 0x12
			i++
			i = encodeVarintFelixbackend(dAtA, i, uint64(len(v)))
			i += copy(dAtA[i:], v)
		}
	}
	return i, nil
}

func (m *NamespaceRemove) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *NamespaceRemove) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Id != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.Id.Size()))
		n82, err := m.Id.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n82
	}
	return i, nil
}

func (m *NamespaceID) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *NamespaceID) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Name) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Name)))
		i += copy(dAtA[i:], m.Name)
	}
	return i, nil
}

func (m *TunnelType) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *TunnelType) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Ipip {
		dAtA[i] = 0x8
		i++
		if m.Ipip {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if m.Vxlan {
		dAtA[i] = 0x10
		i++
		if m.Vxlan {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if m.Wireguard {
		dAtA[i] = 0x18
		i++
		if m.Wireguard {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	return i, nil
}

func (m *RouteUpdate) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RouteUpdate) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Type != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.Type))
	}
	if m.IpPoolType != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.IpPoolType))
	}
	if len(m.Dst) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Dst)))
		i += copy(dAtA[i:], m.Dst)
	}
	if len(m.DstNodeName) > 0 {
		dAtA[i] = 0x22
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.DstNodeName)))
		i += copy(dAtA[i:], m.DstNodeName)
	}
	if len(m.DstNodeIp) > 0 {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.DstNodeIp)))
		i += copy(dAtA[i:], m.DstNodeIp)
	}
	if m.SameSubnet {
		dAtA[i] = 0x38
		i++
		if m.SameSubnet {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if m.NatOutgoing {
		dAtA[i] = 0x40
		i++
		if m.NatOutgoing {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if m.LocalWorkload {
		dAtA[i] = 0x48
		i++
		if m.LocalWorkload {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if m.TunnelType != nil {
		dAtA[i] = 0x52
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.TunnelType.Size()))
		n83, err := m.TunnelType.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n83
	}
	if m.Borrowed {
		dAtA[i] = 0x58
		i++
		if m.Borrowed {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	return i, nil
}

func (m *RouteRemove) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RouteRemove) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Dst) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Dst)))
		i += copy(dAtA[i:], m.Dst)
	}
	return i, nil
}

func (m *VXLANTunnelEndpointUpdate) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *VXLANTunnelEndpointUpdate) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Node) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Node)))
		i += copy(dAtA[i:], m.Node)
	}
	if len(m.Mac) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Mac)))
		i += copy(dAtA[i:], m.Mac)
	}
	if len(m.Ipv4Addr) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Ipv4Addr)))
		i += copy(dAtA[i:], m.Ipv4Addr)
	}
	if len(m.ParentDeviceIp) > 0 {
		dAtA[i] = 0x22
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.ParentDeviceIp)))
		i += copy(dAtA[i:], m.ParentDeviceIp)
	}
	if len(m.MacV6) > 0 {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.MacV6)))
		i += copy(dAtA[i:], m.MacV6)
	}
	if len(m.Ipv6Addr) > 0 {
		dAtA[i] = 0x32
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Ipv6Addr)))
		i += copy(dAtA[i:], m.Ipv6Addr)
	}
	if len(m.ParentDeviceIpv6) > 0 {
		dAtA[i] = 0x3a
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.ParentDeviceIpv6)))
		i += copy(dAtA[i:], m.ParentDeviceIpv6)
	}
	return i, nil
}

func (m *VXLANTunnelEndpointRemove) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *VXLANTunnelEndpointRemove) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Node) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Node)))
		i += copy(dAtA[i:], m.Node)
	}
	return i, nil
}

func (m *WireguardEndpointUpdate) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *WireguardEndpointUpdate) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Hostname) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Hostname)))
		i += copy(dAtA[i:], m.Hostname)
	}
	if len(m.PublicKey) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.PublicKey)))
		i += copy(dAtA[i:], m.PublicKey)
	}
	if len(m.InterfaceIpv4Addr) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.InterfaceIpv4Addr)))
		i += copy(dAtA[i:], m.InterfaceIpv4Addr)
	}
	return i, nil
}

func (m *WireguardEndpointRemove) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *WireguardEndpointRemove) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Hostname) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Hostname)))
		i += copy(dAtA[i:], m.Hostname)
	}
	return i, nil
}

func (m *WireguardEndpointV6Update) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *WireguardEndpointV6Update) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Hostname) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Hostname)))
		i += copy(dAtA[i:], m.Hostname)
	}
	if len(m.PublicKeyV6) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.PublicKeyV6)))
		i += copy(dAtA[i:], m.PublicKeyV6)
	}
	if len(m.InterfaceIpv6Addr) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.InterfaceIpv6Addr)))
		i += copy(dAtA[i:], m.InterfaceIpv6Addr)
	}
	return i, nil
}

func (m *WireguardEndpointV6Remove) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *WireguardEndpointV6Remove) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Hostname) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Hostname)))
		i += copy(dAtA[i:], m.Hostname)
	}
	return i, nil
}

func (m *GlobalBGPConfigUpdate) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GlobalBGPConfigUpdate) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.ServiceClusterCidrs) > 0 {
		for _, s := range m.ServiceClusterCidrs {
			dAtA[i] = 0xa
			i++
			l = len(s)
			for l >= 1<<7 {
				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
				l >>= 7
				i++
			}
			dAtA[i] = uint8(l)
			i++
			i += copy(dAtA[i:], s)
		}
	}
	if len(m.ServiceExternalCidrs) > 0 {
		for _, s := range m.ServiceExternalCidrs {
			dAtA[i] = 0x12
			i++
			l = len(s)
			for l >= 1<<7 {
				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
				l >>= 7
				i++
			}
			dAtA[i] = uint8(l)
			i++
			i += copy(dAtA[i:], s)
		}
	}
	if len(m.ServiceLoadbalancerCidrs) > 0 {
		for _, s := range m.ServiceLoadbalancerCidrs {
			dAtA[i] = 0x1a
			i++
			l = len(s)
			for l >= 1<<7 {
				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
				l >>= 7
				i++
			}
			dAtA[i] = uint8(l)
			i++
			i += copy(dAtA[i:], s)
		}
	}
	return i, nil
}

func (m *ServicePort) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ServicePort) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Protocol) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Protocol)))
		i += copy(dAtA[i:], m.Protocol)
	}
	if m.Port != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.Port))
	}
	if m.NodePort != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(m.NodePort))
	}
	return i, nil
}

func (m *ServiceUpdate) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ServiceUpdate) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Name) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Name)))
		i += copy(dAtA[i:], m.Name)
	}
	if len(m.Namespace) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Namespace)))
		i += copy(dAtA[i:], m.Namespace)
	}
	if len(m.Type) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Type)))
		i += copy(dAtA[i:], m.Type)
	}
	if len(m.ClusterIps) > 0 {
		for _, s := range m.ClusterIps {
			dAtA[i] = 0x22
			i++
			l = len(s)
			for l >= 1<<7 {
				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
				l >>= 7
				i++
			}
			dAtA[i] = uint8(l)
			i++
			i += copy(dAtA[i:], s)
		}
	}
	if len(m.LoadbalancerIp) > 0 {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.LoadbalancerIp)))
		i += copy(dAtA[i:], m.LoadbalancerIp)
	}
	if len(m.ExternalIps) > 0 {
		for _, s := range m.ExternalIps {
			dAtA[i] = 0x32
			i++
			l = len(s)
			for l >= 1<<7 {
				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
				l >>= 7
				i++
			}
			dAtA[i] = uint8(l)
			i++
			i += copy(dAtA[i:], s)
		}
	}
	if len(m.Ports) > 0 {
		for _, msg := range m.Ports {
			dAtA[i] = 0x3a
			i++
			i = encodeVarintFelixbackend(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	return i, nil
}

func (m *ServiceRemove) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ServiceRemove) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Name) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Name)))
		i += copy(dAtA[i:], m.Name)
	}
	if len(m.Namespace) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Namespace)))
		i += copy(dAtA[i:], m.Namespace)
	}
	return i, nil
}

func encodeVarintFelixbackend(dAtA []byte, offset int, v uint64) int {
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return offset + 1
}
func (m *SyncRequest) Size() (n int) {
	var l int
	_ = l
	return n
}

func (m *ToDataplane) Size() (n int) {
	var l int
	_ = l
	if m.Payload != nil {
		n += m.Payload.Size()
	}
	if m.SequenceNumber != 0 {
		n += 1 + sovFelixbackend(uint64(m.SequenceNumber))
	}
	return n
}

func (m *ToDataplane_InSync) Size() (n int) {
	var l int
	_ = l
	if m.InSync != nil {
		l = m.InSync.Size()
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	return n
}
func (m *ToDataplane_IpsetUpdate) Size() (n int) {
	var l int
	_ = l
	if m.IpsetUpdate != nil {
		l = m.IpsetUpdate.Size()
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	return n
}
func (m *ToDataplane_IpsetDeltaUpdate) Size() (n int) {
	var l int
	_ = l
	if m.IpsetDeltaUpdate != nil {
		l = m.IpsetDeltaUpdate.Size()
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	return n
}
func (m *ToDataplane_IpsetRemove) Size() (n int) {
	var l int
	_ = l
	if m.IpsetRemove != nil {
		l = m.IpsetRemove.Size()
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	return n
}
func (m *ToDataplane_ActiveProfileUpdate) Size() (n int) {
	var l int
	_ = l
	if m.ActiveProfileUpdate != nil {
		l = m.ActiveProfileUpdate.Size()
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	return n
}
func (m *ToDataplane_ActiveProfileRemove) Size() (n int) {
	var l int
	_ = l
	if m.ActiveProfileRemove != nil {
		l = m.ActiveProfileRemove.Size()
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	return n
}
func (m *ToDataplane_ActivePolicyUpdate) Size() (n int) {
	var l int
	_ = l
	if m.ActivePolicyUpdate != nil {
		l = m.ActivePolicyUpdate.Size()
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	return n
}
func (m *ToDataplane_ActivePolicyRemove) Size() (n int) {
	var l int
	_ = l
	if m.ActivePolicyRemove != nil {
		l = m.ActivePolicyRemove.Size()
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	return n
}
func (m *ToDataplane_HostEndpointUpdate) Size() (n int) {
	var l int
	_ = l
	if m.HostEndpointUpdate != nil {
		l = m.HostEndpointUpdate.Size()
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	return n
}
func (m *ToDataplane_HostEndpointRemove) Size() (n int) {
	var l int
	_ = l
	if m.HostEndpointRemove != nil {
		l = m.HostEndpointRemove.Size()
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	return n
}
func (m *ToDataplane_WorkloadEndpointUpdate) Size() (n int) {
	var l int
	_ = l
	if m.WorkloadEndpointUpdate != nil {
		l = m.WorkloadEndpointUpdate.Size()
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	return n
}
func (m *ToDataplane_WorkloadEndpointRemove) Size() (n int) {
	var l int
	_ = l
	if m.WorkloadEndpointRemove != nil {
		l = m.WorkloadEndpointRemove.Size()
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	return n
}
func (m *ToDataplane_ConfigUpdate) Size() (n int) {
	var l int
	_ = l
	if m.ConfigUpdate != nil {
		l = m.ConfigUpdate.Size()
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	return n
}
func (m *ToDataplane_HostMetadataUpdate) Size() (n int) {
	var l int
	_ = l
	if m.HostMetadataUpdate != nil {
		l = m.HostMetadataUpdate.Size()
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	return n
}
func (m *ToDataplane_IpamPoolUpdate) Size() (n int) {
	var l int
	_ = l
	if m.IpamPoolUpdate != nil {
		l = m.IpamPoolUpdate.Size()
		n += 2 + l + sovFelixbackend(uint64(l))
	}
	return n
}
func (m *ToDataplane_IpamPoolRemove) Size() (n int) {
	var l int
	_ = l
	if m.IpamPoolRemove != nil {
		l = m.IpamPoolRemove.Size()
		n += 2 + l + sovFelixbackend(uint64(l))
	}
	return n
}
func (m *ToDataplane_HostMetadataRemove) Size() (n int) {
	var l int
	_ = l
	if m.HostMetadataRemove != nil {
		l = m.HostMetadataRemove.Size()
		n += 2 + l + sovFelixbackend(uint64(l))
	}
	return n
}
func (m *ToDataplane_ServiceAccountUpdate) Size() (n int) {
	var l int
	_ = l
	if m.ServiceAccountUpdate != nil {
		l = m.ServiceAccountUpdate.Size()
		n += 2 + l + sovFelixbackend(uint64(l))
	}
	return n
}
func (m *ToDataplane_ServiceAccountRemove) Size() (n int) {
	var l int
	_ = l
	if m.ServiceAccountRemove != nil {
		l = m.ServiceAccountRemove.Size()
		n += 2 + l + sovFelixbackend(uint64(l))
	}
	return n
}
func (m *ToDataplane_NamespaceUpdate) Size() (n int) {
	var l int
	_ = l
	if m.NamespaceUpdate != nil {
		l = m.NamespaceUpdate.Size()
		n += 2 + l + sovFelixbackend(uint64(l))
	}
	return n
}
func (m *ToDataplane_NamespaceRemove) Size() (n int) {
	var l int
	_ = l
	if m.NamespaceRemove != nil {
		l = m.NamespaceRemove.Size()
		n += 2 + l + sovFelixbackend(uint64(l))
	}
	return n
}
func (m *ToDataplane_RouteUpdate) Size() (n int) {
	var l int
	_ = l
	if m.RouteUpdate != nil {
		l = m.RouteUpdate.Size()
		n += 2 + l + sovFelixbackend(uint64(l))
	}
	return n
}
func (m *ToDataplane_RouteRemove) Size() (n int) {
	var l int
	_ = l
	if m.RouteRemove != nil {
		l = m.RouteRemove.Size()
		n += 2 + l + sovFelixbackend(uint64(l))
	}
	return n
}
func (m *ToDataplane_VtepUpdate) Size() (n int) {
	var l int
	_ = l
	if m.VtepUpdate != nil {
		l = m.VtepUpdate.Size()
		n += 2 + l + sovFelixbackend(uint64(l))
	}
	return n
}
func (m *ToDataplane_VtepRemove) Size() (n int) {
	var l int
	_ = l
	if m.VtepRemove != nil {
		l = m.VtepRemove.Size()
		n += 2 + l + sovFelixbackend(uint64(l))
	}
	return n
}
func (m *ToDataplane_WireguardEndpointUpdate) Size() (n int) {
	var l int
	_ = l
	if m.WireguardEndpointUpdate != nil {
		l = m.WireguardEndpointUpdate.Size()
		n += 2 + l + sovFelixbackend(uint64(l))
	}
	return n
}
func (m *ToDataplane_WireguardEndpointRemove) Size() (n int) {
	var l int
	_ = l
	if m.WireguardEndpointRemove != nil {
		l = m.WireguardEndpointRemove.Size()
		n += 2 + l + sovFelixbackend(uint64(l))
	}
	return n
}
func (m *ToDataplane_GlobalBgpConfigUpdate) Size() (n int) {
	var l int
	_ = l
	if m.GlobalBgpConfigUpdate != nil {
		l = m.GlobalBgpConfigUpdate.Size()
		n += 2 + l + sovFelixbackend(uint64(l))
	}
	return n
}
func (m *ToDataplane_Encapsulation) Size() (n int) {
	var l int
	_ = l
	if m.Encapsulation != nil {
		l = m.Encapsulation.Size()
		n += 2 + l + sovFelixbackend(uint64(l))
	}
	return n
}
func (m *ToDataplane_ServiceUpdate) Size() (n int) {
	var l int
	_ = l
	if m.ServiceUpdate != nil {
		l = m.ServiceUpdate.Size()
		n += 2 + l + sovFelixbackend(uint64(l))
	}
	return n
}
func (m *ToDataplane_ServiceRemove) Size() (n int) {
	var l int
	_ = l
	if m.ServiceRemove != nil {
		l = m.ServiceRemove.Size()
		n += 2 + l + sovFelixbackend(uint64(l))
	}
	return n
}
func (m *ToDataplane_WireguardEndpointV6Update) Size() (n int) {
	var l int
	_ = l
	if m.WireguardEndpointV6Update != nil {
		l = m.WireguardEndpointV6Update.Size()
		n += 2 + l + sovFelixbackend(uint64(l))
	}
	return n
}
func (m *ToDataplane_WireguardEndpointV6Remove) Size() (n int) {
	var l int
	_ = l
	if m.WireguardEndpointV6Remove != nil {
		l = m.WireguardEndpointV6Remove.Size()
		n += 2 + l + sovFelixbackend(uint64(l))
	}
	return n
}
func (m *ToDataplane_HostMetadataV6Update) Size() (n int) {
	var l int
	_ = l
	if m.HostMetadataV6Update != nil {
		l = m.HostMetadataV6Update.Size()
		n += 2 + l + sovFelixbackend(uint64(l))
	}
	return n
}
func (m *ToDataplane_HostMetadataV6Remove) Size() (n int) {
	var l int
	_ = l
	if m.HostMetadataV6Remove != nil {
		l = m.HostMetadataV6Remove.Size()
		n += 2 + l + sovFelixbackend(uint64(l))
	}
	return n
}
func (m *ToDataplane_HostMetadataV4V6Update) Size() (n int) {
	var l int
	_ = l
	if m.HostMetadataV4V6Update != nil {
		l = m.HostMetadataV4V6Update.Size()
		n += 2 + l + sovFelixbackend(uint64(l))
	}
	return n
}
func (m *ToDataplane_HostMetadataV4V6Remove) Size() (n int) {
	var l int
	_ = l
	if m.HostMetadataV4V6Remove != nil {
		l = m.HostMetadataV4V6Remove.Size()
		n += 2 + l + sovFelixbackend(uint64(l))
	}
	return n
}
func (m *FromDataplane) Size() (n int) {
	var l int
	_ = l
	if m.Payload != nil {
		n += m.Payload.Size()
	}
	if m.SequenceNumber != 0 {
		n += 1 + sovFelixbackend(uint64(m.SequenceNumber))
	}
	return n
}

func (m *FromDataplane_ProcessStatusUpdate) Size() (n int) {
	var l int
	_ = l
	if m.ProcessStatusUpdate != nil {
		l = m.ProcessStatusUpdate.Size()
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	return n
}
func (m *FromDataplane_HostEndpointStatusUpdate) Size() (n int) {
	var l int
	_ = l
	if m.HostEndpointStatusUpdate != nil {
		l = m.HostEndpointStatusUpdate.Size()
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	return n
}
func (m *FromDataplane_HostEndpointStatusRemove) Size() (n int) {
	var l int
	_ = l
	if m.HostEndpointStatusRemove != nil {
		l = m.HostEndpointStatusRemove.Size()
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	return n
}
func (m *FromDataplane_WorkloadEndpointStatusUpdate) Size() (n int) {
	var l int
	_ = l
	if m.WorkloadEndpointStatusUpdate != nil {
		l = m.WorkloadEndpointStatusUpdate.Size()
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	return n
}
func (m *FromDataplane_WorkloadEndpointStatusRemove) Size() (n int) {
	var l int
	_ = l
	if m.WorkloadEndpointStatusRemove != nil {
		l = m.WorkloadEndpointStatusRemove.Size()
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	return n
}
func (m *FromDataplane_WireguardStatusUpdate) Size() (n int) {
	var l int
	_ = l
	if m.WireguardStatusUpdate != nil {
		l = m.WireguardStatusUpdate.Size()
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	return n
}
func (m *FromDataplane_DataplaneInSync) Size() (n int) {
	var l int
	_ = l
	if m.DataplaneInSync != nil {
		l = m.DataplaneInSync.Size()
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	return n
}
func (m *ConfigUpdate) Size() (n int) {
	var l int
	_ = l
	if len(m.Config) > 0 {
		for k, v := range m.Config {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovFelixbackend(uint64(len(k))) + 1 + len(v) + sovFelixbackend(uint64(len(v)))
			n += mapEntrySize + 1 + sovFelixbackend(uint64(mapEntrySize))
		}
	}
	if len(m.SourceToRawConfig) > 0 {
		for k, v := range m.SourceToRawConfig {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = v.Size()
				l += 1 + sovFelixbackend(uint64(l))
			}
			mapEntrySize := 1 + sovFelixbackend(uint64(k)) + l
			n += mapEntrySize + 1 + sovFelixbackend(uint64(mapEntrySize))
		}
	}
	l = len(m.Message)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	return n
}

func (m *RawConfig) Size() (n int) {
	var l int
	_ = l
	l = len(m.Source)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	if len(m.Config) > 0 {
		for k, v := range m.Config {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovFelixbackend(uint64(len(k))) + 1 + len(v) + sovFelixbackend(uint64(len(v)))
			n += mapEntrySize + 1 + sovFelixbackend(uint64(mapEntrySize))
		}
	}
	return n
}

func (m *InSync) Size() (n int) {
	var l int
	_ = l
	return n
}

func (m *IPSetUpdate) Size() (n int) {
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	if len(m.Members) > 0 {
		for _, s := range m.Members {
			l = len(s)
			n += 1 + l + sovFelixbackend(uint64(l))
		}
	}
	if m.Type != 0 {
		n += 1 + sovFelixbackend(uint64(m.Type))
	}
	return n
}

func (m *IPSetDeltaUpdate) Size() (n int) {
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	if len(m.AddedMembers) > 0 {
		for _, s := range m.AddedMembers {
			l = len(s)
			n += 1 + l + sovFelixbackend(uint64(l))
		}
	}
	if len(m.RemovedMembers) > 0 {
		for _, s := range m.RemovedMembers {
			l = len(s)
			n += 1 + l + sovFelixbackend(uint64(l))
		}
	}
	return n
}

func (m *IPSetRemove) Size() (n int) {
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	return n
}

func (m *ActiveProfileUpdate) Size() (n int) {
	var l int
	_ = l
	if m.Id != nil {
		l = m.Id.Size()
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	if m.Profile != nil {
		l = m.Profile.Size()
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	return n
}

func (m *ActiveProfileRemove) Size() (n int) {
	var l int
	_ = l
	if m.Id != nil {
		l = m.Id.Size()
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	return n
}

func (m *ProfileID) Size() (n int) {
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	return n
}

func (m *Profile) Size() (n int) {
	var l int
	_ = l
	if len(m.InboundRules) > 0 {
		for _, e := range m.InboundRules {
			l = e.Size()
			n += 1 + l + sovFelixbackend(uint64(l))
		}
	}
	if len(m.OutboundRules) > 0 {
		for _, e := range m.OutboundRules {
			l = e.Size()
			n += 1 + l + sovFelixbackend(uint64(l))
		}
	}
	return n
}

func (m *ActivePolicyUpdate) Size() (n int) {
	var l int
	_ = l
	if m.Id != nil {
		l = m.Id.Size()
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	if m.Policy != nil {
		l = m.Policy.Size()
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	return n
}

func (m *ActivePolicyRemove) Size() (n int) {
	var l int
	_ = l
	if m.Id != nil {
		l = m.Id.Size()
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	return n
}

func (m *PolicyID) Size() (n int) {
	var l int
	_ = l
	l = len(m.Tier)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	return n
}

func (m *Policy) Size() (n int) {
	var l int
	_ = l
	if len(m.InboundRules) > 0 {
		for _, e := range m.InboundRules {
			l = e.Size()
			n += 1 + l + sovFelixbackend(uint64(l))
		}
	}
	if len(m.OutboundRules) > 0 {
		for _, e := range m.OutboundRules {
			l = e.Size()
			n += 1 + l + sovFelixbackend(uint64(l))
		}
	}
	if m.Untracked {
		n += 2
	}
	if m.PreDnat {
		n += 2
	}
	l = len(m.Namespace)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	l = len(m.OriginalSelector)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	return n
}

func (m *Rule) Size() (n int) {
	var l int
	_ = l
	l = len(m.Action)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	if m.IpVersion != 0 {
		n += 1 + sovFelixbackend(uint64(m.IpVersion))
	}
	if m.Protocol != nil {
		l = m.Protocol.Size()
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	if len(m.SrcNet) > 0 {
		for _, s := range m.SrcNet {
			l = len(s)
			n += 1 + l + sovFelixbackend(uint64(l))
		}
	}
	if len(m.SrcPorts) > 0 {
		for _, e := range m.SrcPorts {
			l = e.Size()
			n += 1 + l + sovFelixbackend(uint64(l))
		}
	}
	if len(m.DstNet) > 0 {
		for _, s := range m.DstNet {
			l = len(s)
			n += 1 + l + sovFelixbackend(uint64(l))
		}
	}
	if len(m.DstPorts) > 0 {
		for _, e := range m.DstPorts {
			l = e.Size()
			n += 1 + l + sovFelixbackend(uint64(l))
		}
	}
	if m.Icmp != nil {
		n += m.Icmp.Size()
	}
	if len(m.SrcIpSetIds) > 0 {
		for _, s := range m.SrcIpSetIds {
			l = len(s)
			n += 1 + l + sovFelixbackend(uint64(l))
		}
	}
	if len(m.DstIpSetIds) > 0 {
		for _, s := range m.DstIpSetIds {
			l = len(s)
			n += 1 + l + sovFelixbackend(uint64(l))
		}
	}
	if len(m.SrcNamedPortIpSetIds) > 0 {
		for _, s := range m.SrcNamedPortIpSetIds {
			l = len(s)
			n += 1 + l + sovFelixbackend(uint64(l))
		}
	}
	if len(m.DstNamedPortIpSetIds) > 0 {
		for _, s := range m.DstNamedPortIpSetIds {
			l = len(s)
			n += 1 + l + sovFelixbackend(uint64(l))
		}
	}
	if len(m.DstIpPortSetIds) > 0 {
		for _, s := range m.DstIpPortSetIds {
			l = len(s)
			n += 1 + l + sovFelixbackend(uint64(l))
		}
	}
	if m.NotProtocol != nil {
		l = m.NotProtocol.Size()
		n += 2 + l + sovFelixbackend(uint64(l))
	}
	if len(m.NotSrcNet) > 0 {
		for _, s := range m.NotSrcNet {
			l = len(s)
			n += 2 + l + sovFelixbackend(uint64(l))
		}
	}
	if len(m.NotSrcPorts) > 0 {
		for _, e := range m.NotSrcPorts {
			l = e.Size()
			n += 2 + l + sovFelixbackend(uint64(l))
		}
	}
	if len(m.NotDstNet) > 0 {
		for _, s := range m.NotDstNet {
			l = len(s)
			n += 2 + l + sovFelixbackend(uint64(l))
		}
	}
	if len(m.NotDstPorts) > 0 {
		for _, e := range m.NotDstPorts {
			l = e.Size()
			n += 2 + l + sovFelixbackend(uint64(l))
		}
	}
	if m.NotIcmp != nil {
		n += m.NotIcmp.Size()
	}
	if len(m.NotSrcIpSetIds) > 0 {
		for _, s := range m.NotSrcIpSetIds {
			l = len(s)
			n += 2 + l + sovFelixbackend(uint64(l))
		}
	}
	if len(m.NotDstIpSetIds) > 0 {
		for _, s := range m.NotDstIpSetIds {
			l = len(s)
			n += 2 + l + sovFelixbackend(uint64(l))
		}
	}
	if len(m.NotSrcNamedPortIpSetIds) > 0 {
		for _, s := range m.NotSrcNamedPortIpSetIds {
			l = len(s)
			n += 2 + l + sovFelixbackend(uint64(l))
		}
	}
	if len(m.NotDstNamedPortIpSetIds) > 0 {
		for _, s := range m.NotDstNamedPortIpSetIds {
			l = len(s)
			n += 2 + l + sovFelixbackend(uint64(l))
		}
	}
	l = len(m.OriginalSrcSelector)
	if l > 0 {
		n += 2 + l + sovFelixbackend(uint64(l))
	}
	l = len(m.OriginalDstSelector)
	if l > 0 {
		n += 2 + l + sovFelixbackend(uint64(l))
	}
	l = len(m.OriginalSrcNamespaceSelector)
	if l > 0 {
		n += 2 + l + sovFelixbackend(uint64(l))
	}
	l = len(m.OriginalDstNamespaceSelector)
	if l > 0 {
		n += 2 + l + sovFelixbackend(uint64(l))
	}
	l = len(m.OriginalNotSrcSelector)
	if l > 0 {
		n += 2 + l + sovFelixbackend(uint64(l))
	}
	l = len(m.OriginalNotDstSelector)
	if l > 0 {
		n += 2 + l + sovFelixbackend(uint64(l))
	}
	if m.SrcServiceAccountMatch != nil {
		l = m.SrcServiceAccountMatch.Size()
		n += 2 + l + sovFelixbackend(uint64(l))
	}
	if m.DstServiceAccountMatch != nil {
		l = m.DstServiceAccountMatch.Size()
		n += 2 + l + sovFelixbackend(uint64(l))
	}
	if m.HttpMatch != nil {
		l = m.HttpMatch.Size()
		n += 2 + l + sovFelixbackend(uint64(l))
	}
	if m.Metadata != nil {
		l = m.Metadata.Size()
		n += 2 + l + sovFelixbackend(uint64(l))
	}
	l = len(m.OriginalDstService)
	if l > 0 {
		n += 2 + l + sovFelixbackend(uint64(l))
	}
	l = len(m.OriginalDstServiceNamespace)
	if l > 0 {
		n += 2 + l + sovFelixbackend(uint64(l))
	}
	l = len(m.OriginalSrcService)
	if l > 0 {
		n += 2 + l + sovFelixbackend(uint64(l))
	}
	l = len(m.OriginalSrcServiceNamespace)
	if l > 0 {
		n += 2 + l + sovFelixbackend(uint64(l))
	}
	l = len(m.RuleId)
	if l > 0 {
		n += 2 + l + sovFelixbackend(uint64(l))
	}
	return n
}

func (m *Rule_IcmpType) Size() (n int) {
	var l int
	_ = l
	n += 1 + sovFelixbackend(uint64(m.IcmpType))
	return n
}
func (m *Rule_IcmpTypeCode) Size() (n int) {
	var l int
	_ = l
	if m.IcmpTypeCode != nil {
		l = m.IcmpTypeCode.Size()
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	return n
}
func (m *Rule_NotIcmpType) Size() (n int) {
	var l int
	_ = l
	n += 2 + sovFelixbackend(uint64(m.NotIcmpType))
	return n
}
func (m *Rule_NotIcmpTypeCode) Size() (n int) {
	var l int
	_ = l
	if m.NotIcmpTypeCode != nil {
		l = m.NotIcmpTypeCode.Size()
		n += 2 + l + sovFelixbackend(uint64(l))
	}
	return n
}
func (m *ServiceAccountMatch) Size() (n int) {
	var l int
	_ = l
	l = len(m.Selector)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	if len(m.Names) > 0 {
		for _, s := range m.Names {
			l = len(s)
			n += 1 + l + sovFelixbackend(uint64(l))
		}
	}
	return n
}

func (m *HTTPMatch) Size() (n int) {
	var l int
	_ = l
	if len(m.Methods) > 0 {
		for _, s := range m.Methods {
			l = len(s)
			n += 1 + l + sovFelixbackend(uint64(l))
		}
	}
	if len(m.Paths) > 0 {
		for _, e := range m.Paths {
			l = e.Size()
			n += 1 + l + sovFelixbackend(uint64(l))
		}
	}
	return n
}

func (m *HTTPMatch_PathMatch) Size() (n int) {
	var l int
	_ = l
	if m.PathMatch != nil {
		n += m.PathMatch.Size()
	}
	return n
}

func (m *HTTPMatch_PathMatch_Exact) Size() (n int) {
	var l int
	_ = l
	l = len(m.Exact)
	n += 1 + l + sovFelixbackend(uint64(l))
	return n
}
func (m *HTTPMatch_PathMatch_Prefix) Size() (n int) {
	var l int
	_ = l
	l = len(m.Prefix)
	n += 1 + l + sovFelixbackend(uint64(l))
	return n
}
func (m *RuleMetadata) Size() (n int) {
	var l int
	_ = l
	if len(m.Annotations) > 0 {
		for k, v := range m.Annotations {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovFelixbackend(uint64(len(k))) + 1 + len(v) + sovFelixbackend(uint64(len(v)))
			n += mapEntrySize + 1 + sovFelixbackend(uint64(mapEntrySize))
		}
	}
	return n
}

func (m *IcmpTypeAndCode) Size() (n int) {
	var l int
	_ = l
	if m.Type != 0 {
		n += 1 + sovFelixbackend(uint64(m.Type))
	}
	if m.Code != 0 {
		n += 1 + sovFelixbackend(uint64(m.Code))
	}
	return n
}

func (m *Protocol) Size() (n int) {
	var l int
	_ = l
	if m.NumberOrName != nil {
		n += m.NumberOrName.Size()
	}
	return n
}

func (m *Protocol_Number) Size() (n int) {
	var l int
	_ = l
	n += 1 + sovFelixbackend(uint64(m.Number))
	return n
}
func (m *Protocol_Name) Size() (n int) {
	var l int
	_ = l
	l = len(m.Name)
	n += 1 + l + sovFelixbackend(uint64(l))
	return n
}
func (m *PortRange) Size() (n int) {
	var l int
	_ = l
	if m.First != 0 {
		n += 1 + sovFelixbackend(uint64(m.First))
	}
	if m.Last != 0 {
		n += 1 + sovFelixbackend(uint64(m.Last))
	}
	return n
}

func (m *WorkloadEndpointID) Size() (n int) {
	var l int
	_ = l
	l = len(m.OrchestratorId)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	l = len(m.WorkloadId)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	l = len(m.EndpointId)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	return n
}

func (m *WorkloadEndpointUpdate) Size() (n int) {
	var l int
	_ = l
	if m.Id != nil {
		l = m.Id.Size()
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	if m.Endpoint != nil {
		l = m.Endpoint.Size()
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	return n
}

func (m *WorkloadEndpoint) Size() (n int) {
	var l int
	_ = l
	l = len(m.State)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	l = len(m.Mac)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	if len(m.ProfileIds) > 0 {
		for _, s := range m.ProfileIds {
			l = len(s)
			n += 1 + l + sovFelixbackend(uint64(l))
		}
	}
	if len(m.Ipv4Nets) > 0 {
		for _, s := range m.Ipv4Nets {
			l = len(s)
			n += 1 + l + sovFelixbackend(uint64(l))
		}
	}
	if len(m.Ipv6Nets) > 0 {
		for _, s := range m.Ipv6Nets {
			l = len(s)
			n += 1 + l + sovFelixbackend(uint64(l))
		}
	}
	if len(m.Tiers) > 0 {
		for _, e := range m.Tiers {
			l = e.Size()
			n += 1 + l + sovFelixbackend(uint64(l))
		}
	}
	if len(m.Ipv4Nat) > 0 {
		for _, e := range m.Ipv4Nat {
			l = e.Size()
			n += 1 + l + sovFelixbackend(uint64(l))
		}
	}
	if len(m.Ipv6Nat) > 0 {
		for _, e := range m.Ipv6Nat {
			l = e.Size()
			n += 1 + l + sovFelixbackend(uint64(l))
		}
	}
	if len(m.AllowSpoofedSourcePrefixes) > 0 {
		for _, s := range m.AllowSpoofedSourcePrefixes {
			l = len(s)
			n += 1 + l + sovFelixbackend(uint64(l))
		}
	}
	if len(m.Annotations) > 0 {
		for k, v := range m.Annotations {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovFelixbackend(uint64(len(k))) + 1 + len(v) + sovFelixbackend(uint64(len(v)))
			n += mapEntrySize + 1 + sovFelixbackend(uint64(mapEntrySize))
		}
	}
	return n
}

func (m *WorkloadEndpointRemove) Size() (n int) {
	var l int
	_ = l
	if m.Id != nil {
		l = m.Id.Size()
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	return n
}

func (m *HostEndpointID) Size() (n int) {
	var l int
	_ = l
	l = len(m.EndpointId)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	return n
}

func (m *HostEndpointUpdate) Size() (n int) {
	var l int
	_ = l
	if m.Id != nil {
		l = m.Id.Size()
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	if m.Endpoint != nil {
		l = m.Endpoint.Size()
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	return n
}

func (m *HostEndpoint) Size() (n int) {
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	if len(m.ProfileIds) > 0 {
		for _, s := range m.ProfileIds {
			l = len(s)
			n += 1 + l + sovFelixbackend(uint64(l))
		}
	}
	if len(m.Tiers) > 0 {
		for _, e := range m.Tiers {
			l = e.Size()
			n += 1 + l + sovFelixbackend(uint64(l))
		}
	}
	if len(m.ExpectedIpv4Addrs) > 0 {
		for _, s := range m.ExpectedIpv4Addrs {
			l = len(s)
			n += 1 + l + sovFelixbackend(uint64(l))
		}
	}
	if len(m.ExpectedIpv6Addrs) > 0 {
		for _, s := range m.ExpectedIpv6Addrs {
			l = len(s)
			n += 1 + l + sovFelixbackend(uint64(l))
		}
	}
	if len(m.UntrackedTiers) > 0 {
		for _, e := range m.UntrackedTiers {
			l = e.Size()
			n += 1 + l + sovFelixbackend(uint64(l))
		}
	}
	if len(m.PreDnatTiers) > 0 {
		for _, e := range m.PreDnatTiers {
			l = e.Size()
			n += 1 + l + sovFelixbackend(uint64(l))
		}
	}
	if len(m.ForwardTiers) > 0 {
		for _, e := range m.ForwardTiers {
			l = e.Size()
			n += 1 + l + sovFelixbackend(uint64(l))
		}
	}
	return n
}

func (m *HostEndpointRemove) Size() (n int) {
	var l int
	_ = l
	if m.Id != nil {
		l = m.Id.Size()
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	return n
}

func (m *TierInfo) Size() (n int) {
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	if len(m.IngressPolicies) > 0 {
		for _, s := range m.IngressPolicies {
			l = len(s)
			n += 1 + l + sovFelixbackend(uint64(l))
		}
	}
	if len(m.EgressPolicies) > 0 {
		for _, s := range m.EgressPolicies {
			l = len(s)
			n += 1 + l + sovFelixbackend(uint64(l))
		}
	}
	l = len(m.DefaultAction)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	return n
}

func (m *NatInfo) Size() (n int) {
	var l int
	_ = l
	l = len(m.ExtIp)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	l = len(m.IntIp)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	return n
}

func (m *ProcessStatusUpdate) Size() (n int) {
	var l int
	_ = l
	l = len(m.IsoTimestamp)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	if m.Uptime != 0 {
		n += 9
	}
	return n
}

func (m *HostEndpointStatusUpdate) Size() (n int) {
	var l int
	_ = l
	if m.Id != nil {
		l = m.Id.Size()
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	if m.Status != nil {
		l = m.Status.Size()
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	return n
}

func (m *EndpointStatus) Size() (n int) {
	var l int
	_ = l
	l = len(m.Status)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	return n
}

func (m *HostEndpointStatusRemove) Size() (n int) {
	var l int
	_ = l
	if m.Id != nil {
		l = m.Id.Size()
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	return n
}

func (m *WorkloadEndpointStatusUpdate) Size() (n int) {
	var l int
	_ = l
	if m.Id != nil {
		l = m.Id.Size()
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	if m.Status != nil {
		l = m.Status.Size()
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	return n
}

func (m *WorkloadEndpointStatusRemove) Size() (n int) {
	var l int
	_ = l
	if m.Id != nil {
		l = m.Id.Size()
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	return n
}

func (m *WireguardStatusUpdate) Size() (n int) {
	var l int
	_ = l
	l = len(m.PublicKey)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	if m.IpVersion != 0 {
		n += 1 + sovFelixbackend(uint64(m.IpVersion))
	}
	return n
}

func (m *DataplaneInSync) Size() (n int) {
	var l int
	_ = l
	return n
}

func (m *HostMetadataV4V6Update) Size() (n int) {
	var l int
	_ = l
	l = len(m.Hostname)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	l = len(m.Ipv4Addr)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	l = len(m.Ipv6Addr)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	l = len(m.Asnumber)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	if len(m.Labels) > 0 {
		for k, v := range m.Labels {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovFelixbackend(uint64(len(k))) + 1 + len(v) + sovFelixbackend(uint64(len(v)))
			n += mapEntrySize + 1 + sovFelixbackend(uint64(mapEntrySize))
		}
	}
	return n
}

func (m *HostMetadataV4V6Remove) Size() (n int) {
	var l int
	_ = l
	l = len(m.Hostname)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	l = len(m.Ipv4Addr)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	return n
}

func (m *HostMetadataUpdate) Size() (n int) {
	var l int
	_ = l
	l = len(m.Hostname)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	l = len(m.Ipv4Addr)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	return n
}

func (m *HostMetadataRemove) Size() (n int) {
	var l int
	_ = l
	l = len(m.Hostname)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	l = len(m.Ipv4Addr)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	return n
}

func (m *HostMetadataV6Update) Size() (n int) {
	var l int
	_ = l
	l = len(m.Hostname)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	l = len(m.Ipv6Addr)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	return n
}

func (m *HostMetadataV6Remove) Size() (n int) {
	var l int
	_ = l
	l = len(m.Hostname)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	l = len(m.Ipv6Addr)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	return n
}

func (m *IPAMPoolUpdate) Size() (n int) {
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	if m.Pool != nil {
		l = m.Pool.Size()
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	return n
}

func (m *IPAMPoolRemove) Size() (n int) {
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	return n
}

func (m *IPAMPool) Size() (n int) {
	var l int
	_ = l
	l = len(m.Cidr)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	if m.Masquerade {
		n += 2
	}
	l = len(m.IpipMode)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	l = len(m.VxlanMode)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	return n
}

func (m *Encapsulation) Size() (n int) {
	var l int
	_ = l
	if m.IpipEnabled {
		n += 2
	}
	if m.VxlanEnabled {
		n += 2
	}
	if m.VxlanEnabledV6 {
		n += 2
	}
	return n
}

func (m *ServiceAccountUpdate) Size() (n int) {
	var l int
	_ = l
	if m.Id != nil {
		l = m.Id.Size()
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	if len(m.Labels) > 0 {
		for k, v := range m.Labels {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovFelixbackend(uint64(len(k))) + 1 + len(v) + sovFelixbackend(uint64(len(v)))
			n += mapEntrySize + 1 + sovFelixbackend(uint64(mapEntrySize))
		}
	}
	return n
}

func (m *ServiceAccountRemove) Size() (n int) {
	var l int
	_ = l
	if m.Id != nil {
		l = m.Id.Size()
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	return n
}

func (m *ServiceAccountID) Size() (n int) {
	var l int
	_ = l
	l = len(m.Namespace)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	return n
}

func (m *NamespaceUpdate) Size() (n int) {
	var l int
	_ = l
	if m.Id != nil {
		l = m.Id.Size()
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	if len(m.Labels) > 0 {
		for k, v := range m.Labels {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovFelixbackend(uint64(len(k))) + 1 + len(v) + sovFelixbackend(uint64(len(v)))
			n += mapEntrySize + 1 + sovFelixbackend(uint64(mapEntrySize))
		}
	}
	return n
}

func (m *NamespaceRemove) Size() (n int) {
	var l int
	_ = l
	if m.Id != nil {
		l = m.Id.Size()
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	return n
}

func (m *NamespaceID) Size() (n int) {
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	return n
}

func (m *TunnelType) Size() (n int) {
	var l int
	_ = l
	if m.Ipip {
		n += 2
	}
	if m.Vxlan {
		n += 2
	}
	if m.Wireguard {
		n += 2
	}
	return n
}

func (m *RouteUpdate) Size() (n int) {
	var l int
	_ = l
	if m.Type != 0 {
		n += 1 + sovFelixbackend(uint64(m.Type))
	}
	if m.IpPoolType != 0 {
		n += 1 + sovFelixbackend(uint64(m.IpPoolType))
	}
	l = len(m.Dst)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	l = len(m.DstNodeName)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	l = len(m.DstNodeIp)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	if m.SameSubnet {
		n += 2
	}
	if m.NatOutgoing {
		n += 2
	}
	if m.LocalWorkload {
		n += 2
	}
	if m.TunnelType != nil {
		l = m.TunnelType.Size()
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	if m.Borrowed {
		n += 2
	}
	return n
}

func (m *RouteRemove) Size() (n int) {
	var l int
	_ = l
	l = len(m.Dst)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	return n
}

func (m *VXLANTunnelEndpointUpdate) Size() (n int) {
	var l int
	_ = l
	l = len(m.Node)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	l = len(m.Mac)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	l = len(m.Ipv4Addr)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	l = len(m.ParentDeviceIp)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	l = len(m.MacV6)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	l = len(m.Ipv6Addr)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	l = len(m.ParentDeviceIpv6)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	return n
}

func (m *VXLANTunnelEndpointRemove) Size() (n int) {
	var l int
	_ = l
	l = len(m.Node)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	return n
}

func (m *WireguardEndpointUpdate) Size() (n int) {
	var l int
	_ = l
	l = len(m.Hostname)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	l = len(m.PublicKey)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	l = len(m.InterfaceIpv4Addr)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	return n
}

func (m *WireguardEndpointRemove) Size() (n int) {
	var l int
	_ = l
	l = len(m.Hostname)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	return n
}

func (m *WireguardEndpointV6Update) Size() (n int) {
	var l int
	_ = l
	l = len(m.Hostname)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	l = len(m.PublicKeyV6)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	l = len(m.InterfaceIpv6Addr)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	return n
}

func (m *WireguardEndpointV6Remove) Size() (n int) {
	var l int
	_ = l
	l = len(m.Hostname)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	return n
}

func (m *GlobalBGPConfigUpdate) Size() (n int) {
	var l int
	_ = l
	if len(m.ServiceClusterCidrs) > 0 {
		for _, s := range m.ServiceClusterCidrs {
			l = len(s)
			n += 1 + l + sovFelixbackend(uint64(l))
		}
	}
	if len(m.ServiceExternalCidrs) > 0 {
		for _, s := range m.ServiceExternalCidrs {
			l = len(s)
			n += 1 + l + sovFelixbackend(uint64(l))
		}
	}
	if len(m.ServiceLoadbalancerCidrs) > 0 {
		for _, s := range m.ServiceLoadbalancerCidrs {
			l = len(s)
			n += 1 + l + sovFelixbackend(uint64(l))
		}
	}
	return n
}

func (m *ServicePort) Size() (n int) {
	var l int
	_ = l
	l = len(m.Protocol)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	if m.Port != 0 {
		n += 1 + sovFelixbackend(uint64(m.Port))
	}
	if m.NodePort != 0 {
		n += 1 + sovFelixbackend(uint64(m.NodePort))
	}
	return n
}

func (m *ServiceUpdate) Size() (n int) {
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	l = len(m.Namespace)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	l = len(m.Type)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	if len(m.ClusterIps) > 0 {
		for _, s := range m.ClusterIps {
			l = len(s)
			n += 1 + l + sovFelixbackend(uint64(l))
		}
	}
	l = len(m.LoadbalancerIp)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	if len(m.ExternalIps) > 0 {
		for _, s := range m.ExternalIps {
			l = len(s)
			n += 1 + l + sovFelixbackend(uint64(l))
		}
	}
	if len(m.Ports) > 0 {
		for _, e := range m.Ports {
			l = e.Size()
			n += 1 + l + sovFelixbackend(uint64(l))
		}
	}
	return n
}

func (m *ServiceRemove) Size() (n int) {
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	l = len(m.Namespace)
	if l > 0 {
		n += 1 + l + sovFelixbackend(uint64(l))
	}
	return n
}

func sovFelixbackend(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozFelixbackend(x uint64) (n int) {
	return sovFelixbackend(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *SyncRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFelixbackend
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: SyncRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SyncRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipFelixbackend(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFelixbackend
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ToDataplane) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFelixbackend
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ToDataplane: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ToDataplane: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InSync", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &InSync{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Payload = &ToDataplane_InSync{v}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IpsetUpdate", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &IPSetUpdate{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Payload = &ToDataplane_IpsetUpdate{v}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IpsetDeltaUpdate", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &IPSetDeltaUpdate{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Payload = &ToDataplane_IpsetDeltaUpdate{v}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IpsetRemove", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &IPSetRemove{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Payload = &ToDataplane_IpsetRemove{v}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ActiveProfileUpdate", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ActiveProfileUpdate{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Payload = &ToDataplane_ActiveProfileUpdate{v}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ActiveProfileRemove", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ActiveProfileRemove{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Payload = &ToDataplane_ActiveProfileRemove{v}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ActivePolicyUpdate", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ActivePolicyUpdate{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Payload = &ToDataplane_ActivePolicyUpdate{v}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ActivePolicyRemove", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ActivePolicyRemove{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Payload = &ToDataplane_ActivePolicyRemove{v}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HostEndpointUpdate", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &HostEndpointUpdate{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Payload = &ToDataplane_HostEndpointUpdate{v}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HostEndpointRemove", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &HostEndpointRemove{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Payload = &ToDataplane_HostEndpointRemove{v}
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field WorkloadEndpointUpdate", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &WorkloadEndpointUpdate{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Payload = &ToDataplane_WorkloadEndpointUpdate{v}
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field WorkloadEndpointRemove", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &WorkloadEndpointRemove{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Payload = &ToDataplane_WorkloadEndpointRemove{v}
			iNdEx = postIndex
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ConfigUpdate", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ConfigUpdate{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Payload = &ToDataplane_ConfigUpdate{v}
			iNdEx = postIndex
		case 14:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HostMetadataUpdate", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &HostMetadataUpdate{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Payload = &ToDataplane_HostMetadataUpdate{v}
			iNdEx = postIndex
		case 15:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SequenceNumber", wireType)
			}
			m.SequenceNumber = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SequenceNumber |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 16:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IpamPoolUpdate", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &IPAMPoolUpdate{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Payload = &ToDataplane_IpamPoolUpdate{v}
			iNdEx = postIndex
		case 17:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IpamPoolRemove", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &IPAMPoolRemove{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Payload = &ToDataplane_IpamPoolRemove{v}
			iNdEx = postIndex
		case 18:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HostMetadataRemove", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &HostMetadataRemove{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Payload = &ToDataplane_HostMetadataRemove{v}
			iNdEx = postIndex
		case 19:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ServiceAccountUpdate", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ServiceAccountUpdate{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Payload = &ToDataplane_ServiceAccountUpdate{v}
			iNdEx = postIndex
		case 20:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ServiceAccountRemove", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ServiceAccountRemove{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Payload = &ToDataplane_ServiceAccountRemove{v}
			iNdEx = postIndex
		case 21:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NamespaceUpdate", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &NamespaceUpdate{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Payload = &ToDataplane_NamespaceUpdate{v}
			iNdEx = postIndex
		case 22:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NamespaceRemove", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &NamespaceRemove{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Payload = &ToDataplane_NamespaceRemove{v}
			iNdEx = postIndex
		case 23:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RouteUpdate", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &RouteUpdate{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Payload = &ToDataplane_RouteUpdate{v}
			iNdEx = postIndex
		case 24:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RouteRemove", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &RouteRemove{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Payload = &ToDataplane_RouteRemove{v}
			iNdEx = postIndex
		case 25:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field VtepUpdate", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &VXLANTunnelEndpointUpdate{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Payload = &ToDataplane_VtepUpdate{v}
			iNdEx = postIndex
		case 26:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field VtepRemove", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &VXLANTunnelEndpointRemove{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Payload = &ToDataplane_VtepRemove{v}
			iNdEx = postIndex
		case 27:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field WireguardEndpointUpdate", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &WireguardEndpointUpdate{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Payload = &ToDataplane_WireguardEndpointUpdate{v}
			iNdEx = postIndex
		case 28:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field WireguardEndpointRemove", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &WireguardEndpointRemove{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Payload = &ToDataplane_WireguardEndpointRemove{v}
			iNdEx = postIndex
		case 29:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GlobalBgpConfigUpdate", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &GlobalBGPConfigUpdate{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Payload = &ToDataplane_GlobalBgpConfigUpdate{v}
			iNdEx = postIndex
		case 30:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Encapsulation", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &Encapsulation{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Payload = &ToDataplane_Encapsulation{v}
			iNdEx = postIndex
		case 31:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ServiceUpdate", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ServiceUpdate{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Payload = &ToDataplane_ServiceUpdate{v}
			iNdEx = postIndex
		case 32:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ServiceRemove", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ServiceRemove{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Payload = &ToDataplane_ServiceRemove{v}
			iNdEx = postIndex
		case 33:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field WireguardEndpointV6Update", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &WireguardEndpointV6Update{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Payload = &ToDataplane_WireguardEndpointV6Update{v}
			iNdEx = postIndex
		case 34:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field WireguardEndpointV6Remove", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &WireguardEndpointV6Remove{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Payload = &ToDataplane_WireguardEndpointV6Remove{v}
			iNdEx = postIndex
		case 35:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HostMetadataV6Update", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &HostMetadataV6Update{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Payload = &ToDataplane_HostMetadataV6Update{v}
			iNdEx = postIndex
		case 36:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HostMetadataV6Remove", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &HostMetadataV6Remove{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Payload = &ToDataplane_HostMetadataV6Remove{v}
			iNdEx = postIndex
		case 37:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HostMetadataV4V6Update", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &HostMetadataV4V6Update{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Payload = &ToDataplane_HostMetadataV4V6Update{v}
			iNdEx = postIndex
		case 38:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HostMetadataV4V6Remove", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &HostMetadataV4V6Remove{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Payload = &ToDataplane_HostMetadataV4V6Remove{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFelixbackend(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFelixbackend
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *FromDataplane) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFelixbackend
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: FromDataplane: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FromDataplane: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProcessStatusUpdate", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ProcessStatusUpdate{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Payload = &FromDataplane_ProcessStatusUpdate{v}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HostEndpointStatusUpdate", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &HostEndpointStatusUpdate{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Payload = &FromDataplane_HostEndpointStatusUpdate{v}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HostEndpointStatusRemove", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &HostEndpointStatusRemove{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Payload = &FromDataplane_HostEndpointStatusRemove{v}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field WorkloadEndpointStatusUpdate", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &WorkloadEndpointStatusUpdate{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Payload = &FromDataplane_WorkloadEndpointStatusUpdate{v}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field WorkloadEndpointStatusRemove", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &WorkloadEndpointStatusRemove{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Payload = &FromDataplane_WorkloadEndpointStatusRemove{v}
			iNdEx = postIndex
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SequenceNumber", wireType)
			}
			m.SequenceNumber = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SequenceNumber |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field WireguardStatusUpdate", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &WireguardStatusUpdate{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Payload = &FromDataplane_WireguardStatusUpdate{v}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DataplaneInSync", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &DataplaneInSync{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Payload = &FromDataplane_DataplaneInSync{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFelixbackend(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFelixbackend
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ConfigUpdate) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFelixbackend
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ConfigUpdate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ConfigUpdate: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Config", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Config == nil {
				m.Config = make(map[string]string)
			}
			var mapkey string
			var mapvalue string
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowFelixbackend
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowFelixbackend
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= (uint64(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthFelixbackend
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var stringLenmapvalue uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowFelixbackend
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapvalue |= (uint64(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapvalue := int(stringLenmapvalue)
					if intStringLenmapvalue < 0 {
						return ErrInvalidLengthFelixbackend
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipFelixbackend(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthFelixbackend
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Config[mapkey] = mapvalue
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SourceToRawConfig", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.SourceToRawConfig == nil {
				m.SourceToRawConfig = make(map[uint32]*RawConfig)
			}
			var mapkey uint32
			var mapvalue *RawConfig
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowFelixbackend
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowFelixbackend
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= (uint32(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowFelixbackend
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= (int(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthFelixbackend
					}
					postmsgIndex := iNdEx + mapmsglen
					if mapmsglen < 0 {
						return ErrInvalidLengthFelixbackend
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &RawConfig{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipFelixbackend(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthFelixbackend
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.SourceToRawConfig[mapkey] = mapvalue
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Message = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFelixbackend(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFelixbackend
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RawConfig) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFelixbackend
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RawConfig: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RawConfig: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Source", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Source = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Config", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Config == nil {
				m.Config = make(map[string]string)
			}
			var mapkey string
			var mapvalue string
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowFelixbackend
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowFelixbackend
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= (uint64(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthFelixbackend
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var stringLenmapvalue uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowFelixbackend
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapvalue |= (uint64(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapvalue := int(stringLenmapvalue)
					if intStringLenmapvalue < 0 {
						return ErrInvalidLengthFelixbackend
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipFelixbackend(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthFelixbackend
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Config[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFelixbackend(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFelixbackend
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *InSync) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFelixbackend
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: InSync: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: InSync: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipFelixbackend(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFelixbackend
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *IPSetUpdate) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFelixbackend
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: IPSetUpdate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: IPSetUpdate: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Id = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Members", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Members = append(m.Members, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= (IPSetUpdate_IPSetType(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipFelixbackend(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFelixbackend
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *IPSetDeltaUpdate) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFelixbackend
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: IPSetDeltaUpdate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: IPSetDeltaUpdate: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Id = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AddedMembers", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AddedMembers = append(m.AddedMembers, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RemovedMembers", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RemovedMembers = append(m.RemovedMembers, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFelixbackend(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFelixbackend
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *IPSetRemove) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFelixbackend
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: IPSetRemove: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: IPSetRemove: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Id = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFelixbackend(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFelixbackend
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ActiveProfileUpdate) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFelixbackend
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ActiveProfileUpdate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ActiveProfileUpdate: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Id == nil {
				m.Id = &ProfileID{}
			}
			if err := m.Id.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Profile", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Profile == nil {
				m.Profile = &Profile{}
			}
			if err := m.Profile.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFelixbackend(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFelixbackend
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ActiveProfileRemove) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFelixbackend
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ActiveProfileRemove: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ActiveProfileRemove: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Id == nil {
				m.Id = &ProfileID{}
			}
			if err := m.Id.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFelixbackend(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFelixbackend
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ProfileID) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFelixbackend
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ProfileID: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ProfileID: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFelixbackend(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFelixbackend
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Profile) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFelixbackend
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Profile: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Profile: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InboundRules", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.InboundRules = append(m.InboundRules, &Rule{})
			if err := m.InboundRules[len(m.InboundRules)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OutboundRules", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OutboundRules = append(m.OutboundRules, &Rule{})
			if err := m.OutboundRules[len(m.OutboundRules)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFelixbackend(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFelixbackend
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ActivePolicyUpdate) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFelixbackend
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ActivePolicyUpdate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ActivePolicyUpdate: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Id == nil {
				m.Id = &PolicyID{}
			}
			if err := m.Id.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Policy", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Policy == nil {
				m.Policy = &Policy{}
			}
			if err := m.Policy.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFelixbackend(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFelixbackend
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ActivePolicyRemove) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFelixbackend
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ActivePolicyRemove: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ActivePolicyRemove: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Id == nil {
				m.Id = &PolicyID{}
			}
			if err := m.Id.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFelixbackend(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFelixbackend
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PolicyID) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFelixbackend
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: PolicyID: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PolicyID: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Tier", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Tier = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFelixbackend(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFelixbackend
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Policy) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFelixbackend
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Policy: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Policy: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InboundRules", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.InboundRules = append(m.InboundRules, &Rule{})
			if err := m.InboundRules[len(m.InboundRules)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OutboundRules", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OutboundRules = append(m.OutboundRules, &Rule{})
			if err := m.OutboundRules[len(m.OutboundRules)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Untracked", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Untracked = bool(v != 0)
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PreDnat", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.PreDnat = bool(v != 0)
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Namespace = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OriginalSelector", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OriginalSelector = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFelixbackend(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFelixbackend
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Rule) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFelixbackend
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Rule: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Rule: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Action", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Action = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IpVersion", wireType)
			}
			m.IpVersion = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.IpVersion |= (IPVersion(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Protocol", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Protocol == nil {
				m.Protocol = &Protocol{}
			}
			if err := m.Protocol.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SrcNet", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SrcNet = append(m.SrcNet, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SrcPorts", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SrcPorts = append(m.SrcPorts, &PortRange{})
			if err := m.SrcPorts[len(m.SrcPorts)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DstNet", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DstNet = append(m.DstNet, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DstPorts", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DstPorts = append(m.DstPorts, &PortRange{})
			if err := m.DstPorts[len(m.DstPorts)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IcmpType", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Icmp = &Rule_IcmpType{v}
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IcmpTypeCode", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &IcmpTypeAndCode{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Icmp = &Rule_IcmpTypeCode{v}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SrcIpSetIds", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SrcIpSetIds = append(m.SrcIpSetIds, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DstIpSetIds", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DstIpSetIds = append(m.DstIpSetIds, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SrcNamedPortIpSetIds", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SrcNamedPortIpSetIds = append(m.SrcNamedPortIpSetIds, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DstNamedPortIpSetIds", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DstNamedPortIpSetIds = append(m.DstNamedPortIpSetIds, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 15:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DstIpPortSetIds", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DstIpPortSetIds = append(m.DstIpPortSetIds, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 102:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NotProtocol", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NotProtocol == nil {
				m.NotProtocol = &Protocol{}
			}
			if err := m.NotProtocol.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 103:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NotSrcNet", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NotSrcNet = append(m.NotSrcNet, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 104:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NotSrcPorts", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NotSrcPorts = append(m.NotSrcPorts, &PortRange{})
			if err := m.NotSrcPorts[len(m.NotSrcPorts)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 105:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NotDstNet", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NotDstNet = append(m.NotDstNet, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 106:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NotDstPorts", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NotDstPorts = append(m.NotDstPorts, &PortRange{})
			if err := m.NotDstPorts[len(m.NotDstPorts)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 107:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NotIcmpType", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.NotIcmp = &Rule_NotIcmpType{v}
		case 108:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NotIcmpTypeCode", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &IcmpTypeAndCode{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.NotIcmp = &Rule_NotIcmpTypeCode{v}
			iNdEx = postIndex
		case 109:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NotSrcIpSetIds", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NotSrcIpSetIds = append(m.NotSrcIpSetIds, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 110:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NotDstIpSetIds", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NotDstIpSetIds = append(m.NotDstIpSetIds, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 112:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NotSrcNamedPortIpSetIds", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NotSrcNamedPortIpSetIds = append(m.NotSrcNamedPortIpSetIds, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 113:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NotDstNamedPortIpSetIds", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NotDstNamedPortIpSetIds = append(m.NotDstNamedPortIpSetIds, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 114:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OriginalSrcSelector", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OriginalSrcSelector = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 115:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OriginalDstSelector", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OriginalDstSelector = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 116:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OriginalSrcNamespaceSelector", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OriginalSrcNamespaceSelector = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 117:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OriginalDstNamespaceSelector", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OriginalDstNamespaceSelector = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 118:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OriginalNotSrcSelector", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OriginalNotSrcSelector = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 119:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OriginalNotDstSelector", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OriginalNotDstSelector = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 120:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SrcServiceAccountMatch", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.SrcServiceAccountMatch == nil {
				m.SrcServiceAccountMatch = &ServiceAccountMatch{}
			}
			if err := m.SrcServiceAccountMatch.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 121:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DstServiceAccountMatch", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.DstServiceAccountMatch == nil {
				m.DstServiceAccountMatch = &ServiceAccountMatch{}
			}
			if err := m.DstServiceAccountMatch.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 122:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HttpMatch", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.HttpMatch == nil {
				m.HttpMatch = &HTTPMatch{}
			}
			if err := m.HttpMatch.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 123:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Metadata == nil {
				m.Metadata = &RuleMetadata{}
			}
			if err := m.Metadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 130:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OriginalDstService", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OriginalDstService = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 131:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OriginalDstServiceNamespace", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OriginalDstServiceNamespace = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 132:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OriginalSrcService", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OriginalSrcService = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 133:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OriginalSrcServiceNamespace", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OriginalSrcServiceNamespace = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 201:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RuleId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RuleId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFelixbackend(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFelixbackend
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ServiceAccountMatch) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFelixbackend
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ServiceAccountMatch: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ServiceAccountMatch: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Selector = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Names", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Names = append(m.Names, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFelixbackend(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFelixbackend
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *HTTPMatch) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFelixbackend
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: HTTPMatch: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: HTTPMatch: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Methods", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Methods = append(m.Methods, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Paths", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Paths = append(m.Paths, &HTTPMatch_PathMatch{})
			if err := m.Paths[len(m.Paths)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFelixbackend(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFelixbackend
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *HTTPMatch_PathMatch) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFelixbackend
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: PathMatch: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PathMatch: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Exact", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PathMatch = &HTTPMatch_PathMatch_Exact{string(dAtA[iNdEx:postIndex])}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Prefix", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PathMatch = &HTTPMatch_PathMatch_Prefix{string(dAtA[iNdEx:postIndex])}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFelixbackend(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFelixbackend
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RuleMetadata) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFelixbackend
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RuleMetadata: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RuleMetadata: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Annotations", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Annotations == nil {
				m.Annotations = make(map[string]string)
			}
			var mapkey string
			var mapvalue string
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowFelixbackend
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowFelixbackend
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= (uint64(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthFelixbackend
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var stringLenmapvalue uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowFelixbackend
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapvalue |= (uint64(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapvalue := int(stringLenmapvalue)
					if intStringLenmapvalue < 0 {
						return ErrInvalidLengthFelixbackend
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipFelixbackend(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthFelixbackend
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Annotations[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFelixbackend(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFelixbackend
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *IcmpTypeAndCode) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFelixbackend
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: IcmpTypeAndCode: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: IcmpTypeAndCode: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipFelixbackend(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFelixbackend
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Protocol) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFelixbackend
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Protocol: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Protocol: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Number", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.NumberOrName = &Protocol_Number{v}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NumberOrName = &Protocol_Name{string(dAtA[iNdEx:postIndex])}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFelixbackend(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFelixbackend
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PortRange) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFelixbackend
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: PortRange: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PortRange: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field First", wireType)
			}
			m.First = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.First |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Last", wireType)
			}
			m.Last = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Last |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipFelixbackend(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFelixbackend
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *WorkloadEndpointID) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFelixbackend
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: WorkloadEndpointID: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: WorkloadEndpointID: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OrchestratorId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OrchestratorId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field WorkloadId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.WorkloadId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EndpointId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.EndpointId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFelixbackend(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFelixbackend
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *WorkloadEndpointUpdate) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFelixbackend
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: WorkloadEndpointUpdate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: WorkloadEndpointUpdate: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Id == nil {
				m.Id = &WorkloadEndpointID{}
			}
			if err := m.Id.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Endpoint", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Endpoint == nil {
				m.Endpoint = &WorkloadEndpoint{}
			}
			if err := m.Endpoint.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFelixbackend(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFelixbackend
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *WorkloadEndpoint) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFelixbackend
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: WorkloadEndpoint: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: WorkloadEndpoint: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field State", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.State = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Mac", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Mac = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProfileIds", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ProfileIds = append(m.ProfileIds, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ipv4Nets", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Ipv4Nets = append(m.Ipv4Nets, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ipv6Nets", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Ipv6Nets = append(m.Ipv6Nets, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Tiers", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Tiers = append(m.Tiers, &TierInfo{})
			if err := m.Tiers[len(m.Tiers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ipv4Nat", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Ipv4Nat = append(m.Ipv4Nat, &NatInfo{})
			if err := m.Ipv4Nat[len(m.Ipv4Nat)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ipv6Nat", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Ipv6Nat = append(m.Ipv6Nat, &NatInfo{})
			if err := m.Ipv6Nat[len(m.Ipv6Nat)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AllowSpoofedSourcePrefixes", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AllowSpoofedSourcePrefixes = append(m.AllowSpoofedSourcePrefixes, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Annotations", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Annotations == nil {
				m.Annotations = make(map[string]string)
			}
			var mapkey string
			var mapvalue string
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowFelixbackend
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowFelixbackend
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= (uint64(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthFelixbackend
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var stringLenmapvalue uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowFelixbackend
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapvalue |= (uint64(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapvalue := int(stringLenmapvalue)
					if intStringLenmapvalue < 0 {
						return ErrInvalidLengthFelixbackend
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipFelixbackend(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthFelixbackend
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Annotations[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFelixbackend(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFelixbackend
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *WorkloadEndpointRemove) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFelixbackend
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: WorkloadEndpointRemove: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: WorkloadEndpointRemove: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Id == nil {
				m.Id = &WorkloadEndpointID{}
			}
			if err := m.Id.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFelixbackend(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFelixbackend
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *HostEndpointID) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFelixbackend
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: HostEndpointID: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: HostEndpointID: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EndpointId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.EndpointId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFelixbackend(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFelixbackend
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *HostEndpointUpdate) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFelixbackend
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: HostEndpointUpdate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: HostEndpointUpdate: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Id == nil {
				m.Id = &HostEndpointID{}
			}
			if err := m.Id.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Endpoint", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Endpoint == nil {
				m.Endpoint = &HostEndpoint{}
			}
			if err := m.Endpoint.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFelixbackend(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFelixbackend
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *HostEndpoint) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFelixbackend
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: HostEndpoint: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: HostEndpoint: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProfileIds", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ProfileIds = append(m.ProfileIds, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Tiers", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Tiers = append(m.Tiers, &TierInfo{})
			if err := m.Tiers[len(m.Tiers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExpectedIpv4Addrs", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ExpectedIpv4Addrs = append(m.ExpectedIpv4Addrs, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExpectedIpv6Addrs", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ExpectedIpv6Addrs = append(m.ExpectedIpv6Addrs, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UntrackedTiers", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.UntrackedTiers = append(m.UntrackedTiers, &TierInfo{})
			if err := m.UntrackedTiers[len(m.UntrackedTiers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PreDnatTiers", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PreDnatTiers = append(m.PreDnatTiers, &TierInfo{})
			if err := m.PreDnatTiers[len(m.PreDnatTiers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ForwardTiers", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ForwardTiers = append(m.ForwardTiers, &TierInfo{})
			if err := m.ForwardTiers[len(m.ForwardTiers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFelixbackend(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFelixbackend
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *HostEndpointRemove) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFelixbackend
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: HostEndpointRemove: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: HostEndpointRemove: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Id == nil {
				m.Id = &HostEndpointID{}
			}
			if err := m.Id.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFelixbackend(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFelixbackend
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TierInfo) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFelixbackend
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TierInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TierInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IngressPolicies", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.IngressPolicies = append(m.IngressPolicies, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EgressPolicies", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.EgressPolicies = append(m.EgressPolicies, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DefaultAction", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DefaultAction = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFelixbackend(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFelixbackend
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *NatInfo) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFelixbackend
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: NatInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: NatInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExtIp", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ExtIp = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IntIp", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.IntIp = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFelixbackend(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFelixbackend
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ProcessStatusUpdate) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFelixbackend
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ProcessStatusUpdate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ProcessStatusUpdate: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsoTimestamp", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.IsoTimestamp = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field Uptime", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.Uptime = float64(math.Float64frombits(v))
		default:
			iNdEx = preIndex
			skippy, err := skipFelixbackend(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFelixbackend
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *HostEndpointStatusUpdate) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFelixbackend
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: HostEndpointStatusUpdate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: HostEndpointStatusUpdate: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Id == nil {
				m.Id = &HostEndpointID{}
			}
			if err := m.Id.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Status == nil {
				m.Status = &EndpointStatus{}
			}
			if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFelixbackend(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFelixbackend
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EndpointStatus) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFelixbackend
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: EndpointStatus: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EndpointStatus: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Status = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFelixbackend(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFelixbackend
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *HostEndpointStatusRemove) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFelixbackend
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: HostEndpointStatusRemove: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: HostEndpointStatusRemove: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Id == nil {
				m.Id = &HostEndpointID{}
			}
			if err := m.Id.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFelixbackend(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFelixbackend
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *WorkloadEndpointStatusUpdate) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFelixbackend
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: WorkloadEndpointStatusUpdate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: WorkloadEndpointStatusUpdate: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Id == nil {
				m.Id = &WorkloadEndpointID{}
			}
			if err := m.Id.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Status == nil {
				m.Status = &EndpointStatus{}
			}
			if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFelixbackend(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFelixbackend
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *WorkloadEndpointStatusRemove) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFelixbackend
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: WorkloadEndpointStatusRemove: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: WorkloadEndpointStatusRemove: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Id == nil {
				m.Id = &WorkloadEndpointID{}
			}
			if err := m.Id.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFelixbackend(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFelixbackend
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *WireguardStatusUpdate) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFelixbackend
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: WireguardStatusUpdate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: WireguardStatusUpdate: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PublicKey", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PublicKey = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IpVersion", wireType)
			}
			m.IpVersion = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.IpVersion |= (IPVersion(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipFelixbackend(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFelixbackend
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DataplaneInSync) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFelixbackend
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: DataplaneInSync: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DataplaneInSync: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipFelixbackend(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFelixbackend
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *HostMetadataV4V6Update) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFelixbackend
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: HostMetadataV4V6Update: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: HostMetadataV4V6Update: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Hostname", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Hostname = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ipv4Addr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Ipv4Addr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ipv6Addr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Ipv6Addr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Asnumber", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Asnumber = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Labels", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Labels == nil {
				m.Labels = make(map[string]string)
			}
			var mapkey string
			var mapvalue string
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowFelixbackend
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowFelixbackend
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= (uint64(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthFelixbackend
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var stringLenmapvalue uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowFelixbackend
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapvalue |= (uint64(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapvalue := int(stringLenmapvalue)
					if intStringLenmapvalue < 0 {
						return ErrInvalidLengthFelixbackend
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipFelixbackend(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthFelixbackend
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Labels[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFelixbackend(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFelixbackend
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *HostMetadataV4V6Remove) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFelixbackend
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: HostMetadataV4V6Remove: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: HostMetadataV4V6Remove: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Hostname", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Hostname = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ipv4Addr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Ipv4Addr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFelixbackend(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFelixbackend
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *HostMetadataUpdate) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFelixbackend
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: HostMetadataUpdate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: HostMetadataUpdate: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Hostname", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Hostname = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ipv4Addr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Ipv4Addr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFelixbackend(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFelixbackend
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *HostMetadataRemove) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFelixbackend
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: HostMetadataRemove: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: HostMetadataRemove: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Hostname", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Hostname = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ipv4Addr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Ipv4Addr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFelixbackend(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFelixbackend
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *HostMetadataV6Update) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFelixbackend
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: HostMetadataV6Update: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: HostMetadataV6Update: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Hostname", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Hostname = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ipv6Addr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Ipv6Addr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFelixbackend(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFelixbackend
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *HostMetadataV6Remove) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFelixbackend
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: HostMetadataV6Remove: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: HostMetadataV6Remove: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Hostname", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Hostname = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ipv6Addr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Ipv6Addr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFelixbackend(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFelixbackend
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *IPAMPoolUpdate) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFelixbackend
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: IPAMPoolUpdate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: IPAMPoolUpdate: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Id = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pool", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Pool == nil {
				m.Pool = &IPAMPool{}
			}
			if err := m.Pool.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFelixbackend(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFelixbackend
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *IPAMPoolRemove) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFelixbackend
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: IPAMPoolRemove: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: IPAMPoolRemove: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Id = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFelixbackend(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFelixbackend
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *IPAMPool) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFelixbackend
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: IPAMPool: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: IPAMPool: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Cidr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Cidr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Masquerade", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Masquerade = bool(v != 0)
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IpipMode", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.IpipMode = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field VxlanMode", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.VxlanMode = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFelixbackend(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFelixbackend
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Encapsulation) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFelixbackend
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Encapsulation: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Encapsulation: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IpipEnabled", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IpipEnabled = bool(v != 0)
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field VxlanEnabled", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.VxlanEnabled = bool(v != 0)
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field VxlanEnabledV6", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.VxlanEnabledV6 = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipFelixbackend(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFelixbackend
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ServiceAccountUpdate) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFelixbackend
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ServiceAccountUpdate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ServiceAccountUpdate: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Id == nil {
				m.Id = &ServiceAccountID{}
			}
			if err := m.Id.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Labels", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Labels == nil {
				m.Labels = make(map[string]string)
			}
			var mapkey string
			var mapvalue string
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowFelixbackend
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowFelixbackend
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= (uint64(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthFelixbackend
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var stringLenmapvalue uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowFelixbackend
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapvalue |= (uint64(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapvalue := int(stringLenmapvalue)
					if intStringLenmapvalue < 0 {
						return ErrInvalidLengthFelixbackend
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipFelixbackend(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthFelixbackend
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Labels[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFelixbackend(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFelixbackend
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ServiceAccountRemove) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFelixbackend
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ServiceAccountRemove: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ServiceAccountRemove: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Id == nil {
				m.Id = &ServiceAccountID{}
			}
			if err := m.Id.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFelixbackend(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFelixbackend
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ServiceAccountID) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFelixbackend
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ServiceAccountID: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ServiceAccountID: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Namespace = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFelixbackend(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFelixbackend
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *NamespaceUpdate) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFelixbackend
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: NamespaceUpdate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: NamespaceUpdate: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Id == nil {
				m.Id = &NamespaceID{}
			}
			if err := m.Id.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Labels", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Labels == nil {
				m.Labels = make(map[string]string)
			}
			var mapkey string
			var mapvalue string
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowFelixbackend
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowFelixbackend
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= (uint64(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthFelixbackend
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var stringLenmapvalue uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowFelixbackend
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapvalue |= (uint64(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapvalue := int(stringLenmapvalue)
					if intStringLenmapvalue < 0 {
						return ErrInvalidLengthFelixbackend
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipFelixbackend(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthFelixbackend
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Labels[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFelixbackend(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFelixbackend
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *NamespaceRemove) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFelixbackend
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: NamespaceRemove: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: NamespaceRemove: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Id == nil {
				m.Id = &NamespaceID{}
			}
			if err := m.Id.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFelixbackend(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFelixbackend
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *NamespaceID) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFelixbackend
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: NamespaceID: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: NamespaceID: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFelixbackend(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFelixbackend
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TunnelType) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFelixbackend
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TunnelType: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TunnelType: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ipip", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Ipip = bool(v != 0)
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Vxlan", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Vxlan = bool(v != 0)
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Wireguard", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Wireguard = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipFelixbackend(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFelixbackend
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RouteUpdate) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFelixbackend
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RouteUpdate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RouteUpdate: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= (RouteType(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IpPoolType", wireType)
			}
			m.IpPoolType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.IpPoolType |= (IPPoolType(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Dst", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Dst = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DstNodeName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DstNodeName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DstNodeIp", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DstNodeIp = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SameSubnet", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.SameSubnet = bool(v != 0)
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NatOutgoing", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.NatOutgoing = bool(v != 0)
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LocalWorkload", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.LocalWorkload = bool(v != 0)
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TunnelType", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.TunnelType == nil {
				m.TunnelType = &TunnelType{}
			}
			if err := m.TunnelType.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 11:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Borrowed", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Borrowed = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipFelixbackend(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFelixbackend
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RouteRemove) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFelixbackend
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RouteRemove: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RouteRemove: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Dst", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Dst = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFelixbackend(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFelixbackend
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *VXLANTunnelEndpointUpdate) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFelixbackend
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: VXLANTunnelEndpointUpdate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: VXLANTunnelEndpointUpdate: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Node", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Node = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Mac", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Mac = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ipv4Addr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Ipv4Addr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ParentDeviceIp", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ParentDeviceIp = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MacV6", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MacV6 = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ipv6Addr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Ipv6Addr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ParentDeviceIpv6", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ParentDeviceIpv6 = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFelixbackend(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFelixbackend
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *VXLANTunnelEndpointRemove) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFelixbackend
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: VXLANTunnelEndpointRemove: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: VXLANTunnelEndpointRemove: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Node", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Node = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFelixbackend(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFelixbackend
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *WireguardEndpointUpdate) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFelixbackend
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: WireguardEndpointUpdate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: WireguardEndpointUpdate: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Hostname", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Hostname = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PublicKey", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PublicKey = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InterfaceIpv4Addr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.InterfaceIpv4Addr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFelixbackend(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFelixbackend
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *WireguardEndpointRemove) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFelixbackend
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: WireguardEndpointRemove: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: WireguardEndpointRemove: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Hostname", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Hostname = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFelixbackend(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFelixbackend
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *WireguardEndpointV6Update) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFelixbackend
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: WireguardEndpointV6Update: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: WireguardEndpointV6Update: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Hostname", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Hostname = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PublicKeyV6", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PublicKeyV6 = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InterfaceIpv6Addr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.InterfaceIpv6Addr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFelixbackend(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFelixbackend
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *WireguardEndpointV6Remove) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFelixbackend
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: WireguardEndpointV6Remove: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: WireguardEndpointV6Remove: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Hostname", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Hostname = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFelixbackend(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFelixbackend
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GlobalBGPConfigUpdate) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFelixbackend
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GlobalBGPConfigUpdate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GlobalBGPConfigUpdate: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ServiceClusterCidrs", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ServiceClusterCidrs = append(m.ServiceClusterCidrs, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ServiceExternalCidrs", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ServiceExternalCidrs = append(m.ServiceExternalCidrs, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ServiceLoadbalancerCidrs", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ServiceLoadbalancerCidrs = append(m.ServiceLoadbalancerCidrs, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFelixbackend(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFelixbackend
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ServicePort) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFelixbackend
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ServicePort: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ServicePort: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Protocol", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Protocol = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Port", wireType)
			}
			m.Port = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Port |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NodePort", wireType)
			}
			m.NodePort = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NodePort |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipFelixbackend(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFelixbackend
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ServiceUpdate) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFelixbackend
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ServiceUpdate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ServiceUpdate: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Namespace = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Type = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ClusterIps", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ClusterIps = append(m.ClusterIps, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LoadbalancerIp", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LoadbalancerIp = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExternalIps", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ExternalIps = append(m.ExternalIps, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ports", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Ports = append(m.Ports, &ServicePort{})
			if err := m.Ports[len(m.Ports)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFelixbackend(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFelixbackend
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ServiceRemove) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFelixbackend
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ServiceRemove: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ServiceRemove: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFelixbackend
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Namespace = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFelixbackend(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFelixbackend
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipFelixbackend(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowFelixbackend
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
			return iNdEx, nil
		case 1:
			iNdEx += 8
			return iNdEx, nil
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowFelixbackend
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			iNdEx += length
			if length < 0 {
				return 0, ErrInvalidLengthFelixbackend
			}
			return iNdEx, nil
		case 3:
			for {
				var innerWire uint64
				var start int = iNdEx
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return 0, ErrIntOverflowFelixbackend
					}
					if iNdEx >= l {
						return 0, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					innerWire |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				innerWireType := int(innerWire & 0x7)
				if innerWireType == 4 {
					break
				}
				next, err := skipFelixbackend(dAtA[start:])
				if err != nil {
					return 0, err
				}
				iNdEx = start + next
			}
			return iNdEx, nil
		case 4:
			return iNdEx, nil
		case 5:
			iNdEx += 4
			return iNdEx, nil
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
	}
	panic("unreachable")
}

var (
	ErrInvalidLengthFelixbackend = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowFelixbackend   = fmt.Errorf("proto: integer overflow")
)

func init() { proto1.RegisterFile("felixbackend.proto", fileDescriptorFelixbackend) }

var fileDescriptorFelixbackend = []byte{
	// 4260 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x7b, 0x4b, 0x73, 0x24, 0x49,
	0x52, 0xbf, 0xb2, 0x24, 0x95, 0xaa, 0xbc, 0x9e, 0x1d, 0x7a, 0x95, 0xd4, 0xdd, 0xea, 0x9e, 0xec,
	0xe9, 0x1d, 0x4d, 0xef, 0x4e, 0x4f, 0xff, 0x35, 0xea, 0xea, 0xed, 0xf9, 0x2f, 0xb3, 0x56, 0xad,
	0xd2, 0x8c, 0x6a, 0xa6, 0x5b, 0x12, 0x29, 0x8d, 0x86, 0x59, 0xd6, 0x2c, 0x49, 0x65, 0x86, 0xa4,
	0xa4, 0xb3, 0x32, 0x73, 0x32, 0xa3, 0xf4, 0x58, 0x4e, 0xc0, 0x62, 0x06, 0xc6, 0x01, 0x0e, 0x18,
	0x06, 0x77, 0x4e, 0x18, 0xdf, 0x80, 0x03, 0xd7, 0x5d, 0xe3, 0x02, 0xc6, 0x17, 0xc0, 0x86, 0x1b,
	0xc6, 0x05, 0xcc, 0x38, 0x70, 0xc3, 0xe2, 0x99, 0x8f, 0xca, 0x52, 0xab, 0xd9, 0x81, 0x93, 0x2a,
	0x3c, 0xdc, 0x7f, 0xe1, 0xe1, 0xe9, 0xe1, 0xe1, 0xe1, 0x11, 0x02, 0x74, 0x82, 0x3d, 0xf7, 0xf2,
	0xd8, 0xb2, 0x5f, 0x63, 0xdf, 0x79, 0x1c, 0x46, 0x01, 0x09, 0xd0, 0x2c, 0xa3, 0xe9, 0x0d, 0xa8,
	0x1d, 0x5c, 0xf9, 0xb6, 0x81, 0xbf, 0x19, 0xe1, 0x98, 0xe8, 0x7f, 0xbf, 0x04, 0xb5, 0xc3, 0xa0,
	0x6f, 0x11, 0x2b, 0xf4, 0x2c, 0x1f, 0xa3, 0x75, 0x98, 0x73, 0x7d, 0x33, 0xbe, 0xf2, 0xed, 0x8e,
	0x76, 0x5f, 0x5b, 0xaf, 0x6d, 0x34, 0x1e, 0x33, 0xb9, 0xc7, 0x03, 0x9f, 0x8a, 0xed, 0x4c, 0x19,
	0x65, 0x97, 0xfd, 0x42, 0xcf, 0xa0, 0xee, 0x86, 0x31, 0x26, 0xe6, 0x28, 0x74, 0x2c, 0x82, 0x3b,
	0x25, 0xc6, 0x8e, 0x24, 0xfb, 0xfe, 0x01, 0x26, 0x5f, 0xb2, 0x9e, 0x9d, 0x29, 0xa3, 0xc6, 0x38,
	0x79, 0x13, 0x7d, 0x06, 0x88, 0x0b, 0x3a, 0xd8, 0x23, 0x96, 0x14, 0x9f, 0x66, 0xe2, 0xcb, 0x69,
	0xf1, 0x3e, 0xed, 0x57, 0x18, 0x6d, 0x26, 0x94, 0xa2, 0x25, 0x1a, 0x44, 0x78, 0x18, 0x9c, 0xe3,
	0xce, 0xcc, 0xb8, 0x06, 0x06, 0xeb, 0x51, 0x1a, 0xf0, 0x26, 0xda, 0x87, 0x45, 0xcb, 0x26, 0xee,
	0x39, 0x36, 0xc3, 0x28, 0x38, 0x71, 0x3d, 0x2c, 0x95, 0x98, 0x65, 0x08, 0xab, 0x02, 0xa1, 0xc7,
	0x78, 0xf6, 0x39, 0x8b, 0xd2, 0x63, 0xde, 0x1a, 0x27, 0x17, 0x20, 0x0a, 0x9d, 0xca, 0x93, 0x11,
	0x95, 0x6e, 0x59, 0x44, 0xa1, 0xe3, 0x2b, 0x58, 0x90, 0x88, 0x81, 0xe7, 0xda, 0x57, 0x52, 0xc5,
	0x39, 0x06, 0xb8, 0x92, 0x05, 0x64, 0x1c, 0x4a, 0x43, 0x64, 0x8d, 0x51, 0xc7, 0xe1, 0x84, 0x7e,
	0x95, 0x89, 0x70, 0x4a, 0xbd, 0x0c, 0x5c, 0xa2, 0xdd, 0x59, 0x10, 0x13, 0x13, 0xfb, 0x4e, 0x18,
	0xb8, 0xbe, 0x72, 0x82, 0x6a, 0x06, 0x6e, 0x27, 0x88, 0xc9, 0xb6, 0xe0, 0x48, 0xb4, 0x3b, 0x1b,
	0xa3, 0x8e, 0xc3, 0x09, 0xed, 0x60, 0x22, 0x5c, 0xa2, 0xdd, 0xd9, 0x18, 0x15, 0x7d, 0x0d, 0x9d,
	0x8b, 0x20, 0x7a, 0xed, 0x05, 0x96, 0x33, 0xa6, 0x61, 0x8d, 0x41, 0xde, 0x15, 0x90, 0x5f, 0x09,
	0xb6, 0x31, 0x2d, 0x97, 0x2e, 0x0a, 0x7b, 0x8a, 0xa1, 0x85, 0xb6, 0xf5, 0x6b, 0xa1, 0x95, 0xc6,
	0x63, 0xd0, 0x42, 0xeb, 0x8f, 0xa1, 0x61, 0x07, 0xfe, 0x89, 0x7b, 0x2a, 0x55, 0x6d, 0x30, 0xbc,
	0x79, 0x81, 0xb7, 0xc5, 0xfa, 0x94, 0x82, 0x75, 0x3b, 0xd5, 0x56, 0x06, 0x1c, 0x62, 0x62, 0x39,
	0x56, 0xb2, 0xaa, 0x9a, 0x63, 0x06, 0x7c, 0x25, 0x38, 0xb2, 0xdf, 0x23, 0x4b, 0x45, 0xef, 0x41,
	0x2b, 0xa6, 0x01, 0xc2, 0xb7, 0xb1, 0xe9, 0x8f, 0x86, 0xc7, 0x38, 0xea, 0xb4, 0xee, 0x6b, 0xeb,
	0x33, 0x46, 0x53, 0x92, 0x77, 0x19, 0x15, 0xf5, 0xa0, 0xed, 0x86, 0xd6, 0xd0, 0x0c, 0x83, 0xc0,
	0x93, 0x63, 0xb6, 0xd9, 0x98, 0x8b, 0x6a, 0x19, 0xf6, 0x5e, 0xed, 0x07, 0x81, 0xa7, 0xc6, 0x6b,
	0x52, 0x81, 0x84, 0x92, 0x85, 0x10, 0x96, 0xbc, 0x55, 0x08, 0xa1, 0x2c, 0xa8, 0x20, 0x72, 0xde,
	0xa8, 0x66, 0x2f, 0x60, 0xd0, 0xc4, 0xd9, 0x67, 0xdd, 0x27, 0x4b, 0x45, 0x07, 0xb0, 0x14, 0xe3,
	0xe8, 0xdc, 0xb5, 0xb1, 0x69, 0xd9, 0x76, 0x30, 0x4a, 0x9c, 0x67, 0x9e, 0x01, 0xde, 0x16, 0x80,
	0x07, 0x9c, 0xa9, 0xc7, 0x79, 0xd4, 0x04, 0x17, 0xe2, 0x02, 0x7a, 0x11, 0xa8, 0xd0, 0x72, 0xe1,
	0x1a, 0x50, 0xa5, 0x67, 0x0e, 0x54, 0x68, 0xba, 0x05, 0x6d, 0xdf, 0x1a, 0xe2, 0x38, 0xb4, 0x6c,
	0x15, 0xc3, 0x16, 0x19, 0xdc, 0x92, 0x80, 0xdb, 0x95, 0xdd, 0x4a, 0xbd, 0x96, 0x9f, 0x25, 0x65,
	0x41, 0x84, 0x4e, 0x4b, 0xc5, 0x20, 0x4a, 0x9d, 0x04, 0x44, 0x68, 0xf2, 0x0c, 0xea, 0x51, 0x30,
	0x22, 0x4a, 0x8b, 0xe5, 0x4c, 0x2c, 0x36, 0x68, 0x57, 0xb2, 0x1b, 0x44, 0x49, 0x33, 0x11, 0x14,
	0x23, 0x77, 0xc6, 0x05, 0x93, 0x20, 0x1e, 0x25, 0x4d, 0xb4, 0x05, 0xb5, 0x73, 0x82, 0x43, 0x39,
	0xe0, 0x0a, 0x93, 0xbb, 0x2f, 0xe4, 0x8e, 0x7e, 0xe3, 0x65, 0x6f, 0xf7, 0x70, 0xe4, 0xfb, 0xd8,
	0x1b, 0x5b, 0xda, 0x40, 0xc5, 0xd4, 0xdc, 0x39, 0x88, 0x18, 0x7c, 0xf5, 0x4d, 0x20, 0x4a, 0x15,
	0x06, 0x22, 0x34, 0xf9, 0x29, 0xac, 0x5c, 0xb8, 0x11, 0x3e, 0x1d, 0x59, 0xd1, 0x78, 0xbc, 0xb9,
	0xcd, 0x20, 0xd7, 0x64, 0x50, 0x90, 0x7c, 0x63, 0x5a, 0x2d, 0x5f, 0x14, 0x77, 0x4d, 0x40, 0x17,
	0x0a, 0xdf, 0xb9, 0x1e, 0x5d, 0xa9, 0x3b, 0x8e, 0x2e, 0x74, 0xff, 0x0a, 0x3a, 0xa7, 0x5e, 0x70,
	0x6c, 0x79, 0xe6, 0xf1, 0x69, 0x68, 0x66, 0xe3, 0xcf, 0x5d, 0x06, 0x7e, 0x47, 0x80, 0x7f, 0xc6,
	0xd8, 0x5e, 0x7c, 0xb6, 0x9f, 0x0b, 0x44, 0x8b, 0x5c, 0xfe, 0xc5, 0x69, 0x98, 0xee, 0x40, 0x3f,
	0x82, 0x06, 0xf6, 0x6d, 0x2b, 0x8c, 0x47, 0x9e, 0x45, 0xdc, 0xc0, 0xef, 0xac, 0x31, 0xb4, 0x05,
	0x81, 0xb6, 0x9d, 0xee, 0xdb, 0x99, 0x32, 0xb2, 0xcc, 0xe8, 0xd7, 0xa0, 0x29, 0x57, 0x8b, 0x50,
	0xe6, 0x5e, 0x46, 0x5c, 0xac, 0x12, 0xa5, 0x44, 0x23, 0x4e, 0x13, 0xd2, 0xe2, 0xc2, 0x50, 0xf7,
	0x8b, 0xc4, 0x95, 0x79, 0xa4, 0xb8, 0x30, 0x8a, 0x0d, 0x77, 0x0a, 0x4c, 0x7e, 0xde, 0x95, 0xba,
	0xbc, 0x93, 0x71, 0x93, 0x31, 0xab, 0x1f, 0x75, 0x95, 0x5e, 0x2b, 0x17, 0x93, 0x3a, 0x27, 0x0f,
	0x22, 0x34, 0xd6, 0xdf, 0x34, 0x88, 0xd2, 0xbe, 0x68, 0x10, 0x31, 0x93, 0x43, 0x58, 0xce, 0x46,
	0xc6, 0x64, 0x12, 0x0f, 0x32, 0x61, 0x27, 0x1d, 0x1c, 0x53, 0xfa, 0x2f, 0x9c, 0x15, 0xd0, 0x0b,
	0x51, 0x85, 0xd6, 0xef, 0x5e, 0x83, 0x9a, 0x04, 0xb3, 0xb3, 0x02, 0x3a, 0xfa, 0x09, 0xac, 0xe4,
	0x50, 0x37, 0x13, 0x6d, 0x1f, 0x66, 0xf6, 0xd6, 0x0c, 0xee, 0x66, 0x4a, 0xdf, 0xa5, 0x0c, 0xf2,
	0xe6, 0xb9, 0xd4, 0xb8, 0x18, 0x5b, 0xe8, 0xfc, 0xbd, 0x6b, 0xb1, 0x93, 0x7d, 0x3b, 0x8f, 0xcd,
	0x7b, 0x5e, 0x54, 0x61, 0x2e, 0xb4, 0xae, 0xe8, 0x86, 0xae, 0xff, 0xd3, 0x2c, 0x34, 0x3e, 0x8d,
	0x82, 0x61, 0x92, 0x4f, 0xef, 0xc3, 0x62, 0x18, 0x05, 0x36, 0x8e, 0x63, 0x33, 0x26, 0x16, 0x19,
	0xc5, 0xd9, 0x7c, 0x57, 0x26, 0x86, 0xfb, 0x9c, 0xe7, 0x80, 0xb1, 0x24, 0xa9, 0x66, 0x38, 0x4e,
	0x46, 0xbf, 0x05, 0xb7, 0xb3, 0xb9, 0x52, 0x16, 0x97, 0x27, 0xc1, 0xf7, 0x0a, 0x52, 0xa6, 0x1c,
	0x78, 0xe7, 0x6c, 0x42, 0xdf, 0xc4, 0x11, 0x84, 0xb9, 0x66, 0xdf, 0x30, 0x82, 0x32, 0x58, 0xc1,
	0x08, 0xe2, 0x53, 0x7b, 0x70, 0x6f, 0x3c, 0x8b, 0xca, 0xce, 0x83, 0x27, 0xce, 0x0f, 0x26, 0x24,
	0x53, 0xb9, 0xb9, 0xdc, 0xb9, 0xb8, 0xa6, 0xff, 0xda, 0xd1, 0xc4, 0x9c, 0xe6, 0x6e, 0x30, 0x9a,
	0x9a, 0xd7, 0x84, 0xd1, 0xc4, 0xdc, 0x0a, 0x72, 0xa7, 0x4a, 0x61, 0xee, 0x74, 0x04, 0x49, 0x54,
	0xce, 0x4d, 0xbe, 0x9a, 0x89, 0xbc, 0x6a, 0xed, 0xe7, 0x66, 0xbd, 0x78, 0x51, 0xd4, 0x81, 0xfa,
	0x70, 0xcb, 0x91, 0xfe, 0x67, 0xca, 0xc3, 0x1c, 0x64, 0x36, 0x74, 0xe5, 0x9f, 0xea, 0x54, 0xd7,
	0x72, 0xb2, 0xa4, 0xb4, 0x57, 0xff, 0x63, 0x09, 0xea, 0x99, 0xd8, 0xfe, 0x0c, 0xca, 0x7c, 0xa7,
	0xe8, 0x68, 0xf7, 0xa7, 0x53, 0xbe, 0x90, 0x66, 0x12, 0x8d, 0x6d, 0x9f, 0x44, 0x57, 0x86, 0x60,
	0x47, 0xbf, 0x09, 0x0b, 0x71, 0x30, 0x8a, 0x6c, 0x6c, 0x92, 0xc0, 0x8c, 0xac, 0x0b, 0xb1, 0xe1,
	0x74, 0x4a, 0x0c, 0xe6, 0x51, 0x11, 0xcc, 0x01, 0xe3, 0x3f, 0x0c, 0x0c, 0xeb, 0x22, 0x8d, 0x78,
	0x2b, 0xce, 0xd3, 0x51, 0x07, 0xe6, 0x86, 0x38, 0x8e, 0xad, 0x53, 0xbe, 0xb8, 0xaa, 0x86, 0x6c,
	0xae, 0x3e, 0x87, 0x5a, 0x4a, 0x16, 0xb5, 0x61, 0xfa, 0x35, 0xbe, 0x62, 0xe7, 0xdb, 0xaa, 0x41,
	0x7f, 0xa2, 0x05, 0x98, 0x3d, 0xb7, 0xbc, 0x11, 0x3f, 0xc4, 0x56, 0x0d, 0xde, 0xf8, 0xb8, 0xf4,
	0x43, 0x6d, 0xf5, 0x08, 0x96, 0x8a, 0x35, 0x48, 0xa3, 0x34, 0x38, 0xca, 0xf7, 0xd2, 0x28, 0xb5,
	0x8d, 0xb6, 0xcc, 0x61, 0xa4, 0x5c, 0x0a, 0x57, 0xff, 0x33, 0x0d, 0xaa, 0x89, 0xea, 0x4b, 0x50,
	0xe6, 0xf3, 0x11, 0x4a, 0x89, 0x16, 0xda, 0x54, 0x86, 0xe6, 0x16, 0xba, 0x93, 0x87, 0x2c, 0xb2,
	0xf2, 0xaf, 0x30, 0x5d, 0xbd, 0x02, 0x65, 0xfe, 0xfd, 0xf5, 0xbf, 0xd0, 0xa0, 0x96, 0x3a, 0xc4,
	0xa3, 0x26, 0x94, 0x5c, 0x47, 0x80, 0x94, 0x5c, 0x87, 0x5b, 0x9b, 0xfa, 0x71, 0xcc, 0x74, 0x63,
	0xd6, 0x66, 0x4d, 0xf4, 0x04, 0x66, 0xc8, 0x55, 0xc8, 0x3f, 0x42, 0x53, 0xa9, 0x9c, 0xc2, 0xe2,
	0xbf, 0x0f, 0xaf, 0x42, 0x6c, 0x30, 0x4e, 0xfd, 0x03, 0xa8, 0x2a, 0x12, 0x2a, 0x43, 0x69, 0xb0,
	0xdf, 0x9e, 0x42, 0x2d, 0x3a, 0xbe, 0xd9, 0xdb, 0xed, 0x9b, 0xfb, 0x7b, 0xc6, 0x61, 0x5b, 0x43,
	0x73, 0x30, 0xbd, 0xbb, 0x7d, 0xd8, 0x2e, 0xe9, 0x21, 0xb4, 0xf3, 0xf5, 0x81, 0x31, 0xf5, 0x1e,
	0x40, 0xc3, 0x72, 0x1c, 0xec, 0x98, 0x59, 0x25, 0xeb, 0x8c, 0xf8, 0x4a, 0x68, 0xfa, 0x1e, 0xb4,
	0xf8, 0xfa, 0x4f, 0xd8, 0xa6, 0x19, 0x5b, 0x53, 0x90, 0x05, 0xa3, 0x7e, 0x57, 0xd8, 0x42, 0x2c,
	0xf1, 0xdc, 0x60, 0xba, 0x05, 0xf3, 0x05, 0xb5, 0x02, 0x74, 0x5f, 0xb1, 0x25, 0xce, 0x20, 0x38,
	0x06, 0x7d, 0xa6, 0xe5, 0x3a, 0xcc, 0x89, 0x7a, 0x81, 0xf0, 0x99, 0x66, 0x96, 0xcd, 0x90, 0xdd,
	0xfa, 0xb3, 0xdc, 0x10, 0x42, 0x93, 0x37, 0x0e, 0xa1, 0xdf, 0x83, 0xaa, 0x22, 0x20, 0x04, 0x33,
	0x34, 0x71, 0x17, 0xaa, 0xb3, 0xdf, 0x7a, 0x00, 0x73, 0x82, 0x01, 0x3d, 0x81, 0x86, 0xeb, 0x1f,
	0x07, 0x23, 0xdf, 0x31, 0xa3, 0x91, 0x87, 0x63, 0xb1, 0xbc, 0x6b, 0xd2, 0xeb, 0x46, 0x1e, 0x36,
	0xea, 0x82, 0x83, 0x36, 0x62, 0xb4, 0x01, 0xcd, 0x60, 0x44, 0xd2, 0x22, 0xa5, 0x71, 0x91, 0x86,
	0x64, 0x61, 0x32, 0xfa, 0x4f, 0x01, 0x8d, 0x97, 0x2d, 0xd0, 0xbd, 0xd4, 0x4c, 0x5a, 0x72, 0x26,
	0x8c, 0x41, 0xd8, 0xea, 0x21, 0x94, 0x79, 0xe9, 0x42, 0x98, 0xaa, 0x91, 0x61, 0x32, 0x44, 0xa7,
	0xfe, 0x34, 0x8b, 0x2e, 0xec, 0xf4, 0x26, 0x74, 0x7d, 0x03, 0x2a, 0xb2, 0x4d, 0xad, 0x44, 0x5c,
	0x1c, 0x49, 0x2b, 0xd1, 0xdf, 0xca, 0x72, 0xa5, 0x94, 0xe5, 0xfe, 0x43, 0x83, 0x32, 0x17, 0xfa,
	0xbf, 0xb1, 0x1c, 0xba, 0x03, 0xd5, 0x91, 0x4f, 0x22, 0xcb, 0x7e, 0x8d, 0x1d, 0xb6, 0xbc, 0x2a,
	0x46, 0x42, 0x40, 0x2b, 0x50, 0x09, 0x23, 0x6c, 0x3a, 0xbe, 0x45, 0x58, 0x16, 0x50, 0xa1, 0xde,
	0x83, 0xfb, 0xbe, 0x45, 0xa8, 0xa0, 0x3a, 0xb0, 0xb1, 0xfd, 0xbb, 0x6a, 0x24, 0x04, 0xf4, 0x7d,
	0xb8, 0x15, 0x44, 0xee, 0xa9, 0xeb, 0x5b, 0x9e, 0x19, 0x63, 0x0f, 0xdb, 0x24, 0x88, 0xd8, 0xfe,
	0x5b, 0x35, 0xda, 0xb2, 0xe3, 0x40, 0xd0, 0xf5, 0xbf, 0x6e, 0xc3, 0x0c, 0xd5, 0x86, 0xc6, 0x2c,
	0xcb, 0x66, 0x99, 0xbd, 0x88, 0x59, 0xbc, 0x85, 0x3e, 0x04, 0x70, 0x43, 0xf3, 0x1c, 0x47, 0x31,
	0xed, 0x2b, 0xb1, 0x20, 0xd0, 0x56, 0x41, 0xe0, 0x88, 0xd3, 0x8d, 0xaa, 0x1b, 0x8a, 0x9f, 0xe8,
	0xfb, 0x54, 0xef, 0x80, 0x04, 0x76, 0xe0, 0x89, 0xac, 0xa8, 0x95, 0x78, 0x32, 0x23, 0x1b, 0x8a,
	0x01, 0x2d, 0xc3, 0x5c, 0x1c, 0xd9, 0xa6, 0x8f, 0xe9, 0x1c, 0xa7, 0x59, 0xa8, 0x8c, 0xec, 0x5d,
	0x4c, 0xd0, 0x07, 0x50, 0xa5, 0x1d, 0x61, 0x10, 0x91, 0xb8, 0x33, 0xcb, 0x4c, 0xa9, 0x16, 0x44,
	0x10, 0x11, 0xc3, 0xf2, 0x4f, 0xb1, 0x51, 0x89, 0x23, 0x9b, 0xb6, 0x62, 0x8a, 0xe3, 0xc4, 0x84,
	0xe1, 0x94, 0x39, 0x8e, 0x13, 0x13, 0x81, 0x43, 0x3b, 0x38, 0xce, 0xdc, 0x24, 0x1c, 0x27, 0x26,
	0x1c, 0xe7, 0x2e, 0x54, 0x5d, 0x7b, 0x18, 0x9a, 0x2c, 0xe2, 0xd1, 0x7d, 0x7e, 0x76, 0x67, 0xca,
	0xa8, 0x50, 0x12, 0x0b, 0x66, 0x9f, 0x40, 0x53, 0x75, 0x9b, 0x76, 0xe0, 0xc8, 0xad, 0x5d, 0x6e,
	0xc4, 0x03, 0xc1, 0xd8, 0xf3, 0x9d, 0xad, 0xc0, 0x61, 0x75, 0x1d, 0x29, 0x4b, 0xdb, 0xe8, 0x01,
	0x34, 0xe9, 0xac, 0xdc, 0xd0, 0x8c, 0x31, 0x31, 0x5d, 0x27, 0xee, 0x00, 0xd3, 0xb6, 0x16, 0x47,
	0xf6, 0x20, 0x3c, 0xc0, 0x64, 0xe0, 0xc4, 0x94, 0x89, 0xaa, 0x9c, 0x62, 0xaa, 0x71, 0x26, 0x27,
	0x26, 0x8a, 0xe9, 0x19, 0xac, 0x30, 0xc3, 0x59, 0x43, 0xec, 0xb0, 0xd9, 0xa5, 0xf9, 0xeb, 0x8c,
	0x7f, 0x81, 0x9a, 0x92, 0xf6, 0xd3, 0xa9, 0xa5, 0x05, 0x99, 0xa5, 0x0a, 0x05, 0x1b, 0x5c, 0x90,
	0xda, 0x6e, 0x4c, 0xf0, 0x07, 0x30, 0x2f, 0xd4, 0x62, 0x52, 0x52, 0xa4, 0xc5, 0x44, 0x5a, 0x4c,
	0x37, 0xca, 0x2f, 0xb8, 0x37, 0xa0, 0xee, 0x07, 0xc4, 0x54, 0x9e, 0x70, 0x52, 0xec, 0x09, 0x35,
	0x3f, 0x20, 0xb2, 0x81, 0xd6, 0x80, 0x36, 0x4d, 0xe9, 0x10, 0xa7, 0x0c, 0xb9, 0xea, 0x07, 0xe4,
	0x80, 0xfb, 0xc4, 0x26, 0x34, 0x64, 0x3f, 0xff, 0x9e, 0x67, 0x13, 0xbe, 0x67, 0x8d, 0xcb, 0xf0,
	0x4f, 0x2a, 0x50, 0xa5, 0x7b, 0xb8, 0x0a, 0xb5, 0xcf, 0x3d, 0x44, 0xa0, 0x26, 0x5e, 0xf2, 0xdb,
	0xd7, 0xa0, 0xf6, 0xa5, 0xa3, 0xbc, 0xcb, 0xa5, 0x12, 0x67, 0x79, 0xcd, 0x9c, 0x45, 0x63, 0x5c,
	0xd2, 0x0d, 0xd0, 0x36, 0xa0, 0x0c, 0x17, 0xf7, 0x19, 0xef, 0x5a, 0x9f, 0xd1, 0x8c, 0x56, 0x0a,
	0x82, 0xb9, 0xcd, 0x23, 0x0e, 0x93, 0x73, 0x9d, 0x21, 0xdf, 0xdb, 0xf8, 0x5c, 0xd5, 0x67, 0x12,
	0xbc, 0x39, 0x0f, 0xf2, 0x15, 0x6f, 0x3f, 0xe5, 0x44, 0x9f, 0xc0, 0x5d, 0x65, 0xf0, 0x42, 0x7f,
	0x08, 0x99, 0xd8, 0xb2, 0xf8, 0x04, 0x63, 0x2e, 0x21, 0xe4, 0x27, 0xfb, 0xd3, 0x37, 0x4a, 0xbe,
	0x5f, 0xe4, 0x52, 0x1b, 0xb0, 0x98, 0x44, 0xaa, 0xc8, 0x4e, 0xa2, 0x55, 0xc4, 0x42, 0xd0, 0xbc,
	0x8a, 0x56, 0x91, 0x2d, 0x03, 0x56, 0x46, 0x86, 0x0e, 0xac, 0x64, 0xe2, 0xac, 0x4c, 0x3f, 0x26,
	0x4a, 0x66, 0x1b, 0xee, 0x65, 0xc6, 0x49, 0xea, 0x63, 0x4a, 0x9a, 0x30, 0xe9, 0x3b, 0xa9, 0x11,
	0x55, 0x95, 0xac, 0x10, 0x46, 0xce, 0x39, 0x07, 0x33, 0xca, 0xc2, 0x88, 0x59, 0x67, 0x61, 0x9e,
	0xc3, 0x8a, 0x82, 0x91, 0xe6, 0x57, 0x00, 0xe7, 0x0c, 0x60, 0x49, 0x32, 0xec, 0x32, 0xcb, 0x4f,
	0x14, 0xcd, 0x18, 0xe0, 0x62, 0x4c, 0x34, 0x6d, 0x83, 0x2f, 0x79, 0xc0, 0xc8, 0x17, 0x2d, 0x87,
	0x16, 0xb1, 0xcf, 0x3a, 0x97, 0x99, 0xd3, 0x6b, 0xb6, 0x66, 0xf9, 0x8a, 0x72, 0x18, 0x4b, 0x31,
	0x55, 0x63, 0x8c, 0x4e, 0x61, 0xb9, 0x12, 0x45, 0xb0, 0x57, 0x6f, 0x86, 0x75, 0xa8, 0x8a, 0xe3,
	0xb0, 0x1f, 0x02, 0x9c, 0x11, 0x12, 0x0a, 0x9c, 0x9f, 0x65, 0x12, 0xa2, 0x9d, 0xc3, 0xc3, 0x7d,
	0x2e, 0x5d, 0xa5, 0x3c, 0x52, 0xa0, 0x22, 0x8b, 0x01, 0x9d, 0xdf, 0xc9, 0x14, 0xda, 0xe9, 0xee,
	0xa6, 0x2a, 0xc2, 0x8a, 0x09, 0xfd, 0x3f, 0x58, 0xc8, 0xf9, 0x11, 0xd3, 0xa2, 0xf3, 0x7b, 0x7c,
	0xfb, 0x43, 0x19, 0x3f, 0x62, 0x5d, 0xa8, 0x0f, 0x6b, 0x45, 0x22, 0x89, 0x1f, 0x74, 0x7e, 0x9f,
	0x0b, 0xdf, 0x1e, 0x17, 0x56, 0x6e, 0x90, 0x19, 0x38, 0xf5, 0x45, 0x3a, 0x3f, 0xcf, 0x0d, 0x7c,
	0xa0, 0x0c, 0x9e, 0x19, 0x38, 0xfd, 0x11, 0x93, 0x81, 0xff, 0x20, 0x37, 0x70, 0x22, 0x9c, 0x0c,
	0xdc, 0x81, 0x39, 0x9a, 0x99, 0x98, 0xae, 0xd3, 0xf9, 0xa5, 0xd8, 0xe3, 0x69, 0x7b, 0xe0, 0xbc,
	0x28, 0xc3, 0x0c, 0x0d, 0x51, 0x2f, 0x00, 0x2a, 0x32, 0x5c, 0x7d, 0x5e, 0xae, 0xfc, 0x42, 0x6b,
	0xff, 0x52, 0x33, 0xc0, 0x0b, 0x4e, 0xcd, 0x30, 0xc2, 0x27, 0xee, 0xa5, 0xfe, 0x19, 0xcc, 0x17,
	0x7d, 0xac, 0x55, 0xa8, 0x28, 0x27, 0xe4, 0xc0, 0xaa, 0x4d, 0xcf, 0x26, 0x4c, 0x4b, 0x91, 0xb0,
	0xf3, 0x86, 0xfe, 0x57, 0x1a, 0x54, 0xd5, 0x67, 0xe4, 0x67, 0x0f, 0x72, 0x16, 0x38, 0x3c, 0xcf,
	0x62, 0x67, 0x0f, 0xd6, 0x44, 0x4f, 0x60, 0x36, 0xb4, 0xc8, 0x99, 0x4c, 0xa6, 0x56, 0xf3, 0x1e,
	0xf0, 0x78, 0xdf, 0x22, 0x67, 0xdc, 0x17, 0x38, 0xe3, 0xea, 0x17, 0x50, 0x55, 0x34, 0xb4, 0x04,
	0xb3, 0xf8, 0xd2, 0xb2, 0x09, 0xd7, 0x6a, 0x67, 0xca, 0xe0, 0x4d, 0xd4, 0x81, 0x32, 0x9f, 0x11,
	0xcf, 0xff, 0x76, 0xa6, 0x0c, 0xd1, 0x7e, 0x51, 0x07, 0xa0, 0x38, 0xdc, 0xef, 0xf4, 0x3f, 0xd7,
	0xa0, 0x9e, 0x76, 0x1f, 0xf4, 0x29, 0xd4, 0x2c, 0xdf, 0x0f, 0x08, 0xab, 0x6a, 0xca, 0xac, 0xf0,
	0xdd, 0x02, 0x47, 0x7b, 0xdc, 0x4b, 0xd8, 0xf8, 0x69, 0x2e, 0x2d, 0xb8, 0xfa, 0x09, 0xb4, 0xf3,
	0x0c, 0x6f, 0x75, 0xae, 0x7b, 0x0e, 0xad, 0xdc, 0xb6, 0xc1, 0xb2, 0x5c, 0xba, 0x0f, 0x51, 0xf9,
	0x59, 0x7e, 0x10, 0xa3, 0x34, 0xb6, 0xe1, 0x94, 0x38, 0x8d, 0xfe, 0xd6, 0x5f, 0x42, 0x45, 0x6d,
	0xb8, 0x1d, 0x28, 0x8b, 0x92, 0x86, 0x26, 0x52, 0x1d, 0xd1, 0x46, 0x0b, 0xe9, 0xfc, 0x78, 0x67,
	0x8a, 0x67, 0xc8, 0x2f, 0xda, 0xd0, 0xe4, 0xfd, 0x66, 0x10, 0x31, 0xe7, 0xd3, 0x9f, 0x42, 0x55,
	0x6d, 0x90, 0x54, 0xdf, 0x13, 0x37, 0x8a, 0x89, 0xd0, 0x81, 0x37, 0xa8, 0x12, 0x9e, 0x15, 0x13,
	0xa9, 0x04, 0xfd, 0xad, 0xff, 0x89, 0x06, 0x28, 0x5f, 0x95, 0x19, 0xf4, 0xe9, 0x01, 0x2e, 0x88,
	0xec, 0x33, 0x1c, 0x93, 0xc8, 0x22, 0x41, 0x44, 0x3d, 0x95, 0x4f, 0xbd, 0x99, 0x26, 0x0f, 0x1c,
	0x74, 0x0f, 0x6a, 0xaa, 0x04, 0xe4, 0x3a, 0xa2, 0x3e, 0x00, 0x92, 0xc4, 0x19, 0x54, 0x69, 0xc8,
	0x75, 0x58, 0xfe, 0x5c, 0x35, 0x40, 0x92, 0x06, 0xce, 0xe7, 0x33, 0x15, 0xad, 0x5d, 0x32, 0x2a,
	0x67, 0x41, 0x4c, 0xd8, 0x44, 0x2e, 0x61, 0xa9, 0xf8, 0xf2, 0x10, 0xbd, 0x9f, 0x3a, 0x6b, 0xac,
	0x4c, 0xa8, 0x28, 0x89, 0x33, 0xcd, 0x47, 0x50, 0x91, 0x43, 0x88, 0xb2, 0xda, 0xf2, 0xa4, 0xdb,
	0x43, 0xc5, 0xa8, 0xff, 0xe7, 0x34, 0xb4, 0xf3, 0xdd, 0xd4, 0x94, 0x31, 0xb1, 0x88, 0x3c, 0xda,
	0xf1, 0x46, 0xd1, 0xa9, 0x85, 0xba, 0xcd, 0xd0, 0xb2, 0x85, 0x09, 0xe8, 0x4f, 0x3a, 0x77, 0x79,
	0x6b, 0x4d, 0xf7, 0x60, 0x9e, 0x57, 0x83, 0x20, 0xd1, 0x6d, 0xf7, 0x36, 0x54, 0xdd, 0xf0, 0x7c,
	0x93, 0xa6, 0x43, 0x3c, 0xb7, 0xae, 0x1a, 0x15, 0x4a, 0xd8, 0xc5, 0x44, 0x76, 0x76, 0x79, 0x67,
	0x59, 0x75, 0x76, 0x59, 0xe7, 0x43, 0x98, 0xa5, 0xc7, 0x27, 0x99, 0x49, 0xcb, 0x74, 0xee, 0xd0,
	0xc5, 0xd1, 0xc0, 0x3f, 0x09, 0x0c, 0xde, 0x8b, 0xde, 0x87, 0x0a, 0x1f, 0xc0, 0x22, 0x9d, 0x0a,
	0xe3, 0x6c, 0xaa, 0xab, 0x27, 0xc2, 0x18, 0xe7, 0xd8, 0x78, 0x16, 0x11, 0xac, 0x5d, 0xc6, 0x5a,
	0x9d, 0xc8, 0xda, 0xa5, 0xac, 0x3d, 0xb8, 0x6b, 0x79, 0x5e, 0x70, 0x61, 0xc6, 0x61, 0x10, 0x9c,
	0x60, 0xc7, 0x14, 0xb5, 0x27, 0xbe, 0x74, 0xb1, 0xcc, 0xa5, 0x57, 0x19, 0xd3, 0x01, 0xe7, 0xe1,
	0xc5, 0x9e, 0x7d, 0xc1, 0x81, 0x3e, 0xcf, 0xae, 0xdf, 0x1a, 0x1b, 0x70, 0x7d, 0xc2, 0x37, 0xfa,
	0x5f, 0x5e, 0xc3, 0x5b, 0xe3, 0x1e, 0x27, 0x4e, 0xb7, 0x37, 0xf7, 0x38, 0xbd, 0x07, 0xcd, 0x74,
	0xc5, 0x76, 0xd0, 0xcf, 0x7b, 0x7e, 0xe9, 0x8d, 0x9e, 0xef, 0x01, 0x1a, 0xbf, 0xd8, 0x47, 0x0f,
	0x53, 0x3a, 0x2c, 0x16, 0xd4, 0x86, 0x85, 0xc7, 0x7f, 0x98, 0xf2, 0xf8, 0xe9, 0xcc, 0xb6, 0x9b,
	0xb9, 0xdd, 0x4f, 0xbc, 0xfd, 0xdf, 0x4b, 0x50, 0x4f, 0x77, 0x15, 0xd5, 0x30, 0xf2, 0x1e, 0x5c,
	0x1a, 0xf3, 0x60, 0xe5, 0x87, 0xd3, 0xd7, 0xfa, 0xe1, 0x63, 0x98, 0xc7, 0x97, 0x21, 0xb6, 0x09,
	0x76, 0x4c, 0xe6, 0x90, 0x96, 0xe3, 0x44, 0x72, 0x45, 0xdc, 0x92, 0x5d, 0x83, 0xf0, 0x7c, 0xb3,
	0x47, 0x3b, 0xf2, 0xfc, 0x5d, 0xc1, 0x3f, 0x3b, 0xc6, 0xdf, 0xe5, 0xfc, 0x3f, 0x84, 0x96, 0x3a,
	0xaf, 0x9b, 0x5c, 0xa1, 0x72, 0xb1, 0x42, 0x4d, 0xc5, 0x77, 0xc8, 0x34, 0x7b, 0x0a, 0x4d, 0x79,
	0xb8, 0x37, 0xaf, 0x5d, 0x51, 0x75, 0x71, 0xe6, 0xe7, 0x62, 0x9b, 0xd0, 0x38, 0x09, 0xa2, 0x0b,
	0x2b, 0x92, 0xc3, 0x55, 0x26, 0x48, 0x09, 0x2e, 0x26, 0xa5, 0xff, 0xff, 0xec, 0x17, 0x16, 0x5e,
	0x76, 0xb3, 0x2f, 0xac, 0xff, 0xa5, 0x06, 0x15, 0x89, 0x5b, 0xf8, 0xb1, 0xde, 0x87, 0xb6, 0xeb,
	0x9f, 0x46, 0x38, 0x8e, 0xf9, 0x5b, 0x14, 0x57, 0x6d, 0xf6, 0x2d, 0x41, 0xdf, 0x17, 0x64, 0x1a,
	0xdf, 0x71, 0x8e, 0x53, 0x14, 0xe8, 0x70, 0x96, 0xf1, 0x21, 0x34, 0x1d, 0x7c, 0x62, 0x8d, 0x3c,
	0x62, 0x8a, 0xa2, 0x04, 0x8f, 0xe0, 0x0d, 0x41, 0xed, 0x31, 0xa2, 0xfe, 0x0c, 0xe6, 0x44, 0x94,
	0x40, 0x8b, 0x50, 0xc6, 0x97, 0xf4, 0xec, 0x21, 0x23, 0x26, 0xbe, 0x24, 0x83, 0x90, 0x92, 0xd9,
	0x42, 0x08, 0xe5, 0xfa, 0xa3, 0x13, 0x0b, 0x75, 0x03, 0xe6, 0x0b, 0xae, 0x68, 0xd0, 0x03, 0x68,
	0xb8, 0x71, 0x60, 0x12, 0x77, 0x88, 0x63, 0x62, 0x0d, 0x25, 0x56, 0xdd, 0x8d, 0x83, 0x43, 0x49,
	0x43, 0x4b, 0x50, 0x1e, 0x85, 0x94, 0x85, 0x41, 0x6a, 0x86, 0x68, 0xe9, 0x21, 0x74, 0x26, 0x5d,
	0xcf, 0xdc, 0x74, 0x35, 0x7d, 0x00, 0x65, 0x7e, 0x71, 0x20, 0x6a, 0x62, 0x8b, 0xea, 0x76, 0x35,
	0x73, 0x31, 0x21, 0x98, 0xf4, 0x75, 0x68, 0x66, 0x7b, 0x58, 0xe1, 0x99, 0x03, 0xc8, 0xc2, 0x33,
	0xe7, 0xec, 0x15, 0xe9, 0xf6, 0x76, 0x7e, 0x70, 0x09, 0x77, 0xae, 0xbb, 0xb5, 0x79, 0x9b, 0x6d,
	0xf2, 0x2d, 0xa7, 0x39, 0x98, 0x34, 0xf2, 0xdb, 0x87, 0xcb, 0x53, 0x58, 0x2c, 0xbc, 0x7d, 0x41,
	0x77, 0x01, 0xc2, 0xd1, 0xb1, 0xe7, 0xda, 0x66, 0x12, 0xbf, 0xab, 0x9c, 0xf2, 0x05, 0xbe, 0x7a,
	0xeb, 0x22, 0x98, 0x7e, 0x0b, 0x5a, 0xb9, 0x4b, 0x19, 0xfd, 0x0f, 0x4b, 0xb0, 0x54, 0x7c, 0xd1,
	0x49, 0x13, 0x68, 0x19, 0x8e, 0x65, 0x02, 0x2d, 0xdb, 0x6a, 0xb3, 0xa6, 0xa1, 0x48, 0x38, 0x31,
	0xdb, 0x5c, 0x69, 0x04, 0x52, 0x9b, 0x35, 0xeb, 0x9c, 0x56, 0x9d, 0x2c, 0x3c, 0x51, 0x54, 0x2b,
	0x16, 0xf9, 0x1d, 0x5f, 0x3e, 0xaa, 0x8d, 0x7a, 0x50, 0xf6, 0xac, 0x63, 0xec, 0xc9, 0xda, 0xda,
	0xfb, 0xd7, 0xde, 0xc4, 0x3e, 0x7e, 0xc9, 0x78, 0xc5, 0xb5, 0x04, 0x17, 0x5c, 0x7d, 0x0e, 0xb5,
	0x14, 0xf9, 0xad, 0xb6, 0xbe, 0x5f, 0x1f, 0xb7, 0x84, 0xf8, 0x96, 0xff, 0x53, 0x4b, 0xe8, 0xaf,
	0x78, 0x8c, 0xcb, 0x3d, 0x7c, 0xfa, 0xae, 0xe0, 0x7e, 0x55, 0xed, 0xf6, 0x60, 0xa1, 0xe8, 0x46,
	0xfe, 0x06, 0x80, 0xdd, 0x3c, 0x60, 0xb7, 0x18, 0xf0, 0xc6, 0x1a, 0x4e, 0x00, 0xdc, 0x86, 0x66,
	0xf6, 0x69, 0x57, 0xc1, 0x15, 0xcc, 0x4c, 0x18, 0x04, 0x9e, 0x58, 0xb3, 0xad, 0xfc, 0x63, 0x2e,
	0xd6, 0xa9, 0xdf, 0x4f, 0x60, 0x26, 0x5c, 0xae, 0xfc, 0x0c, 0x2a, 0x92, 0x83, 0x9d, 0x4f, 0x5c,
	0x47, 0x55, 0xe6, 0xe9, 0x6f, 0xb4, 0x06, 0x30, 0xb4, 0xe2, 0x6f, 0x46, 0x38, 0xb2, 0xc4, 0xc9,
	0xa5, 0x62, 0xa4, 0x28, 0x7c, 0x16, 0x6e, 0x68, 0x0e, 0xe9, 0xc1, 0x46, 0xb9, 0xbc, 0x1b, 0xbe,
	0xa2, 0x87, 0xa0, 0xbb, 0x00, 0xe7, 0x97, 0x9e, 0xe5, 0xf3, 0x5e, 0xee, 0xf4, 0x55, 0x46, 0xa1,
	0xdd, 0xfa, 0xef, 0x6a, 0xd0, 0xc8, 0xbc, 0x54, 0x41, 0xef, 0x40, 0x9d, 0xa1, 0x61, 0xdf, 0x3a,
	0xf6, 0x30, 0xd7, 0xb3, 0x62, 0xd4, 0x28, 0x6d, 0x9b, 0x93, 0xe8, 0xa6, 0xc0, 0x31, 0x25, 0x0f,
	0xd7, 0xa9, 0xce, 0x88, 0x92, 0x69, 0x1d, 0xda, 0x19, 0x26, 0xf3, 0xbc, 0x2b, 0x2a, 0xfa, 0xcd,
	0x34, 0xdf, 0x51, 0x57, 0xff, 0x5b, 0x0d, 0x16, 0x8a, 0x5e, 0x9a, 0xa1, 0xf7, 0x52, 0x61, 0x6c,
	0xb9, 0xb0, 0x64, 0x22, 0xc2, 0xe7, 0x8f, 0xd5, 0xda, 0xe5, 0xa7, 0xe2, 0xf7, 0xae, 0x79, 0xbf,
	0xf6, 0x5d, 0xaf, 0xdc, 0x1f, 0xe7, 0x95, 0x57, 0xb7, 0xe4, 0x37, 0x53, 0x5e, 0xef, 0x43, 0x3b,
	0x4f, 0xcf, 0x5e, 0x67, 0x68, 0xf9, 0xeb, 0x8c, 0xa2, 0xab, 0x9a, 0xbf, 0xd1, 0xa0, 0x95, 0x7b,
	0x0a, 0x87, 0xf4, 0x94, 0x0a, 0x28, 0xff, 0xd2, 0x4d, 0x98, 0xee, 0xe3, 0x9c, 0xe9, 0xf4, 0xe2,
	0x67, 0x75, 0xdf, 0xb5, 0xd5, 0x9e, 0xa6, 0xb4, 0x15, 0x06, 0xbb, 0x81, 0xb6, 0xfa, 0x3b, 0x50,
	0x4b, 0x91, 0x0a, 0x6f, 0xfb, 0x0e, 0x01, 0xf8, 0x8b, 0xb6, 0x43, 0x71, 0xde, 0xa7, 0x9e, 0x2b,
	0xbc, 0x98, 0xfd, 0x66, 0x5a, 0x51, 0x0f, 0x14, 0x6e, 0xcb, 0x1b, 0xd4, 0xe4, 0xea, 0xb5, 0x81,
	0xbc, 0x7a, 0x52, 0x04, 0xfd, 0xbf, 0x4a, 0x50, 0x4b, 0xbd, 0xf1, 0x43, 0xef, 0xa6, 0x6a, 0x0b,
	0xc9, 0xc6, 0xc7, 0x38, 0x92, 0x6b, 0x5f, 0xf4, 0x11, 0x5d, 0x4b, 0xfc, 0xdd, 0x27, 0xe3, 0xe6,
	0xdb, 0xe4, 0x2d, 0x15, 0x28, 0xe8, 0x92, 0x67, 0xec, 0xe0, 0x86, 0xf2, 0x37, 0x35, 0xa3, 0x13,
	0x13, 0x79, 0x7c, 0x75, 0x62, 0x82, 0x74, 0x68, 0xb0, 0xe2, 0x6a, 0xe0, 0xf0, 0x02, 0x97, 0x58,
	0xc6, 0x35, 0x27, 0x26, 0xbb, 0x81, 0xc3, 0xea, 0x59, 0x68, 0x0d, 0x6a, 0x8a, 0xc7, 0x0d, 0xe5,
	0x15, 0x98, 0xe0, 0x18, 0x84, 0xf4, 0x00, 0x11, 0x5b, 0x43, 0x6c, 0xc6, 0xa3, 0x63, 0x1f, 0x13,
	0xf6, 0x1c, 0xa4, 0x62, 0x00, 0x25, 0x1d, 0x30, 0x0a, 0x5d, 0xf7, 0x34, 0xf5, 0x0e, 0x46, 0xe4,
	0x34, 0x70, 0xfd, 0x53, 0x76, 0xd5, 0x53, 0x31, 0x6a, 0xbe, 0x45, 0xf6, 0x04, 0x89, 0xe6, 0xa0,
	0x5e, 0x60, 0x5b, 0x9e, 0x29, 0xcb, 0x0a, 0xec, 0xae, 0xa7, 0x62, 0x34, 0x18, 0x55, 0x26, 0x18,
	0x68, 0x03, 0x6a, 0x84, 0x7d, 0x01, 0x3e, 0x69, 0xfe, 0x30, 0x43, 0x4e, 0x3a, 0xf9, 0x36, 0x06,
	0x90, 0xe4, 0x3b, 0xad, 0x42, 0xe5, 0x38, 0x88, 0xa2, 0xe0, 0x02, 0x3b, 0xec, 0x01, 0x73, 0xc5,
	0x50, 0x6d, 0xfd, 0x9e, 0x30, 0xbd, 0xf0, 0x13, 0x61, 0x9f, 0x92, 0xb2, 0x8f, 0xfe, 0xaf, 0x1a,
	0xac, 0x4c, 0x7c, 0x0f, 0xc9, 0x9c, 0x84, 0xc6, 0x3e, 0xe9, 0x24, 0x34, 0x2a, 0x8a, 0x12, 0x41,
	0x29, 0x29, 0x11, 0x64, 0x36, 0xab, 0xe9, 0x5c, 0x52, 0xb1, 0x0e, 0xed, 0xd0, 0x8a, 0xb0, 0x4f,
	0x4c, 0x07, 0xb3, 0x32, 0xa3, 0x1b, 0x8a, 0x6f, 0xd0, 0xe4, 0xf4, 0x3e, 0x23, 0xf3, 0xec, 0x7a,
	0x68, 0xd9, 0x34, 0xd6, 0xf1, 0x2f, 0x30, 0x3b, 0xb4, 0xec, 0xa3, 0x6e, 0x76, 0xa3, 0x29, 0xe7,
	0xb2, 0x92, 0x1f, 0x00, 0xca, 0xa3, 0x9f, 0x77, 0xd9, 0x17, 0xaa, 0x1a, 0xed, 0x2c, 0xfe, 0x79,
	0x57, 0xff, 0xb0, 0x70, 0xae, 0xc2, 0x36, 0x05, 0x73, 0xd5, 0x7f, 0xae, 0xc1, 0xf2, 0x84, 0x57,
	0x99, 0xd7, 0x6e, 0x8e, 0xd9, 0x04, 0xb0, 0x94, 0x4f, 0x00, 0x1f, 0xc3, 0xbc, 0xeb, 0x13, 0x1c,
	0x9d, 0x58, 0x5c, 0xe3, 0x8c, 0xe9, 0x6e, 0xa9, 0x2e, 0x79, 0x94, 0xd4, 0x9f, 0x16, 0x68, 0xf1,
	0xe6, 0x2d, 0x5a, 0xff, 0x63, 0x0d, 0x56, 0x26, 0xbe, 0x3f, 0xbc, 0x56, 0x7f, 0x1d, 0x1a, 0x89,
	0xfe, 0xf4, 0x8b, 0xf0, 0x29, 0xd4, 0xd4, 0x14, 0x8e, 0xba, 0x63, 0x93, 0xe8, 0x4e, 0x9c, 0x04,
	0xcf, 0x09, 0x9e, 0x15, 0x2a, 0x73, 0x83, 0x69, 0xfc, 0x9d, 0x06, 0x8b, 0x85, 0xef, 0x4b, 0xd1,
	0x06, 0x2c, 0xca, 0xe2, 0xb5, 0xed, 0x8d, 0x62, 0x82, 0x23, 0x93, 0xee, 0xfa, 0xb2, 0xf0, 0x3b,
	0x2f, 0x3a, 0xb7, 0x78, 0xdf, 0x16, 0xed, 0x42, 0x9b, 0xc9, 0x53, 0x6b, 0x7c, 0x49, 0x70, 0xe4,
	0x5b, 0x9e, 0x10, 0x2a, 0x89, 0x7b, 0x4e, 0xde, 0xbb, 0x2d, 0x3a, 0xb9, 0xd4, 0x8f, 0x60, 0x55,
	0x4a, 0xd1, 0x75, 0x7a, 0x6c, 0x79, 0x96, 0x6f, 0xab, 0xe1, 0xf8, 0xb1, 0xb3, 0x23, 0x38, 0x5e,
	0xa6, 0x18, 0x98, 0xb4, 0xfe, 0x35, 0xd4, 0xc4, 0x36, 0xb5, 0x1f, 0x44, 0x84, 0x4e, 0x56, 0x16,
	0x4d, 0xe5, 0x64, 0x55, 0x11, 0x15, 0xc1, 0x0c, 0xe5, 0x91, 0xf5, 0x4d, 0xc9, 0x4f, 0x23, 0x11,
	0xa3, 0x4f, 0x33, 0xba, 0x6a, 0xeb, 0xff, 0xa6, 0x41, 0x23, 0xf3, 0xde, 0xb5, 0xf0, 0x54, 0x9d,
	0xd9, 0x13, 0x4b, 0x05, 0x7b, 0xa2, 0x7a, 0x93, 0x53, 0x15, 0xe1, 0xf7, 0x1e, 0xd4, 0xa4, 0x49,
	0xdd, 0x50, 0x95, 0xfd, 0x04, 0x69, 0x10, 0xb2, 0xd3, 0x77, 0xc6, 0x12, 0x2a, 0x70, 0x36, 0xd3,
	0xe4, 0x41, 0x48, 0x83, 0xa3, 0x32, 0x34, 0x85, 0xe2, 0x55, 0xc0, 0x9a, 0xa4, 0x51, 0xac, 0x75,
	0x98, 0x4d, 0x5f, 0xa9, 0xa3, 0xec, 0x96, 0xcf, 0x4a, 0xc2, 0x9c, 0x41, 0xef, 0xa9, 0xd9, 0xa6,
	0x56, 0xed, 0x5b, 0xcd, 0xf6, 0xd1, 0x3a, 0x54, 0xd5, 0x21, 0x0b, 0xcd, 0xc1, 0x74, 0x6f, 0xf7,
	0xeb, 0xf6, 0x14, 0xaa, 0xc0, 0xcc, 0x60, 0xff, 0x68, 0xb3, 0x3d, 0x23, 0x7e, 0x75, 0xdb, 0xe5,
	0x47, 0x7f, 0xa4, 0x41, 0x55, 0x6d, 0x4b, 0xa8, 0x01, 0xd5, 0xad, 0x41, 0xdf, 0x30, 0x07, 0xbb,
	0x9f, 0xee, 0xb5, 0xa7, 0xd0, 0x3c, 0xb4, 0x8c, 0xed, 0x57, 0x7b, 0x87, 0xdb, 0xe6, 0x57, 0x7b,
	0xc6, 0x17, 0x2f, 0xf7, 0x7a, 0xfd, 0xb6, 0x86, 0x5a, 0x50, 0x13, 0xc4, 0x9d, 0xbd, 0x83, 0xc3,
	0x76, 0x09, 0x21, 0x68, 0xbe, 0xdc, 0xdb, 0xea, 0xbd, 0x4c, 0x98, 0xa6, 0x51, 0x13, 0x80, 0xd3,
	0x18, 0xcf, 0x0c, 0xba, 0x05, 0x0d, 0x21, 0x74, 0xf8, 0xe5, 0xee, 0xee, 0xf6, 0xcb, 0xf6, 0x2c,
	0x6a, 0x43, 0x9d, 0xb3, 0x08, 0x4a, 0xf9, 0xd1, 0x73, 0x80, 0x64, 0xcf, 0xa3, 0x3a, 0xee, 0xee,
	0xed, 0x6e, 0xb7, 0xa7, 0x50, 0x1d, 0x2a, 0xbb, 0x7b, 0xe6, 0xf6, 0xee, 0x56, 0x6f, 0xbf, 0xad,
	0xa1, 0x2a, 0xcc, 0xb2, 0x00, 0xd7, 0x2e, 0xf1, 0x69, 0x0c, 0xf6, 0xdb, 0xd3, 0x1b, 0x9f, 0x00,
	0xf0, 0x87, 0x28, 0xec, 0x3f, 0xb3, 0x9e, 0xc0, 0x0c, 0xfb, 0xab, 0x8c, 0x9c, 0xfc, 0xbf, 0xd7,
	0xaa, 0xa4, 0xa5, 0xfe, 0xe7, 0xeb, 0x89, 0xf6, 0x62, 0xf9, 0x17, 0xdf, 0xae, 0x69, 0xff, 0xf0,
	0xed, 0x9a, 0xf6, 0xcf, 0xdf, 0xae, 0x69, 0x7f, 0xfa, 0x2f, 0x6b, 0x53, 0x3f, 0x99, 0x65, 0x17,
	0xf1, 0xc7, 0x65, 0xf6, 0xe7, 0xa3, 0xff, 0x0e, 0x00, 0x00, 0xff, 0xff, 0xab, 0x5c, 0x16, 0x5b,
	0x51, 0x36, 0x00, 0x00,
}
