// Code generated by protoc-gen-go.
// source: gobgp.proto
// DO NOT EDIT!

/*
Package api is a generated protocol buffer package.

It is generated from these files:
	gobgp.proto

It has these top-level messages:
	Error
	Arguments
	ModPathArguments
	PolicyArguments
	AddressFamily
	GracefulRestartTuple
	GracefulRestart
	Capability
	Aggregator
	ExtendedCommunity
	EVPNNlri
	EvpnMacIpAdvertisement
	RTNlri
	Nlri
	TunnelEncapSubTLV
	TunnelEncapTLV
	PathAttr
	Path
	Destination
	PeerConf
	PeerInfo
	Peer
	Prefix
	PrefixSet
	Neighbor
	NeighborSet
	AsPathLength
	Conditions
	Actions
	Statement
	PolicyDefinition
	RoutingPolicy
	ApplyPolicy
*/
package api

import proto "github.com/golang/protobuf/proto"

import (
	context "golang.org/x/net/context"
	grpc "google.golang.org/grpc"
)

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

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal

type Resource int32

const (
	Resource_GLOBAL             Resource = 0
	Resource_LOCAL              Resource = 1
	Resource_ADJ_IN             Resource = 2
	Resource_ADJ_OUT            Resource = 3
	Resource_POLICY_PREFIX      Resource = 4
	Resource_POLICY_NEIGHBOR    Resource = 5
	Resource_POLICY_ROUTEPOLICY Resource = 6
)

var Resource_name = map[int32]string{
	0: "GLOBAL",
	1: "LOCAL",
	2: "ADJ_IN",
	3: "ADJ_OUT",
	4: "POLICY_PREFIX",
	5: "POLICY_NEIGHBOR",
	6: "POLICY_ROUTEPOLICY",
}
var Resource_value = map[string]int32{
	"GLOBAL":             0,
	"LOCAL":              1,
	"ADJ_IN":             2,
	"ADJ_OUT":            3,
	"POLICY_PREFIX":      4,
	"POLICY_NEIGHBOR":    5,
	"POLICY_ROUTEPOLICY": 6,
}

func (x Resource) String() string {
	return proto.EnumName(Resource_name, int32(x))
}

type Operation int32

const (
	Operation_ADD     Operation = 0
	Operation_DEL     Operation = 1
	Operation_DEL_ALL Operation = 2
)

var Operation_name = map[int32]string{
	0: "ADD",
	1: "DEL",
	2: "DEL_ALL",
}
var Operation_value = map[string]int32{
	"ADD":     0,
	"DEL":     1,
	"DEL_ALL": 2,
}

func (x Operation) String() string {
	return proto.EnumName(Operation_name, int32(x))
}

type AFI int32

const (
	AFI_UNKNOWN_AFI AFI = 0
	AFI_IP          AFI = 1
	AFI_IP6         AFI = 2
	AFI_L2VPN       AFI = 25
)

var AFI_name = map[int32]string{
	0:  "UNKNOWN_AFI",
	1:  "IP",
	2:  "IP6",
	25: "L2VPN",
}
var AFI_value = map[string]int32{
	"UNKNOWN_AFI": 0,
	"IP":          1,
	"IP6":         2,
	"L2VPN":       25,
}

func (x AFI) String() string {
	return proto.EnumName(AFI_name, int32(x))
}

type SAFI int32

const (
	SAFI_UNKNOWN_SAFI             SAFI = 0
	SAFI_UNICAST                  SAFI = 1
	SAFI_MULTICAST                SAFI = 2
	SAFI_MPLS_LABEL               SAFI = 4
	SAFI_ENCAP                    SAFI = 7
	SAFI_VPLS                     SAFI = 65
	SAFI_EVPN                     SAFI = 70
	SAFI_MPLS_VPN                 SAFI = 128
	SAFI_MPLS_VPN_MULTICAST       SAFI = 129
	SAFI_ROUTE_TARGET_CONSTRAINTS SAFI = 132
)

var SAFI_name = map[int32]string{
	0:   "UNKNOWN_SAFI",
	1:   "UNICAST",
	2:   "MULTICAST",
	4:   "MPLS_LABEL",
	7:   "ENCAP",
	65:  "VPLS",
	70:  "EVPN",
	128: "MPLS_VPN",
	129: "MPLS_VPN_MULTICAST",
	132: "ROUTE_TARGET_CONSTRAINTS",
}
var SAFI_value = map[string]int32{
	"UNKNOWN_SAFI":             0,
	"UNICAST":                  1,
	"MULTICAST":                2,
	"MPLS_LABEL":               4,
	"ENCAP":                    7,
	"VPLS":                     65,
	"EVPN":                     70,
	"MPLS_VPN":                 128,
	"MPLS_VPN_MULTICAST":       129,
	"ROUTE_TARGET_CONSTRAINTS": 132,
}

func (x SAFI) String() string {
	return proto.EnumName(SAFI_name, int32(x))
}

type BGP_CAPABILITY int32

const (
	BGP_CAPABILITY_UNKNOWN_CAP            BGP_CAPABILITY = 0
	BGP_CAPABILITY_MULTIPROTOCOL          BGP_CAPABILITY = 1
	BGP_CAPABILITY_ROUTE_REFRESH          BGP_CAPABILITY = 2
	BGP_CAPABILITY_CARRYING_LABEL_INFO    BGP_CAPABILITY = 4
	BGP_CAPABILITY_GRACEFUL_RESTART       BGP_CAPABILITY = 64
	BGP_CAPABILITY_FOUR_OCTET_AS_NUMBER   BGP_CAPABILITY = 65
	BGP_CAPABILITY_ENHANCED_ROUTE_REFRESH BGP_CAPABILITY = 70
	BGP_CAPABILITY_ROUTE_REFRESH_CISCO    BGP_CAPABILITY = 128
)

var BGP_CAPABILITY_name = map[int32]string{
	0:   "UNKNOWN_CAP",
	1:   "MULTIPROTOCOL",
	2:   "ROUTE_REFRESH",
	4:   "CARRYING_LABEL_INFO",
	64:  "GRACEFUL_RESTART",
	65:  "FOUR_OCTET_AS_NUMBER",
	70:  "ENHANCED_ROUTE_REFRESH",
	128: "ROUTE_REFRESH_CISCO",
}
var BGP_CAPABILITY_value = map[string]int32{
	"UNKNOWN_CAP":            0,
	"MULTIPROTOCOL":          1,
	"ROUTE_REFRESH":          2,
	"CARRYING_LABEL_INFO":    4,
	"GRACEFUL_RESTART":       64,
	"FOUR_OCTET_AS_NUMBER":   65,
	"ENHANCED_ROUTE_REFRESH": 70,
	"ROUTE_REFRESH_CISCO":    128,
}

func (x BGP_CAPABILITY) String() string {
	return proto.EnumName(BGP_CAPABILITY_name, int32(x))
}

type Origin int32

const (
	Origin_IGP        Origin = 0
	Origin_EGP        Origin = 1
	Origin_INCOMPLETE Origin = 2
)

var Origin_name = map[int32]string{
	0: "IGP",
	1: "EGP",
	2: "INCOMPLETE",
}
var Origin_value = map[string]int32{
	"IGP":        0,
	"EGP":        1,
	"INCOMPLETE": 2,
}

func (x Origin) String() string {
	return proto.EnumName(Origin_name, int32(x))
}

type EXTENDED_COMMUNITIE_TYPE int32

const (
	EXTENDED_COMMUNITIE_TYPE_TWO_OCTET_AS_SPECIFIC  EXTENDED_COMMUNITIE_TYPE = 0
	EXTENDED_COMMUNITIE_TYPE_IP4_SPECIFIC           EXTENDED_COMMUNITIE_TYPE = 1
	EXTENDED_COMMUNITIE_TYPE_FOUR_OCTET_AS_SPECIFIC EXTENDED_COMMUNITIE_TYPE = 2
	EXTENDED_COMMUNITIE_TYPE_OPAQUE                 EXTENDED_COMMUNITIE_TYPE = 3
)

var EXTENDED_COMMUNITIE_TYPE_name = map[int32]string{
	0: "TWO_OCTET_AS_SPECIFIC",
	1: "IP4_SPECIFIC",
	2: "FOUR_OCTET_AS_SPECIFIC",
	3: "OPAQUE",
}
var EXTENDED_COMMUNITIE_TYPE_value = map[string]int32{
	"TWO_OCTET_AS_SPECIFIC":  0,
	"IP4_SPECIFIC":           1,
	"FOUR_OCTET_AS_SPECIFIC": 2,
	"OPAQUE":                 3,
}

func (x EXTENDED_COMMUNITIE_TYPE) String() string {
	return proto.EnumName(EXTENDED_COMMUNITIE_TYPE_name, int32(x))
}

type EXTENDED_COMMUNITIE_SUBTYPE int32

const (
	EXTENDED_COMMUNITIE_SUBTYPE_ORIGIN_VALIDATION EXTENDED_COMMUNITIE_SUBTYPE = 0
	EXTENDED_COMMUNITIE_SUBTYPE_ROUTE_TARGET      EXTENDED_COMMUNITIE_SUBTYPE = 2
	EXTENDED_COMMUNITIE_SUBTYPE_ROUTE_ORIGIN      EXTENDED_COMMUNITIE_SUBTYPE = 3
)

var EXTENDED_COMMUNITIE_SUBTYPE_name = map[int32]string{
	0: "ORIGIN_VALIDATION",
	2: "ROUTE_TARGET",
	3: "ROUTE_ORIGIN",
}
var EXTENDED_COMMUNITIE_SUBTYPE_value = map[string]int32{
	"ORIGIN_VALIDATION": 0,
	"ROUTE_TARGET":      2,
	"ROUTE_ORIGIN":      3,
}

func (x EXTENDED_COMMUNITIE_SUBTYPE) String() string {
	return proto.EnumName(EXTENDED_COMMUNITIE_SUBTYPE_name, int32(x))
}

type TUNNEL_TYPE int32

const (
	TUNNEL_TYPE_UNKNOWN_TUNNEL_TYPE TUNNEL_TYPE = 0
	TUNNEL_TYPE_L2TPV3_OVER_IP      TUNNEL_TYPE = 1
	TUNNEL_TYPE_GRE                 TUNNEL_TYPE = 2
	TUNNEL_TYPE_IP_IN_IP            TUNNEL_TYPE = 7
	TUNNEL_TYPE_VXLAN               TUNNEL_TYPE = 8
	TUNNEL_TYPE_NVGRE               TUNNEL_TYPE = 9
	TUNNEL_TYPE_MPLS                TUNNEL_TYPE = 10
	TUNNEL_TYPE_MPLS_IN_GRE         TUNNEL_TYPE = 11
	TUNNEL_TYPE_VXLAN_GRE           TUNNEL_TYPE = 12
)

var TUNNEL_TYPE_name = map[int32]string{
	0:  "UNKNOWN_TUNNEL_TYPE",
	1:  "L2TPV3_OVER_IP",
	2:  "GRE",
	7:  "IP_IN_IP",
	8:  "VXLAN",
	9:  "NVGRE",
	10: "MPLS",
	11: "MPLS_IN_GRE",
	12: "VXLAN_GRE",
}
var TUNNEL_TYPE_value = map[string]int32{
	"UNKNOWN_TUNNEL_TYPE": 0,
	"L2TPV3_OVER_IP":      1,
	"GRE":                 2,
	"IP_IN_IP":            7,
	"VXLAN":               8,
	"NVGRE":               9,
	"MPLS":                10,
	"MPLS_IN_GRE":         11,
	"VXLAN_GRE":           12,
}

func (x TUNNEL_TYPE) String() string {
	return proto.EnumName(TUNNEL_TYPE_name, int32(x))
}

type EVPN_TYPE int32

const (
	EVPN_TYPE_UNKNOWN_EVPN_TYPE                  EVPN_TYPE = 0
	EVPN_TYPE_ROUTE_TYPE_ETHERNET_AUTO_DISCOVERY EVPN_TYPE = 1
	EVPN_TYPE_ROUTE_TYPE_MAC_IP_ADVERTISEMENT    EVPN_TYPE = 2
	EVPN_TYPE_INCLUSIVE_MULTICAST_ETHERNET_TAG   EVPN_TYPE = 3
	EVPN_TYPE_ETHERNET_SEGMENT_ROUTE             EVPN_TYPE = 4
)

var EVPN_TYPE_name = map[int32]string{
	0: "UNKNOWN_EVPN_TYPE",
	1: "ROUTE_TYPE_ETHERNET_AUTO_DISCOVERY",
	2: "ROUTE_TYPE_MAC_IP_ADVERTISEMENT",
	3: "INCLUSIVE_MULTICAST_ETHERNET_TAG",
	4: "ETHERNET_SEGMENT_ROUTE",
}
var EVPN_TYPE_value = map[string]int32{
	"UNKNOWN_EVPN_TYPE":                  0,
	"ROUTE_TYPE_ETHERNET_AUTO_DISCOVERY": 1,
	"ROUTE_TYPE_MAC_IP_ADVERTISEMENT":    2,
	"INCLUSIVE_MULTICAST_ETHERNET_TAG":   3,
	"ETHERNET_SEGMENT_ROUTE":             4,
}

func (x EVPN_TYPE) String() string {
	return proto.EnumName(EVPN_TYPE_name, int32(x))
}

type ENCAP_SUBTLV_TYPE int32

const (
	ENCAP_SUBTLV_TYPE_UNKNOWN_SUBTLV_TYPE ENCAP_SUBTLV_TYPE = 0
	ENCAP_SUBTLV_TYPE_ENCAPSULATION       ENCAP_SUBTLV_TYPE = 1
	ENCAP_SUBTLV_TYPE_PROTOCOL            ENCAP_SUBTLV_TYPE = 2
	ENCAP_SUBTLV_TYPE_COLOR               ENCAP_SUBTLV_TYPE = 4
)

var ENCAP_SUBTLV_TYPE_name = map[int32]string{
	0: "UNKNOWN_SUBTLV_TYPE",
	1: "ENCAPSULATION",
	2: "PROTOCOL",
	4: "COLOR",
}
var ENCAP_SUBTLV_TYPE_value = map[string]int32{
	"UNKNOWN_SUBTLV_TYPE": 0,
	"ENCAPSULATION":       1,
	"PROTOCOL":            2,
	"COLOR":               4,
}

func (x ENCAP_SUBTLV_TYPE) String() string {
	return proto.EnumName(ENCAP_SUBTLV_TYPE_name, int32(x))
}

type BGP_ATTR_TYPE int32

const (
	BGP_ATTR_TYPE_UNKNOWN_ATTR         BGP_ATTR_TYPE = 0
	BGP_ATTR_TYPE_ORIGIN               BGP_ATTR_TYPE = 1
	BGP_ATTR_TYPE_AS_PATH              BGP_ATTR_TYPE = 2
	BGP_ATTR_TYPE_NEXT_HOP             BGP_ATTR_TYPE = 3
	BGP_ATTR_TYPE_MULTI_EXIT_DISC      BGP_ATTR_TYPE = 4
	BGP_ATTR_TYPE_LOCAL_PREF           BGP_ATTR_TYPE = 5
	BGP_ATTR_TYPE_ATOMIC_AGGREGATE     BGP_ATTR_TYPE = 6
	BGP_ATTR_TYPE_AGGREGATOR           BGP_ATTR_TYPE = 7
	BGP_ATTR_TYPE_COMMUNITIES          BGP_ATTR_TYPE = 8
	BGP_ATTR_TYPE_ORIGINATOR_ID        BGP_ATTR_TYPE = 9
	BGP_ATTR_TYPE_CLUSTER_LIST         BGP_ATTR_TYPE = 10
	BGP_ATTR_TYPE_MP_REACH_NLRI        BGP_ATTR_TYPE = 14
	BGP_ATTR_TYPE_MP_UNREACH_NLRI      BGP_ATTR_TYPE = 15
	BGP_ATTR_TYPE_EXTENDED_COMMUNITIES BGP_ATTR_TYPE = 16
	BGP_ATTR_TYPE_AS4_PATH             BGP_ATTR_TYPE = 17
	BGP_ATTR_TYPE_AS4_AGGREGATOR       BGP_ATTR_TYPE = 18
	BGP_ATTR_TYPE_TUNNEL_ENCAP         BGP_ATTR_TYPE = 23
)

var BGP_ATTR_TYPE_name = map[int32]string{
	0:  "UNKNOWN_ATTR",
	1:  "ORIGIN",
	2:  "AS_PATH",
	3:  "NEXT_HOP",
	4:  "MULTI_EXIT_DISC",
	5:  "LOCAL_PREF",
	6:  "ATOMIC_AGGREGATE",
	7:  "AGGREGATOR",
	8:  "COMMUNITIES",
	9:  "ORIGINATOR_ID",
	10: "CLUSTER_LIST",
	14: "MP_REACH_NLRI",
	15: "MP_UNREACH_NLRI",
	16: "EXTENDED_COMMUNITIES",
	17: "AS4_PATH",
	18: "AS4_AGGREGATOR",
	23: "TUNNEL_ENCAP",
}
var BGP_ATTR_TYPE_value = map[string]int32{
	"UNKNOWN_ATTR":         0,
	"ORIGIN":               1,
	"AS_PATH":              2,
	"NEXT_HOP":             3,
	"MULTI_EXIT_DISC":      4,
	"LOCAL_PREF":           5,
	"ATOMIC_AGGREGATE":     6,
	"AGGREGATOR":           7,
	"COMMUNITIES":          8,
	"ORIGINATOR_ID":        9,
	"CLUSTER_LIST":         10,
	"MP_REACH_NLRI":        14,
	"MP_UNREACH_NLRI":      15,
	"EXTENDED_COMMUNITIES": 16,
	"AS4_PATH":             17,
	"AS4_AGGREGATOR":       18,
	"TUNNEL_ENCAP":         23,
}

func (x BGP_ATTR_TYPE) String() string {
	return proto.EnumName(BGP_ATTR_TYPE_name, int32(x))
}

type Error_ErrorCode int32

const (
	Error_SUCCESS Error_ErrorCode = 0
	Error_FAIL    Error_ErrorCode = 1
)

var Error_ErrorCode_name = map[int32]string{
	0: "SUCCESS",
	1: "FAIL",
}
var Error_ErrorCode_value = map[string]int32{
	"SUCCESS": 0,
	"FAIL":    1,
}

func (x Error_ErrorCode) String() string {
	return proto.EnumName(Error_ErrorCode_name, int32(x))
}

type Error struct {
	Code Error_ErrorCode `protobuf:"varint,1,opt,name=code,enum=api.Error_ErrorCode" json:"code,omitempty"`
	Msg  string          `protobuf:"bytes,2,opt,name=msg" json:"msg,omitempty"`
}

func (m *Error) Reset()         { *m = Error{} }
func (m *Error) String() string { return proto.CompactTextString(m) }
func (*Error) ProtoMessage()    {}

type Arguments struct {
	Resource Resource       `protobuf:"varint,1,opt,name=resource,enum=api.Resource" json:"resource,omitempty"`
	Af       *AddressFamily `protobuf:"bytes,2,opt,name=af" json:"af,omitempty"`
	RouterId string         `protobuf:"bytes,3,opt,name=router_id" json:"router_id,omitempty"`
}

func (m *Arguments) Reset()         { *m = Arguments{} }
func (m *Arguments) String() string { return proto.CompactTextString(m) }
func (*Arguments) ProtoMessage()    {}

func (m *Arguments) GetAf() *AddressFamily {
	if m != nil {
		return m.Af
	}
	return nil
}

type ModPathArguments struct {
	Resource Resource `protobuf:"varint,1,opt,name=resource,enum=api.Resource" json:"resource,omitempty"`
	Path     *Path    `protobuf:"bytes,2,opt,name=path" json:"path,omitempty"`
}

func (m *ModPathArguments) Reset()         { *m = ModPathArguments{} }
func (m *ModPathArguments) String() string { return proto.CompactTextString(m) }
func (*ModPathArguments) ProtoMessage()    {}

func (m *ModPathArguments) GetPath() *Path {
	if m != nil {
		return m.Path
	}
	return nil
}

type PolicyArguments struct {
	Resource         Resource          `protobuf:"varint,1,opt,name=resource,enum=api.Resource" json:"resource,omitempty"`
	Operation        Operation         `protobuf:"varint,2,opt,name=operation,enum=api.Operation" json:"operation,omitempty"`
	Name             string            `protobuf:"bytes,3,opt,name=name" json:"name,omitempty"`
	PrefixSet        *PrefixSet        `protobuf:"bytes,4,opt,name=prefix_set" json:"prefix_set,omitempty"`
	NeighborSet      *NeighborSet      `protobuf:"bytes,5,opt,name=neighbor_set" json:"neighbor_set,omitempty"`
	PolicyDifinition *PolicyDefinition `protobuf:"bytes,6,opt,name=policy_difinition" json:"policy_difinition,omitempty"`
}

func (m *PolicyArguments) Reset()         { *m = PolicyArguments{} }
func (m *PolicyArguments) String() string { return proto.CompactTextString(m) }
func (*PolicyArguments) ProtoMessage()    {}

func (m *PolicyArguments) GetPrefixSet() *PrefixSet {
	if m != nil {
		return m.PrefixSet
	}
	return nil
}

func (m *PolicyArguments) GetNeighborSet() *NeighborSet {
	if m != nil {
		return m.NeighborSet
	}
	return nil
}

func (m *PolicyArguments) GetPolicyDifinition() *PolicyDefinition {
	if m != nil {
		return m.PolicyDifinition
	}
	return nil
}

type AddressFamily struct {
	Afi  AFI  `protobuf:"varint,1,opt,enum=api.AFI" json:"Afi,omitempty"`
	Safi SAFI `protobuf:"varint,2,opt,enum=api.SAFI" json:"Safi,omitempty"`
}

func (m *AddressFamily) Reset()         { *m = AddressFamily{} }
func (m *AddressFamily) String() string { return proto.CompactTextString(m) }
func (*AddressFamily) ProtoMessage()    {}

type GracefulRestartTuple struct {
	Af    *AddressFamily `protobuf:"bytes,1,opt,name=af" json:"af,omitempty"`
	Flags uint32         `protobuf:"varint,2,opt,name=flags" json:"flags,omitempty"`
}

func (m *GracefulRestartTuple) Reset()         { *m = GracefulRestartTuple{} }
func (m *GracefulRestartTuple) String() string { return proto.CompactTextString(m) }
func (*GracefulRestartTuple) ProtoMessage()    {}

func (m *GracefulRestartTuple) GetAf() *AddressFamily {
	if m != nil {
		return m.Af
	}
	return nil
}

type GracefulRestart struct {
	Flags  uint32                  `protobuf:"varint,1,opt,name=flags" json:"flags,omitempty"`
	Time   uint32                  `protobuf:"varint,2,opt,name=time" json:"time,omitempty"`
	Tuples []*GracefulRestartTuple `protobuf:"bytes,3,rep,name=tuples" json:"tuples,omitempty"`
}

func (m *GracefulRestart) Reset()         { *m = GracefulRestart{} }
func (m *GracefulRestart) String() string { return proto.CompactTextString(m) }
func (*GracefulRestart) ProtoMessage()    {}

func (m *GracefulRestart) GetTuples() []*GracefulRestartTuple {
	if m != nil {
		return m.Tuples
	}
	return nil
}

type Capability struct {
	Code            BGP_CAPABILITY   `protobuf:"varint,1,opt,name=code,enum=api.BGP_CAPABILITY" json:"code,omitempty"`
	MultiProtocol   *AddressFamily   `protobuf:"bytes,2,opt,name=multi_protocol" json:"multi_protocol,omitempty"`
	GracefulRestart *GracefulRestart `protobuf:"bytes,3,opt,name=graceful_restart" json:"graceful_restart,omitempty"`
	Asn             uint32           `protobuf:"varint,4,opt,name=asn" json:"asn,omitempty"`
}

func (m *Capability) Reset()         { *m = Capability{} }
func (m *Capability) String() string { return proto.CompactTextString(m) }
func (*Capability) ProtoMessage()    {}

func (m *Capability) GetMultiProtocol() *AddressFamily {
	if m != nil {
		return m.MultiProtocol
	}
	return nil
}

func (m *Capability) GetGracefulRestart() *GracefulRestart {
	if m != nil {
		return m.GracefulRestart
	}
	return nil
}

type Aggregator struct {
	As      uint32 `protobuf:"varint,1,opt,name=as" json:"as,omitempty"`
	Address string `protobuf:"bytes,2,opt,name=address" json:"address,omitempty"`
}

func (m *Aggregator) Reset()         { *m = Aggregator{} }
func (m *Aggregator) String() string { return proto.CompactTextString(m) }
func (*Aggregator) ProtoMessage()    {}

type ExtendedCommunity struct {
	Type         EXTENDED_COMMUNITIE_TYPE    `protobuf:"varint,1,opt,name=type,enum=api.EXTENDED_COMMUNITIE_TYPE" json:"type,omitempty"`
	Subtype      EXTENDED_COMMUNITIE_SUBTYPE `protobuf:"varint,2,opt,name=subtype,enum=api.EXTENDED_COMMUNITIE_SUBTYPE" json:"subtype,omitempty"`
	IsTransitive bool                        `protobuf:"varint,3,opt,name=is_transitive" json:"is_transitive,omitempty"`
	Asn          uint32                      `protobuf:"varint,4,opt,name=asn" json:"asn,omitempty"`
	Ipv4         string                      `protobuf:"bytes,5,opt,name=ipv4" json:"ipv4,omitempty"`
	LocalAdmin   uint32                      `protobuf:"varint,6,opt,name=local_admin" json:"local_admin,omitempty"`
}

func (m *ExtendedCommunity) Reset()         { *m = ExtendedCommunity{} }
func (m *ExtendedCommunity) String() string { return proto.CompactTextString(m) }
func (*ExtendedCommunity) ProtoMessage()    {}

type EVPNNlri struct {
	Type EVPN_TYPE `protobuf:"varint,1,opt,name=type,enum=api.EVPN_TYPE" json:"type,omitempty"`
	//    EvpnAutoDiscoveryRoute = 2;
	MacIpAdv *EvpnMacIpAdvertisement `protobuf:"bytes,3,opt,name=mac_ip_adv" json:"mac_ip_adv,omitempty"`
}

func (m *EVPNNlri) Reset()         { *m = EVPNNlri{} }
func (m *EVPNNlri) String() string { return proto.CompactTextString(m) }
func (*EVPNNlri) ProtoMessage()    {}

func (m *EVPNNlri) GetMacIpAdv() *EvpnMacIpAdvertisement {
	if m != nil {
		return m.MacIpAdv
	}
	return nil
}

type EvpnMacIpAdvertisement struct {
	MacAddr    string   `protobuf:"bytes,1,opt,name=mac_addr" json:"mac_addr,omitempty"`
	MacAddrLen uint32   `protobuf:"varint,2,opt,name=mac_addr_len" json:"mac_addr_len,omitempty"`
	IpAddr     string   `protobuf:"bytes,3,opt,name=ip_addr" json:"ip_addr,omitempty"`
	IpAddrLen  uint32   `protobuf:"varint,4,opt,name=ip_addr_len" json:"ip_addr_len,omitempty"`
	Rd         string   `protobuf:"bytes,5,opt,name=rd" json:"rd,omitempty"`
	Esi        string   `protobuf:"bytes,6,opt,name=esi" json:"esi,omitempty"`
	Etag       uint32   `protobuf:"varint,7,opt,name=etag" json:"etag,omitempty"`
	Labels     []uint32 `protobuf:"varint,8,rep,name=labels" json:"labels,omitempty"`
}

func (m *EvpnMacIpAdvertisement) Reset()         { *m = EvpnMacIpAdvertisement{} }
func (m *EvpnMacIpAdvertisement) String() string { return proto.CompactTextString(m) }
func (*EvpnMacIpAdvertisement) ProtoMessage()    {}

type RTNlri struct {
	Asn    uint32             `protobuf:"varint,1,opt,name=asn" json:"asn,omitempty"`
	Target *ExtendedCommunity `protobuf:"bytes,2,opt,name=target" json:"target,omitempty"`
	Length uint32             `protobuf:"varint,3,opt,name=length" json:"length,omitempty"`
}

func (m *RTNlri) Reset()         { *m = RTNlri{} }
func (m *RTNlri) String() string { return proto.CompactTextString(m) }
func (*RTNlri) ProtoMessage()    {}

func (m *RTNlri) GetTarget() *ExtendedCommunity {
	if m != nil {
		return m.Target
	}
	return nil
}

type Nlri struct {
	Af       *AddressFamily `protobuf:"bytes,1,opt,name=af" json:"af,omitempty"`
	Prefix   string         `protobuf:"bytes,2,opt,name=prefix" json:"prefix,omitempty"`
	Nexthop  string         `protobuf:"bytes,3,opt,name=nexthop" json:"nexthop,omitempty"`
	EvpnNlri *EVPNNlri      `protobuf:"bytes,4,opt,name=evpn_nlri" json:"evpn_nlri,omitempty"`
	RtNlri   *RTNlri        `protobuf:"bytes,5,opt,name=rt_nlri" json:"rt_nlri,omitempty"`
}

func (m *Nlri) Reset()         { *m = Nlri{} }
func (m *Nlri) String() string { return proto.CompactTextString(m) }
func (*Nlri) ProtoMessage()    {}

func (m *Nlri) GetAf() *AddressFamily {
	if m != nil {
		return m.Af
	}
	return nil
}

func (m *Nlri) GetEvpnNlri() *EVPNNlri {
	if m != nil {
		return m.EvpnNlri
	}
	return nil
}

func (m *Nlri) GetRtNlri() *RTNlri {
	if m != nil {
		return m.RtNlri
	}
	return nil
}

type TunnelEncapSubTLV struct {
	Type     ENCAP_SUBTLV_TYPE `protobuf:"varint,1,opt,name=type,enum=api.ENCAP_SUBTLV_TYPE" json:"type,omitempty"`
	Value    string            `protobuf:"bytes,2,opt,name=value" json:"value,omitempty"`
	Key      uint32            `protobuf:"varint,3,opt,name=key" json:"key,omitempty"`
	Cookie   string            `protobuf:"bytes,4,opt,name=cookie" json:"cookie,omitempty"`
	Protocol uint32            `protobuf:"varint,5,opt,name=protocol" json:"protocol,omitempty"`
	Color    uint32            `protobuf:"varint,6,opt,name=color" json:"color,omitempty"`
}

func (m *TunnelEncapSubTLV) Reset()         { *m = TunnelEncapSubTLV{} }
func (m *TunnelEncapSubTLV) String() string { return proto.CompactTextString(m) }
func (*TunnelEncapSubTLV) ProtoMessage()    {}

type TunnelEncapTLV struct {
	Type   TUNNEL_TYPE          `protobuf:"varint,1,opt,name=type,enum=api.TUNNEL_TYPE" json:"type,omitempty"`
	SubTlv []*TunnelEncapSubTLV `protobuf:"bytes,2,rep,name=sub_tlv" json:"sub_tlv,omitempty"`
}

func (m *TunnelEncapTLV) Reset()         { *m = TunnelEncapTLV{} }
func (m *TunnelEncapTLV) String() string { return proto.CompactTextString(m) }
func (*TunnelEncapTLV) ProtoMessage()    {}

func (m *TunnelEncapTLV) GetSubTlv() []*TunnelEncapSubTLV {
	if m != nil {
		return m.SubTlv
	}
	return nil
}

type PathAttr struct {
	Type        BGP_ATTR_TYPE     `protobuf:"varint,1,opt,name=type,enum=api.BGP_ATTR_TYPE" json:"type,omitempty"`
	Value       []string          `protobuf:"bytes,2,rep,name=value" json:"value,omitempty"`
	Origin      Origin            `protobuf:"varint,3,opt,name=origin,enum=api.Origin" json:"origin,omitempty"`
	AsPath      []uint32          `protobuf:"varint,4,rep,name=as_path" json:"as_path,omitempty"`
	Nexthop     string            `protobuf:"bytes,5,opt,name=nexthop" json:"nexthop,omitempty"`
	Metric      uint32            `protobuf:"varint,6,opt,name=metric" json:"metric,omitempty"`
	Pref        uint32            `protobuf:"varint,7,opt,name=pref" json:"pref,omitempty"`
	Aggregator  *Aggregator       `protobuf:"bytes,8,opt,name=aggregator" json:"aggregator,omitempty"`
	Communites  []uint32          `protobuf:"varint,9,rep,name=communites" json:"communites,omitempty"`
	Originator  string            `protobuf:"bytes,10,opt,name=originator" json:"originator,omitempty"`
	Cluster     []string          `protobuf:"bytes,11,rep,name=cluster" json:"cluster,omitempty"`
	Nlri        []*Nlri           `protobuf:"bytes,12,rep,name=nlri" json:"nlri,omitempty"`
	TunnelEncap []*TunnelEncapTLV `protobuf:"bytes,13,rep,name=tunnel_encap" json:"tunnel_encap,omitempty"`
}

func (m *PathAttr) Reset()         { *m = PathAttr{} }
func (m *PathAttr) String() string { return proto.CompactTextString(m) }
func (*PathAttr) ProtoMessage()    {}

func (m *PathAttr) GetAggregator() *Aggregator {
	if m != nil {
		return m.Aggregator
	}
	return nil
}

func (m *PathAttr) GetNlri() []*Nlri {
	if m != nil {
		return m.Nlri
	}
	return nil
}

func (m *PathAttr) GetTunnelEncap() []*TunnelEncapTLV {
	if m != nil {
		return m.TunnelEncap
	}
	return nil
}

type Path struct {
	Nlri       *Nlri       `protobuf:"bytes,1,opt,name=nlri" json:"nlri,omitempty"`
	Nexthop    string      `protobuf:"bytes,2,opt,name=nexthop" json:"nexthop,omitempty"`
	Age        int64       `protobuf:"varint,3,opt,name=age" json:"age,omitempty"`
	Attrs      []*PathAttr `protobuf:"bytes,4,rep,name=attrs" json:"attrs,omitempty"`
	Best       bool        `protobuf:"varint,5,opt,name=best" json:"best,omitempty"`
	IsWithdraw bool        `protobuf:"varint,6,opt,name=is_withdraw" json:"is_withdraw,omitempty"`
}

func (m *Path) Reset()         { *m = Path{} }
func (m *Path) String() string { return proto.CompactTextString(m) }
func (*Path) ProtoMessage()    {}

func (m *Path) GetNlri() *Nlri {
	if m != nil {
		return m.Nlri
	}
	return nil
}

func (m *Path) GetAttrs() []*PathAttr {
	if m != nil {
		return m.Attrs
	}
	return nil
}

type Destination struct {
	Prefix      string  `protobuf:"bytes,1,opt,name=prefix" json:"prefix,omitempty"`
	Paths       []*Path `protobuf:"bytes,2,rep,name=paths" json:"paths,omitempty"`
	BestPathIdx uint32  `protobuf:"varint,3,opt,name=best_path_idx" json:"best_path_idx,omitempty"`
}

func (m *Destination) Reset()         { *m = Destination{} }
func (m *Destination) String() string { return proto.CompactTextString(m) }
func (*Destination) ProtoMessage()    {}

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

type PeerConf struct {
	RemoteIp           string        `protobuf:"bytes,1,opt,name=remote_ip" json:"remote_ip,omitempty"`
	Id                 string        `protobuf:"bytes,2,opt,name=id" json:"id,omitempty"`
	RemoteAs           uint32        `protobuf:"varint,3,opt,name=remote_as" json:"remote_as,omitempty"`
	CapRefresh         bool          `protobuf:"varint,4,opt,name=cap_refresh" json:"cap_refresh,omitempty"`
	CapEnhancedRefresh bool          `protobuf:"varint,5,opt,name=cap_enhanced_refresh" json:"cap_enhanced_refresh,omitempty"`
	RemoteCap          []*Capability `protobuf:"bytes,6,rep,name=remote_cap" json:"remote_cap,omitempty"`
	LocalCap           []*Capability `protobuf:"bytes,7,rep,name=local_cap" json:"local_cap,omitempty"`
	Holdtime           uint32        `protobuf:"varint,8,opt,name=holdtime" json:"holdtime,omitempty"`
	KeepaliveInterval  uint32        `protobuf:"varint,9,opt,name=keepalive_interval" json:"keepalive_interval,omitempty"`
}

func (m *PeerConf) Reset()         { *m = PeerConf{} }
func (m *PeerConf) String() string { return proto.CompactTextString(m) }
func (*PeerConf) ProtoMessage()    {}

func (m *PeerConf) GetRemoteCap() []*Capability {
	if m != nil {
		return m.RemoteCap
	}
	return nil
}

func (m *PeerConf) GetLocalCap() []*Capability {
	if m != nil {
		return m.LocalCap
	}
	return nil
}

type PeerInfo struct {
	BgpState                  string `protobuf:"bytes,1,opt,name=bgp_state" json:"bgp_state,omitempty"`
	AdminState                string `protobuf:"bytes,2,opt,name=admin_state" json:"admin_state,omitempty"`
	FsmEstablishedTransitions uint32 `protobuf:"varint,3,opt,name=fsm_established_transitions" json:"fsm_established_transitions,omitempty"`
	TotalMessageOut           uint32 `protobuf:"varint,4,opt,name=total_message_out" json:"total_message_out,omitempty"`
	TotalMessageIn            uint32 `protobuf:"varint,5,opt,name=total_message_in" json:"total_message_in,omitempty"`
	UpdateMessageOut          uint32 `protobuf:"varint,6,opt,name=update_message_out" json:"update_message_out,omitempty"`
	UpdateMessageIn           uint32 `protobuf:"varint,7,opt,name=update_message_in" json:"update_message_in,omitempty"`
	KeepAliveMessageOut       uint32 `protobuf:"varint,8,opt,name=keep_alive_message_out" json:"keep_alive_message_out,omitempty"`
	KeepAliveMessageIn        uint32 `protobuf:"varint,9,opt,name=keep_alive_message_in" json:"keep_alive_message_in,omitempty"`
	OpenMessageOut            uint32 `protobuf:"varint,10,opt,name=open_message_out" json:"open_message_out,omitempty"`
	OpenMessageIn             uint32 `protobuf:"varint,11,opt,name=open_message_in" json:"open_message_in,omitempty"`
	NotificationOut           uint32 `protobuf:"varint,12,opt,name=notification_out" json:"notification_out,omitempty"`
	NotificationIn            uint32 `protobuf:"varint,13,opt,name=notification_in" json:"notification_in,omitempty"`
	RefreshMessageOut         uint32 `protobuf:"varint,14,opt,name=refresh_message_out" json:"refresh_message_out,omitempty"`
	RefreshMessageIn          uint32 `protobuf:"varint,15,opt,name=refresh_message_in" json:"refresh_message_in,omitempty"`
	DiscardedOut              uint32 `protobuf:"varint,16,opt,name=discarded_out" json:"discarded_out,omitempty"`
	DiscardedIn               uint32 `protobuf:"varint,17,opt,name=discarded_in" json:"discarded_in,omitempty"`
	Uptime                    int64  `protobuf:"varint,18,opt,name=uptime" json:"uptime,omitempty"`
	Downtime                  int64  `protobuf:"varint,19,opt,name=downtime" json:"downtime,omitempty"`
	LastError                 string `protobuf:"bytes,20,opt,name=last_error" json:"last_error,omitempty"`
	Received                  uint32 `protobuf:"varint,21,opt,name=received" json:"received,omitempty"`
	Accepted                  uint32 `protobuf:"varint,22,opt,name=accepted" json:"accepted,omitempty"`
	Advertized                uint32 `protobuf:"varint,23,opt,name=advertized" json:"advertized,omitempty"`
	OutQ                      uint32 `protobuf:"varint,24,opt,name=out_q" json:"out_q,omitempty"`
	Flops                     uint32 `protobuf:"varint,25,opt,name=flops" json:"flops,omitempty"`
	NegotiatedHoldtime        uint32 `protobuf:"varint,26,opt,name=negotiated_holdtime" json:"negotiated_holdtime,omitempty"`
	KeepaliveInterval         uint32 `protobuf:"varint,27,opt,name=keepalive_interval" json:"keepalive_interval,omitempty"`
}

func (m *PeerInfo) Reset()         { *m = PeerInfo{} }
func (m *PeerInfo) String() string { return proto.CompactTextString(m) }
func (*PeerInfo) ProtoMessage()    {}

type Peer struct {
	Conf *PeerConf `protobuf:"bytes,1,opt,name=conf" json:"conf,omitempty"`
	Info *PeerInfo `protobuf:"bytes,2,opt,name=info" json:"info,omitempty"`
}

func (m *Peer) Reset()         { *m = Peer{} }
func (m *Peer) String() string { return proto.CompactTextString(m) }
func (*Peer) ProtoMessage()    {}

func (m *Peer) GetConf() *PeerConf {
	if m != nil {
		return m.Conf
	}
	return nil
}

func (m *Peer) GetInfo() *PeerInfo {
	if m != nil {
		return m.Info
	}
	return nil
}

type Prefix struct {
	Address         string `protobuf:"bytes,1,opt,name=address" json:"address,omitempty"`
	MaskLength      uint32 `protobuf:"varint,2,opt,name=mask_length" json:"mask_length,omitempty"`
	MaskLengthRange string `protobuf:"bytes,3,opt,name=mask_length_range" json:"mask_length_range,omitempty"`
}

func (m *Prefix) Reset()         { *m = Prefix{} }
func (m *Prefix) String() string { return proto.CompactTextString(m) }
func (*Prefix) ProtoMessage()    {}

type PrefixSet struct {
	PrefixSetName string    `protobuf:"bytes,1,opt,name=prefix_set_name" json:"prefix_set_name,omitempty"`
	PrefixList    []*Prefix `protobuf:"bytes,2,rep,name=prefix_list" json:"prefix_list,omitempty"`
}

func (m *PrefixSet) Reset()         { *m = PrefixSet{} }
func (m *PrefixSet) String() string { return proto.CompactTextString(m) }
func (*PrefixSet) ProtoMessage()    {}

func (m *PrefixSet) GetPrefixList() []*Prefix {
	if m != nil {
		return m.PrefixList
	}
	return nil
}

type Neighbor struct {
	Address string `protobuf:"bytes,1,opt,name=address" json:"address,omitempty"`
}

func (m *Neighbor) Reset()         { *m = Neighbor{} }
func (m *Neighbor) String() string { return proto.CompactTextString(m) }
func (*Neighbor) ProtoMessage()    {}

type NeighborSet struct {
	NeighborSetName string      `protobuf:"bytes,1,opt,name=neighbor_set_name" json:"neighbor_set_name,omitempty"`
	NeighborList    []*Neighbor `protobuf:"bytes,2,rep,name=neighbor_list" json:"neighbor_list,omitempty"`
}

func (m *NeighborSet) Reset()         { *m = NeighborSet{} }
func (m *NeighborSet) String() string { return proto.CompactTextString(m) }
func (*NeighborSet) ProtoMessage()    {}

func (m *NeighborSet) GetNeighborList() []*Neighbor {
	if m != nil {
		return m.NeighborList
	}
	return nil
}

type AsPathLength struct {
	Value    string `protobuf:"bytes,1,opt,name=value" json:"value,omitempty"`
	Operator string `protobuf:"bytes,2,opt,name=operator" json:"operator,omitempty"`
}

func (m *AsPathLength) Reset()         { *m = AsPathLength{} }
func (m *AsPathLength) String() string { return proto.CompactTextString(m) }
func (*AsPathLength) ProtoMessage()    {}

type Conditions struct {
	MatchPrefixSet    *PrefixSet    `protobuf:"bytes,1,opt,name=match_prefix_set" json:"match_prefix_set,omitempty"`
	MatchNeighborSet  *NeighborSet  `protobuf:"bytes,2,opt,name=match_neighbor_set" json:"match_neighbor_set,omitempty"`
	MatchAsPathLength *AsPathLength `protobuf:"bytes,3,opt,name=match_as_path_length" json:"match_as_path_length,omitempty"`
	MatchSetOptions   int64         `protobuf:"varint,4,opt,name=match_set_options" json:"match_set_options,omitempty"`
}

func (m *Conditions) Reset()         { *m = Conditions{} }
func (m *Conditions) String() string { return proto.CompactTextString(m) }
func (*Conditions) ProtoMessage()    {}

func (m *Conditions) GetMatchPrefixSet() *PrefixSet {
	if m != nil {
		return m.MatchPrefixSet
	}
	return nil
}

func (m *Conditions) GetMatchNeighborSet() *NeighborSet {
	if m != nil {
		return m.MatchNeighborSet
	}
	return nil
}

func (m *Conditions) GetMatchAsPathLength() *AsPathLength {
	if m != nil {
		return m.MatchAsPathLength
	}
	return nil
}

type Actions struct {
	AcceptRoute bool `protobuf:"varint,1,opt,name=accept_route" json:"accept_route,omitempty"`
	RejectRoute bool `protobuf:"varint,2,opt,name=reject_route" json:"reject_route,omitempty"`
}

func (m *Actions) Reset()         { *m = Actions{} }
func (m *Actions) String() string { return proto.CompactTextString(m) }
func (*Actions) ProtoMessage()    {}

type Statement struct {
	StatementNeme string      `protobuf:"bytes,1,opt,name=statement_neme" json:"statement_neme,omitempty"`
	Conditions    *Conditions `protobuf:"bytes,2,opt,name=conditions" json:"conditions,omitempty"`
	Actions       *Actions    `protobuf:"bytes,3,opt,name=actions" json:"actions,omitempty"`
}

func (m *Statement) Reset()         { *m = Statement{} }
func (m *Statement) String() string { return proto.CompactTextString(m) }
func (*Statement) ProtoMessage()    {}

func (m *Statement) GetConditions() *Conditions {
	if m != nil {
		return m.Conditions
	}
	return nil
}

func (m *Statement) GetActions() *Actions {
	if m != nil {
		return m.Actions
	}
	return nil
}

type PolicyDefinition struct {
	PolicyDefinitionName string       `protobuf:"bytes,1,opt,name=policy_definition_name" json:"policy_definition_name,omitempty"`
	StatementList        []*Statement `protobuf:"bytes,2,rep,name=statement_list" json:"statement_list,omitempty"`
}

func (m *PolicyDefinition) Reset()         { *m = PolicyDefinition{} }
func (m *PolicyDefinition) String() string { return proto.CompactTextString(m) }
func (*PolicyDefinition) ProtoMessage()    {}

func (m *PolicyDefinition) GetStatementList() []*Statement {
	if m != nil {
		return m.StatementList
	}
	return nil
}

type RoutingPolicy struct {
	PolicyDifinition []*PolicyDefinition `protobuf:"bytes,1,rep,name=policy_difinition" json:"policy_difinition,omitempty"`
}

func (m *RoutingPolicy) Reset()         { *m = RoutingPolicy{} }
func (m *RoutingPolicy) String() string { return proto.CompactTextString(m) }
func (*RoutingPolicy) ProtoMessage()    {}

func (m *RoutingPolicy) GetPolicyDifinition() []*PolicyDefinition {
	if m != nil {
		return m.PolicyDifinition
	}
	return nil
}

type ApplyPolicy struct {
	ImportPolicies      []*PolicyDefinition `protobuf:"bytes,1,rep,name=import_policies" json:"import_policies,omitempty"`
	DefaultImportPolicy int64               `protobuf:"varint,2,opt,name=default_import_policy" json:"default_import_policy,omitempty"`
	ExportPolicies      []*PolicyDefinition `protobuf:"bytes,3,rep,name=export_policies" json:"export_policies,omitempty"`
	DefaultExportPolicy int64               `protobuf:"varint,4,opt,name=default_export_policy" json:"default_export_policy,omitempty"`
}

func (m *ApplyPolicy) Reset()         { *m = ApplyPolicy{} }
func (m *ApplyPolicy) String() string { return proto.CompactTextString(m) }
func (*ApplyPolicy) ProtoMessage()    {}

func (m *ApplyPolicy) GetImportPolicies() []*PolicyDefinition {
	if m != nil {
		return m.ImportPolicies
	}
	return nil
}

func (m *ApplyPolicy) GetExportPolicies() []*PolicyDefinition {
	if m != nil {
		return m.ExportPolicies
	}
	return nil
}

func init() {
	proto.RegisterEnum("api.Resource", Resource_name, Resource_value)
	proto.RegisterEnum("api.Operation", Operation_name, Operation_value)
	proto.RegisterEnum("api.AFI", AFI_name, AFI_value)
	proto.RegisterEnum("api.SAFI", SAFI_name, SAFI_value)
	proto.RegisterEnum("api.BGP_CAPABILITY", BGP_CAPABILITY_name, BGP_CAPABILITY_value)
	proto.RegisterEnum("api.Origin", Origin_name, Origin_value)
	proto.RegisterEnum("api.EXTENDED_COMMUNITIE_TYPE", EXTENDED_COMMUNITIE_TYPE_name, EXTENDED_COMMUNITIE_TYPE_value)
	proto.RegisterEnum("api.EXTENDED_COMMUNITIE_SUBTYPE", EXTENDED_COMMUNITIE_SUBTYPE_name, EXTENDED_COMMUNITIE_SUBTYPE_value)
	proto.RegisterEnum("api.TUNNEL_TYPE", TUNNEL_TYPE_name, TUNNEL_TYPE_value)
	proto.RegisterEnum("api.EVPN_TYPE", EVPN_TYPE_name, EVPN_TYPE_value)
	proto.RegisterEnum("api.ENCAP_SUBTLV_TYPE", ENCAP_SUBTLV_TYPE_name, ENCAP_SUBTLV_TYPE_value)
	proto.RegisterEnum("api.BGP_ATTR_TYPE", BGP_ATTR_TYPE_name, BGP_ATTR_TYPE_value)
	proto.RegisterEnum("api.Error_ErrorCode", Error_ErrorCode_name, Error_ErrorCode_value)
}

// Client API for Grpc service

type GrpcClient interface {
	GetNeighbors(ctx context.Context, in *Arguments, opts ...grpc.CallOption) (Grpc_GetNeighborsClient, error)
	GetNeighbor(ctx context.Context, in *Arguments, opts ...grpc.CallOption) (*Peer, error)
	GetRib(ctx context.Context, in *Arguments, opts ...grpc.CallOption) (Grpc_GetRibClient, error)
	GetAdjRib(ctx context.Context, in *Arguments, opts ...grpc.CallOption) (Grpc_GetAdjRibClient, error)
	Reset(ctx context.Context, in *Arguments, opts ...grpc.CallOption) (*Error, error)
	SoftReset(ctx context.Context, in *Arguments, opts ...grpc.CallOption) (*Error, error)
	SoftResetIn(ctx context.Context, in *Arguments, opts ...grpc.CallOption) (*Error, error)
	SoftResetOut(ctx context.Context, in *Arguments, opts ...grpc.CallOption) (*Error, error)
	Shutdown(ctx context.Context, in *Arguments, opts ...grpc.CallOption) (*Error, error)
	Enable(ctx context.Context, in *Arguments, opts ...grpc.CallOption) (*Error, error)
	Disable(ctx context.Context, in *Arguments, opts ...grpc.CallOption) (*Error, error)
	ModPath(ctx context.Context, opts ...grpc.CallOption) (Grpc_ModPathClient, error)
	GetNeighborPolicy(ctx context.Context, in *Arguments, opts ...grpc.CallOption) (*ApplyPolicy, error)
	GetPolicyPrefixes(ctx context.Context, in *PolicyArguments, opts ...grpc.CallOption) (Grpc_GetPolicyPrefixesClient, error)
	GetPolicyPrefix(ctx context.Context, in *PolicyArguments, opts ...grpc.CallOption) (*PrefixSet, error)
	ModPolicyPrefix(ctx context.Context, opts ...grpc.CallOption) (Grpc_ModPolicyPrefixClient, error)
	GetPolicyNeighbors(ctx context.Context, in *PolicyArguments, opts ...grpc.CallOption) (Grpc_GetPolicyNeighborsClient, error)
	GetPolicyNeighbor(ctx context.Context, in *PolicyArguments, opts ...grpc.CallOption) (*NeighborSet, error)
	GetPolicyRoutePolicies(ctx context.Context, in *PolicyArguments, opts ...grpc.CallOption) (Grpc_GetPolicyRoutePoliciesClient, error)
	GetPolicyRoutePolicy(ctx context.Context, in *PolicyArguments, opts ...grpc.CallOption) (*PolicyDefinition, error)
}

type grpcClient struct {
	cc *grpc.ClientConn
}

func NewGrpcClient(cc *grpc.ClientConn) GrpcClient {
	return &grpcClient{cc}
}

func (c *grpcClient) GetNeighbors(ctx context.Context, in *Arguments, opts ...grpc.CallOption) (Grpc_GetNeighborsClient, error) {
	stream, err := grpc.NewClientStream(ctx, &_Grpc_serviceDesc.Streams[0], c.cc, "/api.Grpc/GetNeighbors", opts...)
	if err != nil {
		return nil, err
	}
	x := &grpcGetNeighborsClient{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 Grpc_GetNeighborsClient interface {
	Recv() (*Peer, error)
	grpc.ClientStream
}

type grpcGetNeighborsClient struct {
	grpc.ClientStream
}

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

func (c *grpcClient) GetNeighbor(ctx context.Context, in *Arguments, opts ...grpc.CallOption) (*Peer, error) {
	out := new(Peer)
	err := grpc.Invoke(ctx, "/api.Grpc/GetNeighbor", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *grpcClient) GetRib(ctx context.Context, in *Arguments, opts ...grpc.CallOption) (Grpc_GetRibClient, error) {
	stream, err := grpc.NewClientStream(ctx, &_Grpc_serviceDesc.Streams[1], c.cc, "/api.Grpc/GetRib", opts...)
	if err != nil {
		return nil, err
	}
	x := &grpcGetRibClient{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 Grpc_GetRibClient interface {
	Recv() (*Destination, error)
	grpc.ClientStream
}

type grpcGetRibClient struct {
	grpc.ClientStream
}

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

func (c *grpcClient) GetAdjRib(ctx context.Context, in *Arguments, opts ...grpc.CallOption) (Grpc_GetAdjRibClient, error) {
	stream, err := grpc.NewClientStream(ctx, &_Grpc_serviceDesc.Streams[2], c.cc, "/api.Grpc/GetAdjRib", opts...)
	if err != nil {
		return nil, err
	}
	x := &grpcGetAdjRibClient{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 Grpc_GetAdjRibClient interface {
	Recv() (*Path, error)
	grpc.ClientStream
}

type grpcGetAdjRibClient struct {
	grpc.ClientStream
}

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

func (c *grpcClient) Reset(ctx context.Context, in *Arguments, opts ...grpc.CallOption) (*Error, error) {
	out := new(Error)
	err := grpc.Invoke(ctx, "/api.Grpc/Reset", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *grpcClient) SoftReset(ctx context.Context, in *Arguments, opts ...grpc.CallOption) (*Error, error) {
	out := new(Error)
	err := grpc.Invoke(ctx, "/api.Grpc/SoftReset", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *grpcClient) SoftResetIn(ctx context.Context, in *Arguments, opts ...grpc.CallOption) (*Error, error) {
	out := new(Error)
	err := grpc.Invoke(ctx, "/api.Grpc/SoftResetIn", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *grpcClient) SoftResetOut(ctx context.Context, in *Arguments, opts ...grpc.CallOption) (*Error, error) {
	out := new(Error)
	err := grpc.Invoke(ctx, "/api.Grpc/SoftResetOut", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *grpcClient) Shutdown(ctx context.Context, in *Arguments, opts ...grpc.CallOption) (*Error, error) {
	out := new(Error)
	err := grpc.Invoke(ctx, "/api.Grpc/Shutdown", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *grpcClient) Enable(ctx context.Context, in *Arguments, opts ...grpc.CallOption) (*Error, error) {
	out := new(Error)
	err := grpc.Invoke(ctx, "/api.Grpc/Enable", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *grpcClient) Disable(ctx context.Context, in *Arguments, opts ...grpc.CallOption) (*Error, error) {
	out := new(Error)
	err := grpc.Invoke(ctx, "/api.Grpc/Disable", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *grpcClient) ModPath(ctx context.Context, opts ...grpc.CallOption) (Grpc_ModPathClient, error) {
	stream, err := grpc.NewClientStream(ctx, &_Grpc_serviceDesc.Streams[3], c.cc, "/api.Grpc/ModPath", opts...)
	if err != nil {
		return nil, err
	}
	x := &grpcModPathClient{stream}
	return x, nil
}

type Grpc_ModPathClient interface {
	Send(*ModPathArguments) error
	Recv() (*Error, error)
	grpc.ClientStream
}

type grpcModPathClient struct {
	grpc.ClientStream
}

func (x *grpcModPathClient) Send(m *ModPathArguments) error {
	return x.ClientStream.SendMsg(m)
}

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

func (c *grpcClient) GetNeighborPolicy(ctx context.Context, in *Arguments, opts ...grpc.CallOption) (*ApplyPolicy, error) {
	out := new(ApplyPolicy)
	err := grpc.Invoke(ctx, "/api.Grpc/GetNeighborPolicy", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *grpcClient) GetPolicyPrefixes(ctx context.Context, in *PolicyArguments, opts ...grpc.CallOption) (Grpc_GetPolicyPrefixesClient, error) {
	stream, err := grpc.NewClientStream(ctx, &_Grpc_serviceDesc.Streams[4], c.cc, "/api.Grpc/GetPolicyPrefixes", opts...)
	if err != nil {
		return nil, err
	}
	x := &grpcGetPolicyPrefixesClient{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 Grpc_GetPolicyPrefixesClient interface {
	Recv() (*PrefixSet, error)
	grpc.ClientStream
}

type grpcGetPolicyPrefixesClient struct {
	grpc.ClientStream
}

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

func (c *grpcClient) GetPolicyPrefix(ctx context.Context, in *PolicyArguments, opts ...grpc.CallOption) (*PrefixSet, error) {
	out := new(PrefixSet)
	err := grpc.Invoke(ctx, "/api.Grpc/GetPolicyPrefix", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *grpcClient) ModPolicyPrefix(ctx context.Context, opts ...grpc.CallOption) (Grpc_ModPolicyPrefixClient, error) {
	stream, err := grpc.NewClientStream(ctx, &_Grpc_serviceDesc.Streams[5], c.cc, "/api.Grpc/ModPolicyPrefix", opts...)
	if err != nil {
		return nil, err
	}
	x := &grpcModPolicyPrefixClient{stream}
	return x, nil
}

type Grpc_ModPolicyPrefixClient interface {
	Send(*PolicyArguments) error
	Recv() (*Error, error)
	grpc.ClientStream
}

type grpcModPolicyPrefixClient struct {
	grpc.ClientStream
}

func (x *grpcModPolicyPrefixClient) Send(m *PolicyArguments) error {
	return x.ClientStream.SendMsg(m)
}

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

func (c *grpcClient) GetPolicyNeighbors(ctx context.Context, in *PolicyArguments, opts ...grpc.CallOption) (Grpc_GetPolicyNeighborsClient, error) {
	stream, err := grpc.NewClientStream(ctx, &_Grpc_serviceDesc.Streams[6], c.cc, "/api.Grpc/GetPolicyNeighbors", opts...)
	if err != nil {
		return nil, err
	}
	x := &grpcGetPolicyNeighborsClient{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 Grpc_GetPolicyNeighborsClient interface {
	Recv() (*NeighborSet, error)
	grpc.ClientStream
}

type grpcGetPolicyNeighborsClient struct {
	grpc.ClientStream
}

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

func (c *grpcClient) GetPolicyNeighbor(ctx context.Context, in *PolicyArguments, opts ...grpc.CallOption) (*NeighborSet, error) {
	out := new(NeighborSet)
	err := grpc.Invoke(ctx, "/api.Grpc/GetPolicyNeighbor", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *grpcClient) GetPolicyRoutePolicies(ctx context.Context, in *PolicyArguments, opts ...grpc.CallOption) (Grpc_GetPolicyRoutePoliciesClient, error) {
	stream, err := grpc.NewClientStream(ctx, &_Grpc_serviceDesc.Streams[7], c.cc, "/api.Grpc/GetPolicyRoutePolicies", opts...)
	if err != nil {
		return nil, err
	}
	x := &grpcGetPolicyRoutePoliciesClient{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 Grpc_GetPolicyRoutePoliciesClient interface {
	Recv() (*PolicyDefinition, error)
	grpc.ClientStream
}

type grpcGetPolicyRoutePoliciesClient struct {
	grpc.ClientStream
}

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

func (c *grpcClient) GetPolicyRoutePolicy(ctx context.Context, in *PolicyArguments, opts ...grpc.CallOption) (*PolicyDefinition, error) {
	out := new(PolicyDefinition)
	err := grpc.Invoke(ctx, "/api.Grpc/GetPolicyRoutePolicy", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// Server API for Grpc service

type GrpcServer interface {
	GetNeighbors(*Arguments, Grpc_GetNeighborsServer) error
	GetNeighbor(context.Context, *Arguments) (*Peer, error)
	GetRib(*Arguments, Grpc_GetRibServer) error
	GetAdjRib(*Arguments, Grpc_GetAdjRibServer) error
	Reset(context.Context, *Arguments) (*Error, error)
	SoftReset(context.Context, *Arguments) (*Error, error)
	SoftResetIn(context.Context, *Arguments) (*Error, error)
	SoftResetOut(context.Context, *Arguments) (*Error, error)
	Shutdown(context.Context, *Arguments) (*Error, error)
	Enable(context.Context, *Arguments) (*Error, error)
	Disable(context.Context, *Arguments) (*Error, error)
	ModPath(Grpc_ModPathServer) error
	GetNeighborPolicy(context.Context, *Arguments) (*ApplyPolicy, error)
	GetPolicyPrefixes(*PolicyArguments, Grpc_GetPolicyPrefixesServer) error
	GetPolicyPrefix(context.Context, *PolicyArguments) (*PrefixSet, error)
	ModPolicyPrefix(Grpc_ModPolicyPrefixServer) error
	GetPolicyNeighbors(*PolicyArguments, Grpc_GetPolicyNeighborsServer) error
	GetPolicyNeighbor(context.Context, *PolicyArguments) (*NeighborSet, error)
	GetPolicyRoutePolicies(*PolicyArguments, Grpc_GetPolicyRoutePoliciesServer) error
	GetPolicyRoutePolicy(context.Context, *PolicyArguments) (*PolicyDefinition, error)
}

func RegisterGrpcServer(s *grpc.Server, srv GrpcServer) {
	s.RegisterService(&_Grpc_serviceDesc, srv)
}

func _Grpc_GetNeighbors_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(Arguments)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(GrpcServer).GetNeighbors(m, &grpcGetNeighborsServer{stream})
}

type Grpc_GetNeighborsServer interface {
	Send(*Peer) error
	grpc.ServerStream
}

type grpcGetNeighborsServer struct {
	grpc.ServerStream
}

func (x *grpcGetNeighborsServer) Send(m *Peer) error {
	return x.ServerStream.SendMsg(m)
}

func _Grpc_GetNeighbor_Handler(srv interface{}, ctx context.Context, codec grpc.Codec, buf []byte) (interface{}, error) {
	in := new(Arguments)
	if err := codec.Unmarshal(buf, in); err != nil {
		return nil, err
	}
	out, err := srv.(GrpcServer).GetNeighbor(ctx, in)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func _Grpc_GetRib_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(Arguments)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(GrpcServer).GetRib(m, &grpcGetRibServer{stream})
}

type Grpc_GetRibServer interface {
	Send(*Destination) error
	grpc.ServerStream
}

type grpcGetRibServer struct {
	grpc.ServerStream
}

func (x *grpcGetRibServer) Send(m *Destination) error {
	return x.ServerStream.SendMsg(m)
}

func _Grpc_GetAdjRib_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(Arguments)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(GrpcServer).GetAdjRib(m, &grpcGetAdjRibServer{stream})
}

type Grpc_GetAdjRibServer interface {
	Send(*Path) error
	grpc.ServerStream
}

type grpcGetAdjRibServer struct {
	grpc.ServerStream
}

func (x *grpcGetAdjRibServer) Send(m *Path) error {
	return x.ServerStream.SendMsg(m)
}

func _Grpc_Reset_Handler(srv interface{}, ctx context.Context, codec grpc.Codec, buf []byte) (interface{}, error) {
	in := new(Arguments)
	if err := codec.Unmarshal(buf, in); err != nil {
		return nil, err
	}
	out, err := srv.(GrpcServer).Reset(ctx, in)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func _Grpc_SoftReset_Handler(srv interface{}, ctx context.Context, codec grpc.Codec, buf []byte) (interface{}, error) {
	in := new(Arguments)
	if err := codec.Unmarshal(buf, in); err != nil {
		return nil, err
	}
	out, err := srv.(GrpcServer).SoftReset(ctx, in)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func _Grpc_SoftResetIn_Handler(srv interface{}, ctx context.Context, codec grpc.Codec, buf []byte) (interface{}, error) {
	in := new(Arguments)
	if err := codec.Unmarshal(buf, in); err != nil {
		return nil, err
	}
	out, err := srv.(GrpcServer).SoftResetIn(ctx, in)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func _Grpc_SoftResetOut_Handler(srv interface{}, ctx context.Context, codec grpc.Codec, buf []byte) (interface{}, error) {
	in := new(Arguments)
	if err := codec.Unmarshal(buf, in); err != nil {
		return nil, err
	}
	out, err := srv.(GrpcServer).SoftResetOut(ctx, in)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func _Grpc_Shutdown_Handler(srv interface{}, ctx context.Context, codec grpc.Codec, buf []byte) (interface{}, error) {
	in := new(Arguments)
	if err := codec.Unmarshal(buf, in); err != nil {
		return nil, err
	}
	out, err := srv.(GrpcServer).Shutdown(ctx, in)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func _Grpc_Enable_Handler(srv interface{}, ctx context.Context, codec grpc.Codec, buf []byte) (interface{}, error) {
	in := new(Arguments)
	if err := codec.Unmarshal(buf, in); err != nil {
		return nil, err
	}
	out, err := srv.(GrpcServer).Enable(ctx, in)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func _Grpc_Disable_Handler(srv interface{}, ctx context.Context, codec grpc.Codec, buf []byte) (interface{}, error) {
	in := new(Arguments)
	if err := codec.Unmarshal(buf, in); err != nil {
		return nil, err
	}
	out, err := srv.(GrpcServer).Disable(ctx, in)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func _Grpc_ModPath_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(GrpcServer).ModPath(&grpcModPathServer{stream})
}

type Grpc_ModPathServer interface {
	Send(*Error) error
	Recv() (*ModPathArguments, error)
	grpc.ServerStream
}

type grpcModPathServer struct {
	grpc.ServerStream
}

func (x *grpcModPathServer) Send(m *Error) error {
	return x.ServerStream.SendMsg(m)
}

func (x *grpcModPathServer) Recv() (*ModPathArguments, error) {
	m := new(ModPathArguments)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _Grpc_GetNeighborPolicy_Handler(srv interface{}, ctx context.Context, codec grpc.Codec, buf []byte) (interface{}, error) {
	in := new(Arguments)
	if err := codec.Unmarshal(buf, in); err != nil {
		return nil, err
	}
	out, err := srv.(GrpcServer).GetNeighborPolicy(ctx, in)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func _Grpc_GetPolicyPrefixes_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(PolicyArguments)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(GrpcServer).GetPolicyPrefixes(m, &grpcGetPolicyPrefixesServer{stream})
}

type Grpc_GetPolicyPrefixesServer interface {
	Send(*PrefixSet) error
	grpc.ServerStream
}

type grpcGetPolicyPrefixesServer struct {
	grpc.ServerStream
}

func (x *grpcGetPolicyPrefixesServer) Send(m *PrefixSet) error {
	return x.ServerStream.SendMsg(m)
}

func _Grpc_GetPolicyPrefix_Handler(srv interface{}, ctx context.Context, codec grpc.Codec, buf []byte) (interface{}, error) {
	in := new(PolicyArguments)
	if err := codec.Unmarshal(buf, in); err != nil {
		return nil, err
	}
	out, err := srv.(GrpcServer).GetPolicyPrefix(ctx, in)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func _Grpc_ModPolicyPrefix_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(GrpcServer).ModPolicyPrefix(&grpcModPolicyPrefixServer{stream})
}

type Grpc_ModPolicyPrefixServer interface {
	Send(*Error) error
	Recv() (*PolicyArguments, error)
	grpc.ServerStream
}

type grpcModPolicyPrefixServer struct {
	grpc.ServerStream
}

func (x *grpcModPolicyPrefixServer) Send(m *Error) error {
	return x.ServerStream.SendMsg(m)
}

func (x *grpcModPolicyPrefixServer) Recv() (*PolicyArguments, error) {
	m := new(PolicyArguments)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _Grpc_GetPolicyNeighbors_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(PolicyArguments)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(GrpcServer).GetPolicyNeighbors(m, &grpcGetPolicyNeighborsServer{stream})
}

type Grpc_GetPolicyNeighborsServer interface {
	Send(*NeighborSet) error
	grpc.ServerStream
}

type grpcGetPolicyNeighborsServer struct {
	grpc.ServerStream
}

func (x *grpcGetPolicyNeighborsServer) Send(m *NeighborSet) error {
	return x.ServerStream.SendMsg(m)
}

func _Grpc_GetPolicyNeighbor_Handler(srv interface{}, ctx context.Context, codec grpc.Codec, buf []byte) (interface{}, error) {
	in := new(PolicyArguments)
	if err := codec.Unmarshal(buf, in); err != nil {
		return nil, err
	}
	out, err := srv.(GrpcServer).GetPolicyNeighbor(ctx, in)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func _Grpc_GetPolicyRoutePolicies_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(PolicyArguments)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(GrpcServer).GetPolicyRoutePolicies(m, &grpcGetPolicyRoutePoliciesServer{stream})
}

type Grpc_GetPolicyRoutePoliciesServer interface {
	Send(*PolicyDefinition) error
	grpc.ServerStream
}

type grpcGetPolicyRoutePoliciesServer struct {
	grpc.ServerStream
}

func (x *grpcGetPolicyRoutePoliciesServer) Send(m *PolicyDefinition) error {
	return x.ServerStream.SendMsg(m)
}

func _Grpc_GetPolicyRoutePolicy_Handler(srv interface{}, ctx context.Context, codec grpc.Codec, buf []byte) (interface{}, error) {
	in := new(PolicyArguments)
	if err := codec.Unmarshal(buf, in); err != nil {
		return nil, err
	}
	out, err := srv.(GrpcServer).GetPolicyRoutePolicy(ctx, in)
	if err != nil {
		return nil, err
	}
	return out, nil
}

var _Grpc_serviceDesc = grpc.ServiceDesc{
	ServiceName: "api.Grpc",
	HandlerType: (*GrpcServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetNeighbor",
			Handler:    _Grpc_GetNeighbor_Handler,
		},
		{
			MethodName: "Reset",
			Handler:    _Grpc_Reset_Handler,
		},
		{
			MethodName: "SoftReset",
			Handler:    _Grpc_SoftReset_Handler,
		},
		{
			MethodName: "SoftResetIn",
			Handler:    _Grpc_SoftResetIn_Handler,
		},
		{
			MethodName: "SoftResetOut",
			Handler:    _Grpc_SoftResetOut_Handler,
		},
		{
			MethodName: "Shutdown",
			Handler:    _Grpc_Shutdown_Handler,
		},
		{
			MethodName: "Enable",
			Handler:    _Grpc_Enable_Handler,
		},
		{
			MethodName: "Disable",
			Handler:    _Grpc_Disable_Handler,
		},
		{
			MethodName: "GetNeighborPolicy",
			Handler:    _Grpc_GetNeighborPolicy_Handler,
		},
		{
			MethodName: "GetPolicyPrefix",
			Handler:    _Grpc_GetPolicyPrefix_Handler,
		},
		{
			MethodName: "GetPolicyNeighbor",
			Handler:    _Grpc_GetPolicyNeighbor_Handler,
		},
		{
			MethodName: "GetPolicyRoutePolicy",
			Handler:    _Grpc_GetPolicyRoutePolicy_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "GetNeighbors",
			Handler:       _Grpc_GetNeighbors_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "GetRib",
			Handler:       _Grpc_GetRib_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "GetAdjRib",
			Handler:       _Grpc_GetAdjRib_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "ModPath",
			Handler:       _Grpc_ModPath_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
		{
			StreamName:    "GetPolicyPrefixes",
			Handler:       _Grpc_GetPolicyPrefixes_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "ModPolicyPrefix",
			Handler:       _Grpc_ModPolicyPrefix_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
		{
			StreamName:    "GetPolicyNeighbors",
			Handler:       _Grpc_GetPolicyNeighbors_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "GetPolicyRoutePolicies",
			Handler:       _Grpc_GetPolicyRoutePolicies_Handler,
			ServerStreams: true,
		},
	},
}