// Copyright (C) 2018 Nippon Telegraph and Telephone Corporation.
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation files
// (the "Software"), to deal in the Software without restriction,
// including without limitation the rights to use, copy, modify, merge,
// publish, distribute, sublicense, and/or sell copies of the Software,
// and to permit persons to whom the Software is furnished to do so,
// subject to the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.6
// 	protoc        (unknown)
// source: api/capability.proto

package api

import (
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	reflect "reflect"
	sync "sync"
	unsafe "unsafe"
)

const (
	// Verify that this generated code is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
	// Verify that runtime/protoimpl is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)

type AddPathCapabilityTuple_Mode int32

const (
	AddPathCapabilityTuple_MODE_UNSPECIFIED AddPathCapabilityTuple_Mode = 0 // NONE
	AddPathCapabilityTuple_MODE_RECEIVE     AddPathCapabilityTuple_Mode = 1
	AddPathCapabilityTuple_MODE_SEND        AddPathCapabilityTuple_Mode = 2
	AddPathCapabilityTuple_MODE_BOTH        AddPathCapabilityTuple_Mode = 3
)

// Enum value maps for AddPathCapabilityTuple_Mode.
var (
	AddPathCapabilityTuple_Mode_name = map[int32]string{
		0: "MODE_UNSPECIFIED",
		1: "MODE_RECEIVE",
		2: "MODE_SEND",
		3: "MODE_BOTH",
	}
	AddPathCapabilityTuple_Mode_value = map[string]int32{
		"MODE_UNSPECIFIED": 0,
		"MODE_RECEIVE":     1,
		"MODE_SEND":        2,
		"MODE_BOTH":        3,
	}
)

func (x AddPathCapabilityTuple_Mode) Enum() *AddPathCapabilityTuple_Mode {
	p := new(AddPathCapabilityTuple_Mode)
	*p = x
	return p
}

func (x AddPathCapabilityTuple_Mode) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (AddPathCapabilityTuple_Mode) Descriptor() protoreflect.EnumDescriptor {
	return file_api_capability_proto_enumTypes[0].Descriptor()
}

func (AddPathCapabilityTuple_Mode) Type() protoreflect.EnumType {
	return &file_api_capability_proto_enumTypes[0]
}

func (x AddPathCapabilityTuple_Mode) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use AddPathCapabilityTuple_Mode.Descriptor instead.
func (AddPathCapabilityTuple_Mode) EnumDescriptor() ([]byte, []int) {
	return file_api_capability_proto_rawDescGZIP(), []int{9, 0}
}

type Capability struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Cap:
	//
	//	*Capability_Unknown
	//	*Capability_MultiProtocol
	//	*Capability_RouteRefresh
	//	*Capability_CarryingLabelInfo
	//	*Capability_ExtendedNexthop
	//	*Capability_GracefulRestart
	//	*Capability_FourOctetAsn
	//	*Capability_AddPath
	//	*Capability_EnhancedRouteRefresh
	//	*Capability_LongLivedGracefulRestart
	//	*Capability_RouteRefreshCisco
	//	*Capability_Fqdn
	//	*Capability_SoftwareVersion
	Cap           isCapability_Cap `protobuf_oneof:"cap"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Capability) Reset() {
	*x = Capability{}
	mi := &file_api_capability_proto_msgTypes[0]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Capability) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Capability) ProtoMessage() {}

func (x *Capability) ProtoReflect() protoreflect.Message {
	mi := &file_api_capability_proto_msgTypes[0]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use Capability.ProtoReflect.Descriptor instead.
func (*Capability) Descriptor() ([]byte, []int) {
	return file_api_capability_proto_rawDescGZIP(), []int{0}
}

func (x *Capability) GetCap() isCapability_Cap {
	if x != nil {
		return x.Cap
	}
	return nil
}

func (x *Capability) GetUnknown() *UnknownCapability {
	if x != nil {
		if x, ok := x.Cap.(*Capability_Unknown); ok {
			return x.Unknown
		}
	}
	return nil
}

func (x *Capability) GetMultiProtocol() *MultiProtocolCapability {
	if x != nil {
		if x, ok := x.Cap.(*Capability_MultiProtocol); ok {
			return x.MultiProtocol
		}
	}
	return nil
}

func (x *Capability) GetRouteRefresh() *RouteRefreshCapability {
	if x != nil {
		if x, ok := x.Cap.(*Capability_RouteRefresh); ok {
			return x.RouteRefresh
		}
	}
	return nil
}

func (x *Capability) GetCarryingLabelInfo() *CarryingLabelInfoCapability {
	if x != nil {
		if x, ok := x.Cap.(*Capability_CarryingLabelInfo); ok {
			return x.CarryingLabelInfo
		}
	}
	return nil
}

func (x *Capability) GetExtendedNexthop() *ExtendedNexthopCapability {
	if x != nil {
		if x, ok := x.Cap.(*Capability_ExtendedNexthop); ok {
			return x.ExtendedNexthop
		}
	}
	return nil
}

func (x *Capability) GetGracefulRestart() *GracefulRestartCapability {
	if x != nil {
		if x, ok := x.Cap.(*Capability_GracefulRestart); ok {
			return x.GracefulRestart
		}
	}
	return nil
}

func (x *Capability) GetFourOctetAsn() *FourOctetASNCapability {
	if x != nil {
		if x, ok := x.Cap.(*Capability_FourOctetAsn); ok {
			return x.FourOctetAsn
		}
	}
	return nil
}

func (x *Capability) GetAddPath() *AddPathCapability {
	if x != nil {
		if x, ok := x.Cap.(*Capability_AddPath); ok {
			return x.AddPath
		}
	}
	return nil
}

func (x *Capability) GetEnhancedRouteRefresh() *EnhancedRouteRefreshCapability {
	if x != nil {
		if x, ok := x.Cap.(*Capability_EnhancedRouteRefresh); ok {
			return x.EnhancedRouteRefresh
		}
	}
	return nil
}

func (x *Capability) GetLongLivedGracefulRestart() *LongLivedGracefulRestartCapability {
	if x != nil {
		if x, ok := x.Cap.(*Capability_LongLivedGracefulRestart); ok {
			return x.LongLivedGracefulRestart
		}
	}
	return nil
}

func (x *Capability) GetRouteRefreshCisco() *RouteRefreshCiscoCapability {
	if x != nil {
		if x, ok := x.Cap.(*Capability_RouteRefreshCisco); ok {
			return x.RouteRefreshCisco
		}
	}
	return nil
}

func (x *Capability) GetFqdn() *FqdnCapability {
	if x != nil {
		if x, ok := x.Cap.(*Capability_Fqdn); ok {
			return x.Fqdn
		}
	}
	return nil
}

func (x *Capability) GetSoftwareVersion() *SoftwareVersionCapability {
	if x != nil {
		if x, ok := x.Cap.(*Capability_SoftwareVersion); ok {
			return x.SoftwareVersion
		}
	}
	return nil
}

type isCapability_Cap interface {
	isCapability_Cap()
}

type Capability_Unknown struct {
	Unknown *UnknownCapability `protobuf:"bytes,1,opt,name=unknown,proto3,oneof"`
}

type Capability_MultiProtocol struct {
	MultiProtocol *MultiProtocolCapability `protobuf:"bytes,2,opt,name=multi_protocol,json=multiProtocol,proto3,oneof"`
}

type Capability_RouteRefresh struct {
	RouteRefresh *RouteRefreshCapability `protobuf:"bytes,3,opt,name=route_refresh,json=routeRefresh,proto3,oneof"`
}

type Capability_CarryingLabelInfo struct {
	CarryingLabelInfo *CarryingLabelInfoCapability `protobuf:"bytes,4,opt,name=carrying_label_info,json=carryingLabelInfo,proto3,oneof"`
}

type Capability_ExtendedNexthop struct {
	ExtendedNexthop *ExtendedNexthopCapability `protobuf:"bytes,5,opt,name=extended_nexthop,json=extendedNexthop,proto3,oneof"`
}

type Capability_GracefulRestart struct {
	GracefulRestart *GracefulRestartCapability `protobuf:"bytes,6,opt,name=graceful_restart,json=gracefulRestart,proto3,oneof"`
}

type Capability_FourOctetAsn struct {
	FourOctetAsn *FourOctetASNCapability `protobuf:"bytes,7,opt,name=four_octet_asn,json=fourOctetAsn,proto3,oneof"`
}

type Capability_AddPath struct {
	AddPath *AddPathCapability `protobuf:"bytes,8,opt,name=add_path,json=addPath,proto3,oneof"`
}

type Capability_EnhancedRouteRefresh struct {
	EnhancedRouteRefresh *EnhancedRouteRefreshCapability `protobuf:"bytes,9,opt,name=enhanced_route_refresh,json=enhancedRouteRefresh,proto3,oneof"`
}

type Capability_LongLivedGracefulRestart struct {
	LongLivedGracefulRestart *LongLivedGracefulRestartCapability `protobuf:"bytes,10,opt,name=long_lived_graceful_restart,json=longLivedGracefulRestart,proto3,oneof"`
}

type Capability_RouteRefreshCisco struct {
	RouteRefreshCisco *RouteRefreshCiscoCapability `protobuf:"bytes,11,opt,name=route_refresh_cisco,json=routeRefreshCisco,proto3,oneof"`
}

type Capability_Fqdn struct {
	Fqdn *FqdnCapability `protobuf:"bytes,12,opt,name=fqdn,proto3,oneof"`
}

type Capability_SoftwareVersion struct {
	SoftwareVersion *SoftwareVersionCapability `protobuf:"bytes,13,opt,name=software_version,json=softwareVersion,proto3,oneof"`
}

func (*Capability_Unknown) isCapability_Cap() {}

func (*Capability_MultiProtocol) isCapability_Cap() {}

func (*Capability_RouteRefresh) isCapability_Cap() {}

func (*Capability_CarryingLabelInfo) isCapability_Cap() {}

func (*Capability_ExtendedNexthop) isCapability_Cap() {}

func (*Capability_GracefulRestart) isCapability_Cap() {}

func (*Capability_FourOctetAsn) isCapability_Cap() {}

func (*Capability_AddPath) isCapability_Cap() {}

func (*Capability_EnhancedRouteRefresh) isCapability_Cap() {}

func (*Capability_LongLivedGracefulRestart) isCapability_Cap() {}

func (*Capability_RouteRefreshCisco) isCapability_Cap() {}

func (*Capability_Fqdn) isCapability_Cap() {}

func (*Capability_SoftwareVersion) isCapability_Cap() {}

type MultiProtocolCapability struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Family        *Family                `protobuf:"bytes,1,opt,name=family,proto3" json:"family,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *MultiProtocolCapability) Reset() {
	*x = MultiProtocolCapability{}
	mi := &file_api_capability_proto_msgTypes[1]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *MultiProtocolCapability) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*MultiProtocolCapability) ProtoMessage() {}

func (x *MultiProtocolCapability) ProtoReflect() protoreflect.Message {
	mi := &file_api_capability_proto_msgTypes[1]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use MultiProtocolCapability.ProtoReflect.Descriptor instead.
func (*MultiProtocolCapability) Descriptor() ([]byte, []int) {
	return file_api_capability_proto_rawDescGZIP(), []int{1}
}

func (x *MultiProtocolCapability) GetFamily() *Family {
	if x != nil {
		return x.Family
	}
	return nil
}

type RouteRefreshCapability struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *RouteRefreshCapability) Reset() {
	*x = RouteRefreshCapability{}
	mi := &file_api_capability_proto_msgTypes[2]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *RouteRefreshCapability) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*RouteRefreshCapability) ProtoMessage() {}

func (x *RouteRefreshCapability) ProtoReflect() protoreflect.Message {
	mi := &file_api_capability_proto_msgTypes[2]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use RouteRefreshCapability.ProtoReflect.Descriptor instead.
func (*RouteRefreshCapability) Descriptor() ([]byte, []int) {
	return file_api_capability_proto_rawDescGZIP(), []int{2}
}

type CarryingLabelInfoCapability struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *CarryingLabelInfoCapability) Reset() {
	*x = CarryingLabelInfoCapability{}
	mi := &file_api_capability_proto_msgTypes[3]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *CarryingLabelInfoCapability) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*CarryingLabelInfoCapability) ProtoMessage() {}

func (x *CarryingLabelInfoCapability) ProtoReflect() protoreflect.Message {
	mi := &file_api_capability_proto_msgTypes[3]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use CarryingLabelInfoCapability.ProtoReflect.Descriptor instead.
func (*CarryingLabelInfoCapability) Descriptor() ([]byte, []int) {
	return file_api_capability_proto_rawDescGZIP(), []int{3}
}

type ExtendedNexthopCapabilityTuple struct {
	state      protoimpl.MessageState `protogen:"open.v1"`
	NlriFamily *Family                `protobuf:"bytes,1,opt,name=nlri_family,json=nlriFamily,proto3" json:"nlri_family,omitempty"`
	// Nexthop AFI must be either
	// gobgp.IPv4 or
	// gobgp.IPv6.
	NexthopFamily *Family `protobuf:"bytes,2,opt,name=nexthop_family,json=nexthopFamily,proto3" json:"nexthop_family,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ExtendedNexthopCapabilityTuple) Reset() {
	*x = ExtendedNexthopCapabilityTuple{}
	mi := &file_api_capability_proto_msgTypes[4]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *ExtendedNexthopCapabilityTuple) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*ExtendedNexthopCapabilityTuple) ProtoMessage() {}

func (x *ExtendedNexthopCapabilityTuple) ProtoReflect() protoreflect.Message {
	mi := &file_api_capability_proto_msgTypes[4]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use ExtendedNexthopCapabilityTuple.ProtoReflect.Descriptor instead.
func (*ExtendedNexthopCapabilityTuple) Descriptor() ([]byte, []int) {
	return file_api_capability_proto_rawDescGZIP(), []int{4}
}

func (x *ExtendedNexthopCapabilityTuple) GetNlriFamily() *Family {
	if x != nil {
		return x.NlriFamily
	}
	return nil
}

func (x *ExtendedNexthopCapabilityTuple) GetNexthopFamily() *Family {
	if x != nil {
		return x.NexthopFamily
	}
	return nil
}

type ExtendedNexthopCapability struct {
	state         protoimpl.MessageState            `protogen:"open.v1"`
	Tuples        []*ExtendedNexthopCapabilityTuple `protobuf:"bytes,1,rep,name=tuples,proto3" json:"tuples,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ExtendedNexthopCapability) Reset() {
	*x = ExtendedNexthopCapability{}
	mi := &file_api_capability_proto_msgTypes[5]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *ExtendedNexthopCapability) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*ExtendedNexthopCapability) ProtoMessage() {}

func (x *ExtendedNexthopCapability) ProtoReflect() protoreflect.Message {
	mi := &file_api_capability_proto_msgTypes[5]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use ExtendedNexthopCapability.ProtoReflect.Descriptor instead.
func (*ExtendedNexthopCapability) Descriptor() ([]byte, []int) {
	return file_api_capability_proto_rawDescGZIP(), []int{5}
}

func (x *ExtendedNexthopCapability) GetTuples() []*ExtendedNexthopCapabilityTuple {
	if x != nil {
		return x.Tuples
	}
	return nil
}

type GracefulRestartCapabilityTuple struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Family        *Family                `protobuf:"bytes,1,opt,name=family,proto3" json:"family,omitempty"`
	Flags         uint32                 `protobuf:"varint,2,opt,name=flags,proto3" json:"flags,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *GracefulRestartCapabilityTuple) Reset() {
	*x = GracefulRestartCapabilityTuple{}
	mi := &file_api_capability_proto_msgTypes[6]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *GracefulRestartCapabilityTuple) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*GracefulRestartCapabilityTuple) ProtoMessage() {}

func (x *GracefulRestartCapabilityTuple) ProtoReflect() protoreflect.Message {
	mi := &file_api_capability_proto_msgTypes[6]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use GracefulRestartCapabilityTuple.ProtoReflect.Descriptor instead.
func (*GracefulRestartCapabilityTuple) Descriptor() ([]byte, []int) {
	return file_api_capability_proto_rawDescGZIP(), []int{6}
}

func (x *GracefulRestartCapabilityTuple) GetFamily() *Family {
	if x != nil {
		return x.Family
	}
	return nil
}

func (x *GracefulRestartCapabilityTuple) GetFlags() uint32 {
	if x != nil {
		return x.Flags
	}
	return 0
}

type GracefulRestartCapability struct {
	state         protoimpl.MessageState            `protogen:"open.v1"`
	Flags         uint32                            `protobuf:"varint,1,opt,name=flags,proto3" json:"flags,omitempty"`
	Time          uint32                            `protobuf:"varint,2,opt,name=time,proto3" json:"time,omitempty"`
	Tuples        []*GracefulRestartCapabilityTuple `protobuf:"bytes,3,rep,name=tuples,proto3" json:"tuples,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *GracefulRestartCapability) Reset() {
	*x = GracefulRestartCapability{}
	mi := &file_api_capability_proto_msgTypes[7]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *GracefulRestartCapability) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*GracefulRestartCapability) ProtoMessage() {}

func (x *GracefulRestartCapability) ProtoReflect() protoreflect.Message {
	mi := &file_api_capability_proto_msgTypes[7]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use GracefulRestartCapability.ProtoReflect.Descriptor instead.
func (*GracefulRestartCapability) Descriptor() ([]byte, []int) {
	return file_api_capability_proto_rawDescGZIP(), []int{7}
}

func (x *GracefulRestartCapability) GetFlags() uint32 {
	if x != nil {
		return x.Flags
	}
	return 0
}

func (x *GracefulRestartCapability) GetTime() uint32 {
	if x != nil {
		return x.Time
	}
	return 0
}

func (x *GracefulRestartCapability) GetTuples() []*GracefulRestartCapabilityTuple {
	if x != nil {
		return x.Tuples
	}
	return nil
}

type FourOctetASNCapability struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Asn           uint32                 `protobuf:"varint,1,opt,name=asn,proto3" json:"asn,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *FourOctetASNCapability) Reset() {
	*x = FourOctetASNCapability{}
	mi := &file_api_capability_proto_msgTypes[8]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *FourOctetASNCapability) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*FourOctetASNCapability) ProtoMessage() {}

func (x *FourOctetASNCapability) ProtoReflect() protoreflect.Message {
	mi := &file_api_capability_proto_msgTypes[8]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use FourOctetASNCapability.ProtoReflect.Descriptor instead.
func (*FourOctetASNCapability) Descriptor() ([]byte, []int) {
	return file_api_capability_proto_rawDescGZIP(), []int{8}
}

func (x *FourOctetASNCapability) GetAsn() uint32 {
	if x != nil {
		return x.Asn
	}
	return 0
}

type AddPathCapabilityTuple struct {
	state         protoimpl.MessageState      `protogen:"open.v1"`
	Family        *Family                     `protobuf:"bytes,1,opt,name=family,proto3" json:"family,omitempty"`
	Mode          AddPathCapabilityTuple_Mode `protobuf:"varint,2,opt,name=mode,proto3,enum=api.AddPathCapabilityTuple_Mode" json:"mode,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *AddPathCapabilityTuple) Reset() {
	*x = AddPathCapabilityTuple{}
	mi := &file_api_capability_proto_msgTypes[9]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *AddPathCapabilityTuple) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AddPathCapabilityTuple) ProtoMessage() {}

func (x *AddPathCapabilityTuple) ProtoReflect() protoreflect.Message {
	mi := &file_api_capability_proto_msgTypes[9]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use AddPathCapabilityTuple.ProtoReflect.Descriptor instead.
func (*AddPathCapabilityTuple) Descriptor() ([]byte, []int) {
	return file_api_capability_proto_rawDescGZIP(), []int{9}
}

func (x *AddPathCapabilityTuple) GetFamily() *Family {
	if x != nil {
		return x.Family
	}
	return nil
}

func (x *AddPathCapabilityTuple) GetMode() AddPathCapabilityTuple_Mode {
	if x != nil {
		return x.Mode
	}
	return AddPathCapabilityTuple_MODE_UNSPECIFIED
}

type AddPathCapability struct {
	state         protoimpl.MessageState    `protogen:"open.v1"`
	Tuples        []*AddPathCapabilityTuple `protobuf:"bytes,1,rep,name=tuples,proto3" json:"tuples,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *AddPathCapability) Reset() {
	*x = AddPathCapability{}
	mi := &file_api_capability_proto_msgTypes[10]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *AddPathCapability) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AddPathCapability) ProtoMessage() {}

func (x *AddPathCapability) ProtoReflect() protoreflect.Message {
	mi := &file_api_capability_proto_msgTypes[10]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use AddPathCapability.ProtoReflect.Descriptor instead.
func (*AddPathCapability) Descriptor() ([]byte, []int) {
	return file_api_capability_proto_rawDescGZIP(), []int{10}
}

func (x *AddPathCapability) GetTuples() []*AddPathCapabilityTuple {
	if x != nil {
		return x.Tuples
	}
	return nil
}

type EnhancedRouteRefreshCapability struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *EnhancedRouteRefreshCapability) Reset() {
	*x = EnhancedRouteRefreshCapability{}
	mi := &file_api_capability_proto_msgTypes[11]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *EnhancedRouteRefreshCapability) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*EnhancedRouteRefreshCapability) ProtoMessage() {}

func (x *EnhancedRouteRefreshCapability) ProtoReflect() protoreflect.Message {
	mi := &file_api_capability_proto_msgTypes[11]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use EnhancedRouteRefreshCapability.ProtoReflect.Descriptor instead.
func (*EnhancedRouteRefreshCapability) Descriptor() ([]byte, []int) {
	return file_api_capability_proto_rawDescGZIP(), []int{11}
}

type LongLivedGracefulRestartCapabilityTuple struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Family        *Family                `protobuf:"bytes,1,opt,name=family,proto3" json:"family,omitempty"`
	Flags         uint32                 `protobuf:"varint,2,opt,name=flags,proto3" json:"flags,omitempty"`
	Time          uint32                 `protobuf:"varint,3,opt,name=time,proto3" json:"time,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *LongLivedGracefulRestartCapabilityTuple) Reset() {
	*x = LongLivedGracefulRestartCapabilityTuple{}
	mi := &file_api_capability_proto_msgTypes[12]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *LongLivedGracefulRestartCapabilityTuple) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*LongLivedGracefulRestartCapabilityTuple) ProtoMessage() {}

func (x *LongLivedGracefulRestartCapabilityTuple) ProtoReflect() protoreflect.Message {
	mi := &file_api_capability_proto_msgTypes[12]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use LongLivedGracefulRestartCapabilityTuple.ProtoReflect.Descriptor instead.
func (*LongLivedGracefulRestartCapabilityTuple) Descriptor() ([]byte, []int) {
	return file_api_capability_proto_rawDescGZIP(), []int{12}
}

func (x *LongLivedGracefulRestartCapabilityTuple) GetFamily() *Family {
	if x != nil {
		return x.Family
	}
	return nil
}

func (x *LongLivedGracefulRestartCapabilityTuple) GetFlags() uint32 {
	if x != nil {
		return x.Flags
	}
	return 0
}

func (x *LongLivedGracefulRestartCapabilityTuple) GetTime() uint32 {
	if x != nil {
		return x.Time
	}
	return 0
}

type LongLivedGracefulRestartCapability struct {
	state         protoimpl.MessageState                     `protogen:"open.v1"`
	Tuples        []*LongLivedGracefulRestartCapabilityTuple `protobuf:"bytes,1,rep,name=tuples,proto3" json:"tuples,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *LongLivedGracefulRestartCapability) Reset() {
	*x = LongLivedGracefulRestartCapability{}
	mi := &file_api_capability_proto_msgTypes[13]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *LongLivedGracefulRestartCapability) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*LongLivedGracefulRestartCapability) ProtoMessage() {}

func (x *LongLivedGracefulRestartCapability) ProtoReflect() protoreflect.Message {
	mi := &file_api_capability_proto_msgTypes[13]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use LongLivedGracefulRestartCapability.ProtoReflect.Descriptor instead.
func (*LongLivedGracefulRestartCapability) Descriptor() ([]byte, []int) {
	return file_api_capability_proto_rawDescGZIP(), []int{13}
}

func (x *LongLivedGracefulRestartCapability) GetTuples() []*LongLivedGracefulRestartCapabilityTuple {
	if x != nil {
		return x.Tuples
	}
	return nil
}

type RouteRefreshCiscoCapability struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *RouteRefreshCiscoCapability) Reset() {
	*x = RouteRefreshCiscoCapability{}
	mi := &file_api_capability_proto_msgTypes[14]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *RouteRefreshCiscoCapability) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*RouteRefreshCiscoCapability) ProtoMessage() {}

func (x *RouteRefreshCiscoCapability) ProtoReflect() protoreflect.Message {
	mi := &file_api_capability_proto_msgTypes[14]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use RouteRefreshCiscoCapability.ProtoReflect.Descriptor instead.
func (*RouteRefreshCiscoCapability) Descriptor() ([]byte, []int) {
	return file_api_capability_proto_rawDescGZIP(), []int{14}
}

type FqdnCapability struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	HostName      string                 `protobuf:"bytes,1,opt,name=host_name,json=hostName,proto3" json:"host_name,omitempty"`
	DomainName    string                 `protobuf:"bytes,2,opt,name=domain_name,json=domainName,proto3" json:"domain_name,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *FqdnCapability) Reset() {
	*x = FqdnCapability{}
	mi := &file_api_capability_proto_msgTypes[15]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *FqdnCapability) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*FqdnCapability) ProtoMessage() {}

func (x *FqdnCapability) ProtoReflect() protoreflect.Message {
	mi := &file_api_capability_proto_msgTypes[15]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use FqdnCapability.ProtoReflect.Descriptor instead.
func (*FqdnCapability) Descriptor() ([]byte, []int) {
	return file_api_capability_proto_rawDescGZIP(), []int{15}
}

func (x *FqdnCapability) GetHostName() string {
	if x != nil {
		return x.HostName
	}
	return ""
}

func (x *FqdnCapability) GetDomainName() string {
	if x != nil {
		return x.DomainName
	}
	return ""
}

type SoftwareVersionCapability struct {
	state           protoimpl.MessageState `protogen:"open.v1"`
	SoftwareVersion string                 `protobuf:"bytes,1,opt,name=software_version,json=softwareVersion,proto3" json:"software_version,omitempty"`
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

func (x *SoftwareVersionCapability) Reset() {
	*x = SoftwareVersionCapability{}
	mi := &file_api_capability_proto_msgTypes[16]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *SoftwareVersionCapability) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*SoftwareVersionCapability) ProtoMessage() {}

func (x *SoftwareVersionCapability) ProtoReflect() protoreflect.Message {
	mi := &file_api_capability_proto_msgTypes[16]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use SoftwareVersionCapability.ProtoReflect.Descriptor instead.
func (*SoftwareVersionCapability) Descriptor() ([]byte, []int) {
	return file_api_capability_proto_rawDescGZIP(), []int{16}
}

func (x *SoftwareVersionCapability) GetSoftwareVersion() string {
	if x != nil {
		return x.SoftwareVersion
	}
	return ""
}

type UnknownCapability struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Code          uint32                 `protobuf:"varint,1,opt,name=code,proto3" json:"code,omitempty"`
	Value         []byte                 `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *UnknownCapability) Reset() {
	*x = UnknownCapability{}
	mi := &file_api_capability_proto_msgTypes[17]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *UnknownCapability) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*UnknownCapability) ProtoMessage() {}

func (x *UnknownCapability) ProtoReflect() protoreflect.Message {
	mi := &file_api_capability_proto_msgTypes[17]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use UnknownCapability.ProtoReflect.Descriptor instead.
func (*UnknownCapability) Descriptor() ([]byte, []int) {
	return file_api_capability_proto_rawDescGZIP(), []int{17}
}

func (x *UnknownCapability) GetCode() uint32 {
	if x != nil {
		return x.Code
	}
	return 0
}

func (x *UnknownCapability) GetValue() []byte {
	if x != nil {
		return x.Value
	}
	return nil
}

var File_api_capability_proto protoreflect.FileDescriptor

const file_api_capability_proto_rawDesc = "" +
	"\n" +
	"\x14api/capability.proto\x12\x03api\x1a\x10api/common.proto\"\xcd\a\n" +
	"\n" +
	"Capability\x122\n" +
	"\aunknown\x18\x01 \x01(\v2\x16.api.UnknownCapabilityH\x00R\aunknown\x12E\n" +
	"\x0emulti_protocol\x18\x02 \x01(\v2\x1c.api.MultiProtocolCapabilityH\x00R\rmultiProtocol\x12B\n" +
	"\rroute_refresh\x18\x03 \x01(\v2\x1b.api.RouteRefreshCapabilityH\x00R\frouteRefresh\x12R\n" +
	"\x13carrying_label_info\x18\x04 \x01(\v2 .api.CarryingLabelInfoCapabilityH\x00R\x11carryingLabelInfo\x12K\n" +
	"\x10extended_nexthop\x18\x05 \x01(\v2\x1e.api.ExtendedNexthopCapabilityH\x00R\x0fextendedNexthop\x12K\n" +
	"\x10graceful_restart\x18\x06 \x01(\v2\x1e.api.GracefulRestartCapabilityH\x00R\x0fgracefulRestart\x12C\n" +
	"\x0efour_octet_asn\x18\a \x01(\v2\x1b.api.FourOctetASNCapabilityH\x00R\ffourOctetAsn\x123\n" +
	"\badd_path\x18\b \x01(\v2\x16.api.AddPathCapabilityH\x00R\aaddPath\x12[\n" +
	"\x16enhanced_route_refresh\x18\t \x01(\v2#.api.EnhancedRouteRefreshCapabilityH\x00R\x14enhancedRouteRefresh\x12h\n" +
	"\x1blong_lived_graceful_restart\x18\n" +
	" \x01(\v2'.api.LongLivedGracefulRestartCapabilityH\x00R\x18longLivedGracefulRestart\x12R\n" +
	"\x13route_refresh_cisco\x18\v \x01(\v2 .api.RouteRefreshCiscoCapabilityH\x00R\x11routeRefreshCisco\x12)\n" +
	"\x04fqdn\x18\f \x01(\v2\x13.api.FqdnCapabilityH\x00R\x04fqdn\x12K\n" +
	"\x10software_version\x18\r \x01(\v2\x1e.api.SoftwareVersionCapabilityH\x00R\x0fsoftwareVersionB\x05\n" +
	"\x03cap\">\n" +
	"\x17MultiProtocolCapability\x12#\n" +
	"\x06family\x18\x01 \x01(\v2\v.api.FamilyR\x06family\"\x18\n" +
	"\x16RouteRefreshCapability\"\x1d\n" +
	"\x1bCarryingLabelInfoCapability\"\x82\x01\n" +
	"\x1eExtendedNexthopCapabilityTuple\x12,\n" +
	"\vnlri_family\x18\x01 \x01(\v2\v.api.FamilyR\n" +
	"nlriFamily\x122\n" +
	"\x0enexthop_family\x18\x02 \x01(\v2\v.api.FamilyR\rnexthopFamily\"X\n" +
	"\x19ExtendedNexthopCapability\x12;\n" +
	"\x06tuples\x18\x01 \x03(\v2#.api.ExtendedNexthopCapabilityTupleR\x06tuples\"[\n" +
	"\x1eGracefulRestartCapabilityTuple\x12#\n" +
	"\x06family\x18\x01 \x01(\v2\v.api.FamilyR\x06family\x12\x14\n" +
	"\x05flags\x18\x02 \x01(\rR\x05flags\"\x82\x01\n" +
	"\x19GracefulRestartCapability\x12\x14\n" +
	"\x05flags\x18\x01 \x01(\rR\x05flags\x12\x12\n" +
	"\x04time\x18\x02 \x01(\rR\x04time\x12;\n" +
	"\x06tuples\x18\x03 \x03(\v2#.api.GracefulRestartCapabilityTupleR\x06tuples\"*\n" +
	"\x16FourOctetASNCapability\x12\x10\n" +
	"\x03asn\x18\x01 \x01(\rR\x03asn\"\xc1\x01\n" +
	"\x16AddPathCapabilityTuple\x12#\n" +
	"\x06family\x18\x01 \x01(\v2\v.api.FamilyR\x06family\x124\n" +
	"\x04mode\x18\x02 \x01(\x0e2 .api.AddPathCapabilityTuple.ModeR\x04mode\"L\n" +
	"\x04Mode\x12\x14\n" +
	"\x10MODE_UNSPECIFIED\x10\x00\x12\x10\n" +
	"\fMODE_RECEIVE\x10\x01\x12\r\n" +
	"\tMODE_SEND\x10\x02\x12\r\n" +
	"\tMODE_BOTH\x10\x03\"H\n" +
	"\x11AddPathCapability\x123\n" +
	"\x06tuples\x18\x01 \x03(\v2\x1b.api.AddPathCapabilityTupleR\x06tuples\" \n" +
	"\x1eEnhancedRouteRefreshCapability\"x\n" +
	"'LongLivedGracefulRestartCapabilityTuple\x12#\n" +
	"\x06family\x18\x01 \x01(\v2\v.api.FamilyR\x06family\x12\x14\n" +
	"\x05flags\x18\x02 \x01(\rR\x05flags\x12\x12\n" +
	"\x04time\x18\x03 \x01(\rR\x04time\"j\n" +
	"\"LongLivedGracefulRestartCapability\x12D\n" +
	"\x06tuples\x18\x01 \x03(\v2,.api.LongLivedGracefulRestartCapabilityTupleR\x06tuples\"\x1d\n" +
	"\x1bRouteRefreshCiscoCapability\"N\n" +
	"\x0eFqdnCapability\x12\x1b\n" +
	"\thost_name\x18\x01 \x01(\tR\bhostName\x12\x1f\n" +
	"\vdomain_name\x18\x02 \x01(\tR\n" +
	"domainName\"F\n" +
	"\x19SoftwareVersionCapability\x12)\n" +
	"\x10software_version\x18\x01 \x01(\tR\x0fsoftwareVersion\"=\n" +
	"\x11UnknownCapability\x12\x12\n" +
	"\x04code\x18\x01 \x01(\rR\x04code\x12\x14\n" +
	"\x05value\x18\x02 \x01(\fR\x05valueB\"Z github.com/osrg/gobgp/v4/api;apib\x06proto3"

var (
	file_api_capability_proto_rawDescOnce sync.Once
	file_api_capability_proto_rawDescData []byte
)

func file_api_capability_proto_rawDescGZIP() []byte {
	file_api_capability_proto_rawDescOnce.Do(func() {
		file_api_capability_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_api_capability_proto_rawDesc), len(file_api_capability_proto_rawDesc)))
	})
	return file_api_capability_proto_rawDescData
}

var file_api_capability_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
var file_api_capability_proto_msgTypes = make([]protoimpl.MessageInfo, 18)
var file_api_capability_proto_goTypes = []any{
	(AddPathCapabilityTuple_Mode)(0),                // 0: api.AddPathCapabilityTuple.Mode
	(*Capability)(nil),                              // 1: api.Capability
	(*MultiProtocolCapability)(nil),                 // 2: api.MultiProtocolCapability
	(*RouteRefreshCapability)(nil),                  // 3: api.RouteRefreshCapability
	(*CarryingLabelInfoCapability)(nil),             // 4: api.CarryingLabelInfoCapability
	(*ExtendedNexthopCapabilityTuple)(nil),          // 5: api.ExtendedNexthopCapabilityTuple
	(*ExtendedNexthopCapability)(nil),               // 6: api.ExtendedNexthopCapability
	(*GracefulRestartCapabilityTuple)(nil),          // 7: api.GracefulRestartCapabilityTuple
	(*GracefulRestartCapability)(nil),               // 8: api.GracefulRestartCapability
	(*FourOctetASNCapability)(nil),                  // 9: api.FourOctetASNCapability
	(*AddPathCapabilityTuple)(nil),                  // 10: api.AddPathCapabilityTuple
	(*AddPathCapability)(nil),                       // 11: api.AddPathCapability
	(*EnhancedRouteRefreshCapability)(nil),          // 12: api.EnhancedRouteRefreshCapability
	(*LongLivedGracefulRestartCapabilityTuple)(nil), // 13: api.LongLivedGracefulRestartCapabilityTuple
	(*LongLivedGracefulRestartCapability)(nil),      // 14: api.LongLivedGracefulRestartCapability
	(*RouteRefreshCiscoCapability)(nil),             // 15: api.RouteRefreshCiscoCapability
	(*FqdnCapability)(nil),                          // 16: api.FqdnCapability
	(*SoftwareVersionCapability)(nil),               // 17: api.SoftwareVersionCapability
	(*UnknownCapability)(nil),                       // 18: api.UnknownCapability
	(*Family)(nil),                                  // 19: api.Family
}
var file_api_capability_proto_depIdxs = []int32{
	18, // 0: api.Capability.unknown:type_name -> api.UnknownCapability
	2,  // 1: api.Capability.multi_protocol:type_name -> api.MultiProtocolCapability
	3,  // 2: api.Capability.route_refresh:type_name -> api.RouteRefreshCapability
	4,  // 3: api.Capability.carrying_label_info:type_name -> api.CarryingLabelInfoCapability
	6,  // 4: api.Capability.extended_nexthop:type_name -> api.ExtendedNexthopCapability
	8,  // 5: api.Capability.graceful_restart:type_name -> api.GracefulRestartCapability
	9,  // 6: api.Capability.four_octet_asn:type_name -> api.FourOctetASNCapability
	11, // 7: api.Capability.add_path:type_name -> api.AddPathCapability
	12, // 8: api.Capability.enhanced_route_refresh:type_name -> api.EnhancedRouteRefreshCapability
	14, // 9: api.Capability.long_lived_graceful_restart:type_name -> api.LongLivedGracefulRestartCapability
	15, // 10: api.Capability.route_refresh_cisco:type_name -> api.RouteRefreshCiscoCapability
	16, // 11: api.Capability.fqdn:type_name -> api.FqdnCapability
	17, // 12: api.Capability.software_version:type_name -> api.SoftwareVersionCapability
	19, // 13: api.MultiProtocolCapability.family:type_name -> api.Family
	19, // 14: api.ExtendedNexthopCapabilityTuple.nlri_family:type_name -> api.Family
	19, // 15: api.ExtendedNexthopCapabilityTuple.nexthop_family:type_name -> api.Family
	5,  // 16: api.ExtendedNexthopCapability.tuples:type_name -> api.ExtendedNexthopCapabilityTuple
	19, // 17: api.GracefulRestartCapabilityTuple.family:type_name -> api.Family
	7,  // 18: api.GracefulRestartCapability.tuples:type_name -> api.GracefulRestartCapabilityTuple
	19, // 19: api.AddPathCapabilityTuple.family:type_name -> api.Family
	0,  // 20: api.AddPathCapabilityTuple.mode:type_name -> api.AddPathCapabilityTuple.Mode
	10, // 21: api.AddPathCapability.tuples:type_name -> api.AddPathCapabilityTuple
	19, // 22: api.LongLivedGracefulRestartCapabilityTuple.family:type_name -> api.Family
	13, // 23: api.LongLivedGracefulRestartCapability.tuples:type_name -> api.LongLivedGracefulRestartCapabilityTuple
	24, // [24:24] is the sub-list for method output_type
	24, // [24:24] is the sub-list for method input_type
	24, // [24:24] is the sub-list for extension type_name
	24, // [24:24] is the sub-list for extension extendee
	0,  // [0:24] is the sub-list for field type_name
}

func init() { file_api_capability_proto_init() }
func file_api_capability_proto_init() {
	if File_api_capability_proto != nil {
		return
	}
	file_api_common_proto_init()
	file_api_capability_proto_msgTypes[0].OneofWrappers = []any{
		(*Capability_Unknown)(nil),
		(*Capability_MultiProtocol)(nil),
		(*Capability_RouteRefresh)(nil),
		(*Capability_CarryingLabelInfo)(nil),
		(*Capability_ExtendedNexthop)(nil),
		(*Capability_GracefulRestart)(nil),
		(*Capability_FourOctetAsn)(nil),
		(*Capability_AddPath)(nil),
		(*Capability_EnhancedRouteRefresh)(nil),
		(*Capability_LongLivedGracefulRestart)(nil),
		(*Capability_RouteRefreshCisco)(nil),
		(*Capability_Fqdn)(nil),
		(*Capability_SoftwareVersion)(nil),
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_api_capability_proto_rawDesc), len(file_api_capability_proto_rawDesc)),
			NumEnums:      1,
			NumMessages:   18,
			NumExtensions: 0,
			NumServices:   0,
		},
		GoTypes:           file_api_capability_proto_goTypes,
		DependencyIndexes: file_api_capability_proto_depIdxs,
		EnumInfos:         file_api_capability_proto_enumTypes,
		MessageInfos:      file_api_capability_proto_msgTypes,
	}.Build()
	File_api_capability_proto = out.File
	file_api_capability_proto_goTypes = nil
	file_api_capability_proto_depIdxs = nil
}
