config

package
v0.0.0-...-7a34c7c Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jun 7, 2017 License: Apache-2.0 Imports: 15 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	DEFAULT_HOLDTIME                  = 90
	DEFAULT_IDLE_HOLDTIME_AFTER_RESET = 30
	DEFAULT_CONNECT_RETRY             = 120
)

Variables

View Source 
var AdminStateToIntMap = map[AdminState]int{
	ADMIN_STATE_UP:     0,
	ADMIN_STATE_DOWN:   1,
	ADMIN_STATE_PFX_CT: 2,
}
View Source 
var AfiSafiTypeToIntMap = map[AfiSafiType]int{
	AFI_SAFI_TYPE_IPV4_UNICAST:          0,
	AFI_SAFI_TYPE_IPV6_UNICAST:          1,
	AFI_SAFI_TYPE_IPV4_LABELLED_UNICAST: 2,
	AFI_SAFI_TYPE_IPV6_LABELLED_UNICAST: 3,
	AFI_SAFI_TYPE_L3VPN_IPV4_UNICAST:    4,
	AFI_SAFI_TYPE_L3VPN_IPV6_UNICAST:    5,
	AFI_SAFI_TYPE_L3VPN_IPV4_MULTICAST:  6,
	AFI_SAFI_TYPE_L3VPN_IPV6_MULTICAST:  7,
	AFI_SAFI_TYPE_L2VPN_VPLS:            8,
	AFI_SAFI_TYPE_L2VPN_EVPN:            9,
	AFI_SAFI_TYPE_IPV4_MULTICAST:        10,
	AFI_SAFI_TYPE_IPV6_MULTICAST:        11,
	AFI_SAFI_TYPE_RTC:                   12,
	AFI_SAFI_TYPE_IPV4_ENCAP:            13,
	AFI_SAFI_TYPE_IPV6_ENCAP:            14,
	AFI_SAFI_TYPE_IPV4_FLOWSPEC:         15,
	AFI_SAFI_TYPE_L3VPN_IPV4_FLOWSPEC:   16,
	AFI_SAFI_TYPE_IPV6_FLOWSPEC:         17,
	AFI_SAFI_TYPE_L3VPN_IPV6_FLOWSPEC:   18,
	AFI_SAFI_TYPE_L2VPN_FLOWSPEC:        19,
	AFI_SAFI_TYPE_OPAQUE:                20,
}
View Source 
var AttributeComparisonToIntMap = map[AttributeComparison]int{
	ATTRIBUTE_COMPARISON_ATTRIBUTE_EQ: 0,
	ATTRIBUTE_COMPARISON_ATTRIBUTE_GE: 1,
	ATTRIBUTE_COMPARISON_ATTRIBUTE_LE: 2,
	ATTRIBUTE_COMPARISON_EQ:           3,
	ATTRIBUTE_COMPARISON_GE:           4,
	ATTRIBUTE_COMPARISON_LE:           5,
}
View Source 
var BgpCapabilityToIntMap = map[BgpCapability]int{
	BGP_CAPABILITY_MPBGP:            0,
	BGP_CAPABILITY_ROUTE_REFRESH:    1,
	BGP_CAPABILITY_ASN32:            2,
	BGP_CAPABILITY_GRACEFUL_RESTART: 3,
	BGP_CAPABILITY_ADD_PATHS:        4,
}
View Source 
var BgpOriginAttrTypeToIntMap = map[BgpOriginAttrType]int{
	BGP_ORIGIN_ATTR_TYPE_IGP:        0,
	BGP_ORIGIN_ATTR_TYPE_EGP:        1,
	BGP_ORIGIN_ATTR_TYPE_INCOMPLETE: 2,
}
View Source 
var BgpSessionDirectionToIntMap = map[BgpSessionDirection]int{
	BGP_SESSION_DIRECTION_INBOUND:  0,
	BGP_SESSION_DIRECTION_OUTBOUND: 1,
}
View Source 
var BgpSetCommunityOptionTypeToIntMap = map[BgpSetCommunityOptionType]int{
	BGP_SET_COMMUNITY_OPTION_TYPE_ADD:     0,
	BGP_SET_COMMUNITY_OPTION_TYPE_REMOVE:  1,
	BGP_SET_COMMUNITY_OPTION_TYPE_REPLACE: 2,
}
View Source 
var BgpWellKnownStdCommunityToIntMap = map[BgpWellKnownStdCommunity]int{
	BGP_WELL_KNOWN_STD_COMMUNITY_NO_EXPORT:           0,
	BGP_WELL_KNOWN_STD_COMMUNITY_NO_ADVERTISE:        1,
	BGP_WELL_KNOWN_STD_COMMUNITY_NO_EXPORT_SUBCONFED: 2,
	BGP_WELL_KNOWN_STD_COMMUNITY_NOPEER:              3,
}
View Source 
var BmpRouteMonitoringPolicyTypeToIntMap = map[BmpRouteMonitoringPolicyType]int{
	BMP_ROUTE_MONITORING_POLICY_TYPE_PRE_POLICY:  0,
	BMP_ROUTE_MONITORING_POLICY_TYPE_POST_POLICY: 1,
	BMP_ROUTE_MONITORING_POLICY_TYPE_BOTH:        2,
	BMP_ROUTE_MONITORING_POLICY_TYPE_LOCAL_RIB:   3,
	BMP_ROUTE_MONITORING_POLICY_TYPE_ALL:         4,
}
View Source 
var CommunityTypeToIntMap = map[CommunityType]int{
	COMMUNITY_TYPE_STANDARD: 0,
	COMMUNITY_TYPE_EXTENDED: 1,
	COMMUNITY_TYPE_BOTH:     2,
	COMMUNITY_TYPE_NONE:     3,
}
View Source 
var DefaultPolicyTypeToIntMap = map[DefaultPolicyType]int{
	DEFAULT_POLICY_TYPE_ACCEPT_ROUTE: 0,
	DEFAULT_POLICY_TYPE_REJECT_ROUTE: 1,
}
View Source 
var InstallProtocolTypeToIntMap = map[InstallProtocolType]int{
	INSTALL_PROTOCOL_TYPE_BGP:                0,
	INSTALL_PROTOCOL_TYPE_ISIS:               1,
	INSTALL_PROTOCOL_TYPE_OSPF:               2,
	INSTALL_PROTOCOL_TYPE_OSPF3:              3,
	INSTALL_PROTOCOL_TYPE_STATIC:             4,
	INSTALL_PROTOCOL_TYPE_DIRECTLY_CONNECTED: 5,
	INSTALL_PROTOCOL_TYPE_LOCAL_AGGREGATE:    6,
}
View Source 
var IntToAdminStateMap = map[int]AdminState{
	0: ADMIN_STATE_UP,
	1: ADMIN_STATE_DOWN,
	2: ADMIN_STATE_PFX_CT,
}
View Source 
var IntToAfiSafiTypeMap = map[int]AfiSafiType{
	0:  AFI_SAFI_TYPE_IPV4_UNICAST,
	1:  AFI_SAFI_TYPE_IPV6_UNICAST,
	2:  AFI_SAFI_TYPE_IPV4_LABELLED_UNICAST,
	3:  AFI_SAFI_TYPE_IPV6_LABELLED_UNICAST,
	4:  AFI_SAFI_TYPE_L3VPN_IPV4_UNICAST,
	5:  AFI_SAFI_TYPE_L3VPN_IPV6_UNICAST,
	6:  AFI_SAFI_TYPE_L3VPN_IPV4_MULTICAST,
	7:  AFI_SAFI_TYPE_L3VPN_IPV6_MULTICAST,
	8:  AFI_SAFI_TYPE_L2VPN_VPLS,
	9:  AFI_SAFI_TYPE_L2VPN_EVPN,
	10: AFI_SAFI_TYPE_IPV4_MULTICAST,
	11: AFI_SAFI_TYPE_IPV6_MULTICAST,
	12: AFI_SAFI_TYPE_RTC,
	13: AFI_SAFI_TYPE_IPV4_ENCAP,
	14: AFI_SAFI_TYPE_IPV6_ENCAP,
	15: AFI_SAFI_TYPE_IPV4_FLOWSPEC,
	16: AFI_SAFI_TYPE_L3VPN_IPV4_FLOWSPEC,
	17: AFI_SAFI_TYPE_IPV6_FLOWSPEC,
	18: AFI_SAFI_TYPE_L3VPN_IPV6_FLOWSPEC,
	19: AFI_SAFI_TYPE_L2VPN_FLOWSPEC,
	20: AFI_SAFI_TYPE_OPAQUE,
}
View Source 
var IntToAttributeComparisonMap = map[int]AttributeComparison{
	0: ATTRIBUTE_COMPARISON_ATTRIBUTE_EQ,
	1: ATTRIBUTE_COMPARISON_ATTRIBUTE_GE,
	2: ATTRIBUTE_COMPARISON_ATTRIBUTE_LE,
	3: ATTRIBUTE_COMPARISON_EQ,
	4: ATTRIBUTE_COMPARISON_GE,
	5: ATTRIBUTE_COMPARISON_LE,
}
View Source 
var IntToBgpCapabilityMap = map[int]BgpCapability{
	0: BGP_CAPABILITY_MPBGP,
	1: BGP_CAPABILITY_ROUTE_REFRESH,
	2: BGP_CAPABILITY_ASN32,
	3: BGP_CAPABILITY_GRACEFUL_RESTART,
	4: BGP_CAPABILITY_ADD_PATHS,
}
View Source 
var IntToBgpOriginAttrTypeMap = map[int]BgpOriginAttrType{
	0: BGP_ORIGIN_ATTR_TYPE_IGP,
	1: BGP_ORIGIN_ATTR_TYPE_EGP,
	2: BGP_ORIGIN_ATTR_TYPE_INCOMPLETE,
}
View Source 
var IntToBgpSessionDirectionMap = map[int]BgpSessionDirection{
	0: BGP_SESSION_DIRECTION_INBOUND,
	1: BGP_SESSION_DIRECTION_OUTBOUND,
}
View Source 
var IntToBgpSetCommunityOptionTypeMap = map[int]BgpSetCommunityOptionType{
	0: BGP_SET_COMMUNITY_OPTION_TYPE_ADD,
	1: BGP_SET_COMMUNITY_OPTION_TYPE_REMOVE,
	2: BGP_SET_COMMUNITY_OPTION_TYPE_REPLACE,
}
View Source 
var IntToBgpWellKnownStdCommunityMap = map[int]BgpWellKnownStdCommunity{
	0: BGP_WELL_KNOWN_STD_COMMUNITY_NO_EXPORT,
	1: BGP_WELL_KNOWN_STD_COMMUNITY_NO_ADVERTISE,
	2: BGP_WELL_KNOWN_STD_COMMUNITY_NO_EXPORT_SUBCONFED,
	3: BGP_WELL_KNOWN_STD_COMMUNITY_NOPEER,
}
View Source 
var IntToBmpRouteMonitoringPolicyTypeMap = map[int]BmpRouteMonitoringPolicyType{
	0: BMP_ROUTE_MONITORING_POLICY_TYPE_PRE_POLICY,
	1: BMP_ROUTE_MONITORING_POLICY_TYPE_POST_POLICY,
	2: BMP_ROUTE_MONITORING_POLICY_TYPE_BOTH,
	3: BMP_ROUTE_MONITORING_POLICY_TYPE_LOCAL_RIB,
	4: BMP_ROUTE_MONITORING_POLICY_TYPE_ALL,
}
View Source 
var IntToCommunityTypeMap = map[int]CommunityType{
	0: COMMUNITY_TYPE_STANDARD,
	1: COMMUNITY_TYPE_EXTENDED,
	2: COMMUNITY_TYPE_BOTH,
	3: COMMUNITY_TYPE_NONE,
}
View Source 
var IntToDefaultPolicyTypeMap = map[int]DefaultPolicyType{
	0: DEFAULT_POLICY_TYPE_ACCEPT_ROUTE,
	1: DEFAULT_POLICY_TYPE_REJECT_ROUTE,
}
View Source 
var IntToInstallProtocolTypeMap = map[int]InstallProtocolType{
	0: INSTALL_PROTOCOL_TYPE_BGP,
	1: INSTALL_PROTOCOL_TYPE_ISIS,
	2: INSTALL_PROTOCOL_TYPE_OSPF,
	3: INSTALL_PROTOCOL_TYPE_OSPF3,
	4: INSTALL_PROTOCOL_TYPE_STATIC,
	5: INSTALL_PROTOCOL_TYPE_DIRECTLY_CONNECTED,
	6: INSTALL_PROTOCOL_TYPE_LOCAL_AGGREGATE,
}
View Source 
var IntToMatchSetOptionsRestrictedTypeMap = map[int]MatchSetOptionsRestrictedType{
	0: MATCH_SET_OPTIONS_RESTRICTED_TYPE_ANY,
	1: MATCH_SET_OPTIONS_RESTRICTED_TYPE_INVERT,
}
View Source 
var IntToMatchSetOptionsTypeMap = map[int]MatchSetOptionsType{
	0: MATCH_SET_OPTIONS_TYPE_ANY,
	1: MATCH_SET_OPTIONS_TYPE_ALL,
	2: MATCH_SET_OPTIONS_TYPE_INVERT,
}
View Source 
var IntToModeMap = map[int]Mode{
	0: MODE_HELPER_ONLY,
	1: MODE_BILATERAL,
	2: MODE_REMOTE_HELPER,
}
View Source 
var IntToMrtTypeMap = map[int]MrtType{
	0: MRT_TYPE_UPDATES,
	1: MRT_TYPE_TABLE,
}
View Source 
var IntToPeerTypeMap = map[int]PeerType{
	0: PEER_TYPE_INTERNAL,
	1: PEER_TYPE_EXTERNAL,
}
View Source 
var IntToRemovePrivateAsOptionMap = map[int]RemovePrivateAsOption{
	0: REMOVE_PRIVATE_AS_OPTION_ALL,
	1: REMOVE_PRIVATE_AS_OPTION_REPLACE,
}
View Source 
var IntToRouteDispositionMap = map[int]RouteDisposition{
	0: ROUTE_DISPOSITION_NONE,
	1: ROUTE_DISPOSITION_ACCEPT_ROUTE,
	2: ROUTE_DISPOSITION_REJECT_ROUTE,
}
View Source 
var IntToRouteTypeMap = map[int]RouteType{
	0: ROUTE_TYPE_NONE,
	1: ROUTE_TYPE_INTERNAL,
	2: ROUTE_TYPE_EXTERNAL,
	3: ROUTE_TYPE_LOCAL,
}
View Source 
var IntToRpkiValidationResultTypeMap = map[int]RpkiValidationResultType{
	0: RPKI_VALIDATION_RESULT_TYPE_NONE,
	1: RPKI_VALIDATION_RESULT_TYPE_NOT_FOUND,
	2: RPKI_VALIDATION_RESULT_TYPE_VALID,
	3: RPKI_VALIDATION_RESULT_TYPE_INVALID,
}
View Source 
var IntToSessionStateMap = map[int]SessionState{
	0: SESSION_STATE_IDLE,
	1: SESSION_STATE_CONNECT,
	2: SESSION_STATE_ACTIVE,
	3: SESSION_STATE_OPENSENT,
	4: SESSION_STATE_OPENCONFIRM,
	5: SESSION_STATE_ESTABLISHED,
}
View Source 
var MatchSetOptionsRestrictedTypeToIntMap = map[MatchSetOptionsRestrictedType]int{
	MATCH_SET_OPTIONS_RESTRICTED_TYPE_ANY:    0,
	MATCH_SET_OPTIONS_RESTRICTED_TYPE_INVERT: 1,
}
View Source 
var MatchSetOptionsTypeToIntMap = map[MatchSetOptionsType]int{
	MATCH_SET_OPTIONS_TYPE_ANY:    0,
	MATCH_SET_OPTIONS_TYPE_ALL:    1,
	MATCH_SET_OPTIONS_TYPE_INVERT: 2,
}
View Source 
var ModeToIntMap = map[Mode]int{
	MODE_HELPER_ONLY:   0,
	MODE_BILATERAL:     1,
	MODE_REMOTE_HELPER: 2,
}
View Source 
var MrtTypeToIntMap = map[MrtType]int{
	MRT_TYPE_UPDATES: 0,
	MRT_TYPE_TABLE:   1,
}
View Source 
var PeerTypeToIntMap = map[PeerType]int{
	PEER_TYPE_INTERNAL: 0,
	PEER_TYPE_EXTERNAL: 1,
}
View Source 
var RemovePrivateAsOptionToIntMap = map[RemovePrivateAsOption]int{
	REMOVE_PRIVATE_AS_OPTION_ALL:     0,
	REMOVE_PRIVATE_AS_OPTION_REPLACE: 1,
}
View Source 
var RouteDispositionToIntMap = map[RouteDisposition]int{
	ROUTE_DISPOSITION_NONE:         0,
	ROUTE_DISPOSITION_ACCEPT_ROUTE: 1,
	ROUTE_DISPOSITION_REJECT_ROUTE: 2,
}
View Source 
var RouteTypeToIntMap = map[RouteType]int{
	ROUTE_TYPE_NONE:     0,
	ROUTE_TYPE_INTERNAL: 1,
	ROUTE_TYPE_EXTERNAL: 2,
	ROUTE_TYPE_LOCAL:    3,
}
View Source 
var RpkiValidationResultTypeToIntMap = map[RpkiValidationResultType]int{
	RPKI_VALIDATION_RESULT_TYPE_NONE:      0,
	RPKI_VALIDATION_RESULT_TYPE_NOT_FOUND: 1,
	RPKI_VALIDATION_RESULT_TYPE_VALID:     2,
	RPKI_VALIDATION_RESULT_TYPE_INVALID:   3,
}
View Source 
var SessionStateToIntMap = map[SessionState]int{
	SESSION_STATE_IDLE:        0,
	SESSION_STATE_CONNECT:     1,
	SESSION_STATE_ACTIVE:      2,
	SESSION_STATE_OPENSENT:    3,
	SESSION_STATE_OPENCONFIRM: 4,
	SESSION_STATE_ESTABLISHED: 5,
}

Functions

func CheckAfiSafisChange 

func CheckAfiSafisChange(x, y []AfiSafi) bool

func CheckPolicyDifference 

func CheckPolicyDifference(currentPolicy *RoutingPolicy, newPolicy *RoutingPolicy) bool

func CreateRfMap 

func CreateRfMap(p *Neighbor) map[bgp.RouteFamily]bool

func GetIPv6LinkLocalNeighborAddress 

func GetIPv6LinkLocalNeighborAddress(ifname string) (string, error)

func IsConfederationMember 

func IsConfederationMember(g *Global, p *Neighbor) bool

func IsEBGPPeer 

func IsEBGPPeer(g *Global, p *Neighbor) bool

func OverwriteNeighborConfigWithPeerGroup 

func OverwriteNeighborConfigWithPeerGroup(c *Neighbor, pg *PeerGroup) error

func ParseMaskLength 

func ParseMaskLength(prefix, mask string) (int, int, error)

func ReadConfigfileServe 

func ReadConfigfileServe(path, format string, configCh chan *BgpConfigSet)

func RegisterConfiguredFields 

func RegisterConfiguredFields(addr string, n interface{})

func SetDefaultConfigValues 

func SetDefaultConfigValues(b *BgpConfigSet) error

func SetDefaultGlobalConfigValues 

func SetDefaultGlobalConfigValues(g *Global) error

func SetDefaultNeighborConfigValues 

func SetDefaultNeighborConfigValues(n *Neighbor, asn uint32) error

func UpdateNeighborConfig 

func UpdateNeighborConfig(curC, newC *BgpConfigSet) ([]Neighbor, []Neighbor, []Neighbor)

func UpdatePeerGroupConfig 

func UpdatePeerGroupConfig(curC, newC *BgpConfigSet) ([]PeerGroup, []PeerGroup, []PeerGroup)

Types

type Actions 

type Actions struct {
	// original -> rpol:route-disposition
	RouteDisposition RouteDisposition `mapstructure:"route-disposition" json:"route-disposition,omitempty"`
	// original -> rpol:igp-actions
	IgpActions IgpActions `mapstructure:"igp-actions" json:"igp-actions,omitempty"`
	// original -> bgp-pol:bgp-actions
	BgpActions BgpActions `mapstructure:"bgp-actions" json:"bgp-actions,omitempty"`
}

struct for container rpol:actions

func (*Actions) Equal 

func (lhs *Actions) Equal(rhs *Actions) bool

type AddPaths 

type AddPaths struct {
	// original -> bgp:add-paths-config
	Config AddPathsConfig `mapstructure:"config" json:"config,omitempty"`
	// original -> bgp:add-paths-state
	State AddPathsState `mapstructure:"state" json:"state,omitempty"`
}

struct for container bgp:add-paths

func (*AddPaths) Equal 

func (lhs *AddPaths) Equal(rhs *AddPaths) bool

type AddPathsConfig 

type AddPathsConfig struct {
	// original -> bgp:receive
	//bgp:receive's original type is boolean
	Receive bool `mapstructure:"receive" json:"receive,omitempty"`
	// original -> bgp:send-max
	SendMax uint8 `mapstructure:"send-max" json:"send-max,omitempty"`
}

struct for container bgp:config

func (*AddPathsConfig) Equal 

func (lhs *AddPathsConfig) Equal(rhs *AddPathsConfig) bool

type AddPathsState 

type AddPathsState struct {
	// original -> bgp:receive
	//bgp:receive's original type is boolean
	Receive bool `mapstructure:"receive" json:"receive,omitempty"`
	// original -> bgp:send-max
	SendMax uint8 `mapstructure:"send-max" json:"send-max,omitempty"`
}

struct for container bgp:state

type AdjTable 

type AdjTable struct {
	// original -> gobgp:ADVERTISED
	Advertised uint32 `mapstructure:"advertised" json:"advertised,omitempty"`
	// original -> gobgp:FILTERED
	Filtered uint32 `mapstructure:"filtered" json:"filtered,omitempty"`
	// original -> gobgp:RECEIVED
	Received uint32 `mapstructure:"received" json:"received,omitempty"`
	// original -> gobgp:ACCEPTED
	Accepted uint32 `mapstructure:"accepted" json:"accepted,omitempty"`
}

struct for container gobgp:adj-table

func (*AdjTable) Equal 

func (lhs *AdjTable) Equal(rhs *AdjTable) bool

type AdminState 

type AdminState string

typedef for identity bgp:admin-state 

const (
	ADMIN_STATE_UP     AdminState = "up"
	ADMIN_STATE_DOWN   AdminState = "down"
	ADMIN_STATE_PFX_CT AdminState = "pfx_ct"
)

func (AdminState) ToInt 

func (v AdminState) ToInt() int

func (AdminState) Validate 

func (v AdminState) Validate() error

type AfiSafi 

type AfiSafi struct {
	// original -> bgp-mp:afi-safi-name
	// original -> bgp-mp:mp-graceful-restart
	MpGracefulRestart MpGracefulRestart `mapstructure:"mp-graceful-restart" json:"mp-graceful-restart,omitempty"`
	// original -> bgp-mp:afi-safi-config
	Config AfiSafiConfig `mapstructure:"config" json:"config,omitempty"`
	// original -> bgp-mp:afi-safi-state
	State AfiSafiState `mapstructure:"state" json:"state,omitempty"`
	// original -> rpol:apply-policy
	ApplyPolicy ApplyPolicy `mapstructure:"apply-policy" json:"apply-policy,omitempty"`
	// original -> bgp-mp:ipv4-unicast
	Ipv4Unicast Ipv4Unicast `mapstructure:"ipv4-unicast" json:"ipv4-unicast,omitempty"`
	// original -> bgp-mp:ipv6-unicast
	Ipv6Unicast Ipv6Unicast `mapstructure:"ipv6-unicast" json:"ipv6-unicast,omitempty"`
	// original -> bgp-mp:ipv4-labelled-unicast
	Ipv4LabelledUnicast Ipv4LabelledUnicast `mapstructure:"ipv4-labelled-unicast" json:"ipv4-labelled-unicast,omitempty"`
	// original -> bgp-mp:ipv6-labelled-unicast
	Ipv6LabelledUnicast Ipv6LabelledUnicast `mapstructure:"ipv6-labelled-unicast" json:"ipv6-labelled-unicast,omitempty"`
	// original -> bgp-mp:l3vpn-ipv4-unicast
	L3vpnIpv4Unicast L3vpnIpv4Unicast `mapstructure:"l3vpn-ipv4-unicast" json:"l3vpn-ipv4-unicast,omitempty"`
	// original -> bgp-mp:l3vpn-ipv6-unicast
	L3vpnIpv6Unicast L3vpnIpv6Unicast `mapstructure:"l3vpn-ipv6-unicast" json:"l3vpn-ipv6-unicast,omitempty"`
	// original -> bgp-mp:l3vpn-ipv4-multicast
	L3vpnIpv4Multicast L3vpnIpv4Multicast `mapstructure:"l3vpn-ipv4-multicast" json:"l3vpn-ipv4-multicast,omitempty"`
	// original -> bgp-mp:l3vpn-ipv6-multicast
	L3vpnIpv6Multicast L3vpnIpv6Multicast `mapstructure:"l3vpn-ipv6-multicast" json:"l3vpn-ipv6-multicast,omitempty"`
	// original -> bgp-mp:l2vpn-vpls
	L2vpnVpls L2vpnVpls `mapstructure:"l2vpn-vpls" json:"l2vpn-vpls,omitempty"`
	// original -> bgp-mp:l2vpn-evpn
	L2vpnEvpn L2vpnEvpn `mapstructure:"l2vpn-evpn" json:"l2vpn-evpn,omitempty"`
	// original -> bgp-mp:route-selection-options
	RouteSelectionOptions RouteSelectionOptions `mapstructure:"route-selection-options" json:"route-selection-options,omitempty"`
	// original -> bgp-mp:use-multiple-paths
	UseMultiplePaths UseMultiplePaths `mapstructure:"use-multiple-paths" json:"use-multiple-paths,omitempty"`
	// original -> bgp-mp:prefix-limit
	PrefixLimit PrefixLimit `mapstructure:"prefix-limit" json:"prefix-limit,omitempty"`
	// original -> gobgp:route-target-membership
	RouteTargetMembership RouteTargetMembership `mapstructure:"route-target-membership" json:"route-target-membership,omitempty"`
	// original -> gobgp:long-lived-graceful-restart
	LongLivedGracefulRestart LongLivedGracefulRestart `mapstructure:"long-lived-graceful-restart" json:"long-lived-graceful-restart,omitempty"`
}

struct for container bgp-mp:afi-safi

func GetAfiSafi 

func GetAfiSafi(p *Neighbor, family bgp.RouteFamily) *AfiSafi

func (*AfiSafi) Equal 

func (lhs *AfiSafi) Equal(rhs *AfiSafi) bool

type AfiSafiConfig 

type AfiSafiConfig struct {
	// original -> bgp-mp:afi-safi-name
	AfiSafiName AfiSafiType `mapstructure:"afi-safi-name" json:"afi-safi-name,omitempty"`
	// original -> bgp-mp:enabled
	//bgp-mp:enabled's original type is boolean
	Enabled bool `mapstructure:"enabled" json:"enabled,omitempty"`
}

struct for container bgp-mp:config

func (*AfiSafiConfig) Equal 

func (lhs *AfiSafiConfig) Equal(rhs *AfiSafiConfig) bool

type AfiSafiState 

type AfiSafiState struct {
	// original -> bgp-mp:afi-safi-name
	AfiSafiName AfiSafiType `mapstructure:"afi-safi-name" json:"afi-safi-name,omitempty"`
	// original -> bgp-mp:enabled
	//bgp-mp:enabled's original type is boolean
	Enabled bool `mapstructure:"enabled" json:"enabled,omitempty"`
	// original -> bgp-op:total-paths
	TotalPaths uint32 `mapstructure:"total-paths" json:"total-paths,omitempty"`
	// original -> bgp-op:total-prefixes
	TotalPrefixes uint32 `mapstructure:"total-prefixes" json:"total-prefixes,omitempty"`
}

struct for container bgp-mp:state

type AfiSafiType 

type AfiSafiType string

typedef for identity bgp-types:afi-safi-type 

const (
	AFI_SAFI_TYPE_IPV4_UNICAST          AfiSafiType = "ipv4-unicast"
	AFI_SAFI_TYPE_IPV6_UNICAST          AfiSafiType = "ipv6-unicast"
	AFI_SAFI_TYPE_IPV4_LABELLED_UNICAST AfiSafiType = "ipv4-labelled-unicast"
	AFI_SAFI_TYPE_IPV6_LABELLED_UNICAST AfiSafiType = "ipv6-labelled-unicast"
	AFI_SAFI_TYPE_L3VPN_IPV4_UNICAST    AfiSafiType = "l3vpn-ipv4-unicast"
	AFI_SAFI_TYPE_L3VPN_IPV6_UNICAST    AfiSafiType = "l3vpn-ipv6-unicast"
	AFI_SAFI_TYPE_L3VPN_IPV4_MULTICAST  AfiSafiType = "l3vpn-ipv4-multicast"
	AFI_SAFI_TYPE_L3VPN_IPV6_MULTICAST  AfiSafiType = "l3vpn-ipv6-multicast"
	AFI_SAFI_TYPE_L2VPN_VPLS            AfiSafiType = "l2vpn-vpls"
	AFI_SAFI_TYPE_L2VPN_EVPN            AfiSafiType = "l2vpn-evpn"
	AFI_SAFI_TYPE_IPV4_MULTICAST        AfiSafiType = "ipv4-multicast"
	AFI_SAFI_TYPE_IPV6_MULTICAST        AfiSafiType = "ipv6-multicast"
	AFI_SAFI_TYPE_RTC                   AfiSafiType = "rtc"
	AFI_SAFI_TYPE_IPV4_ENCAP            AfiSafiType = "ipv4-encap"
	AFI_SAFI_TYPE_IPV6_ENCAP            AfiSafiType = "ipv6-encap"
	AFI_SAFI_TYPE_IPV4_FLOWSPEC         AfiSafiType = "ipv4-flowspec"
	AFI_SAFI_TYPE_L3VPN_IPV4_FLOWSPEC   AfiSafiType = "l3vpn-ipv4-flowspec"
	AFI_SAFI_TYPE_IPV6_FLOWSPEC         AfiSafiType = "ipv6-flowspec"
	AFI_SAFI_TYPE_L3VPN_IPV6_FLOWSPEC   AfiSafiType = "l3vpn-ipv6-flowspec"
	AFI_SAFI_TYPE_L2VPN_FLOWSPEC        AfiSafiType = "l2vpn-flowspec"
	AFI_SAFI_TYPE_OPAQUE                AfiSafiType = "opaque"
)

func (AfiSafiType) ToInt 

func (v AfiSafiType) ToInt() int

func (AfiSafiType) Validate 

func (v AfiSafiType) Validate() error

type AfiSafis 

type AfiSafis []AfiSafi

func (AfiSafis) ToRfList 

func (c AfiSafis) ToRfList() ([]bgp.RouteFamily, error)

type ApplyPolicy 

type ApplyPolicy struct {
	// original -> rpol:apply-policy-config
	Config ApplyPolicyConfig `mapstructure:"config" json:"config,omitempty"`
	// original -> rpol:apply-policy-state
	State ApplyPolicyState `mapstructure:"state" json:"state,omitempty"`
}

struct for container rpol:apply-policy

func (*ApplyPolicy) Equal 

func (lhs *ApplyPolicy) Equal(rhs *ApplyPolicy) bool

type ApplyPolicyConfig 

type ApplyPolicyConfig struct {
	// original -> rpol:import-policy
	ImportPolicyList []string `mapstructure:"import-policy-list" json:"import-policy-list,omitempty"`
	// original -> rpol:default-import-policy
	DefaultImportPolicy DefaultPolicyType `mapstructure:"default-import-policy" json:"default-import-policy,omitempty"`
	// original -> rpol:export-policy
	ExportPolicyList []string `mapstructure:"export-policy-list" json:"export-policy-list,omitempty"`
	// original -> rpol:default-export-policy
	DefaultExportPolicy DefaultPolicyType `mapstructure:"default-export-policy" json:"default-export-policy,omitempty"`
	// original -> gobgp:in-policy
	InPolicyList []string `mapstructure:"in-policy-list" json:"in-policy-list,omitempty"`
	// original -> gobgp:default-in-policy
	DefaultInPolicy DefaultPolicyType `mapstructure:"default-in-policy" json:"default-in-policy,omitempty"`
}

struct for container rpol:config

func (*ApplyPolicyConfig) Equal 

func (lhs *ApplyPolicyConfig) Equal(rhs *ApplyPolicyConfig) bool

type ApplyPolicyState 

type ApplyPolicyState struct {
	// original -> rpol:import-policy
	ImportPolicyList []string `mapstructure:"import-policy-list" json:"import-policy-list,omitempty"`
	// original -> rpol:default-import-policy
	DefaultImportPolicy DefaultPolicyType `mapstructure:"default-import-policy" json:"default-import-policy,omitempty"`
	// original -> rpol:export-policy
	ExportPolicyList []string `mapstructure:"export-policy-list" json:"export-policy-list,omitempty"`
	// original -> rpol:default-export-policy
	DefaultExportPolicy DefaultPolicyType `mapstructure:"default-export-policy" json:"default-export-policy,omitempty"`
	// original -> gobgp:in-policy
	InPolicyList []string `mapstructure:"in-policy-list" json:"in-policy-list,omitempty"`
	// original -> gobgp:default-in-policy
	DefaultInPolicy DefaultPolicyType `mapstructure:"default-in-policy" json:"default-in-policy,omitempty"`
}

struct for container rpol:state

type AsPathLength 

type AsPathLength struct {
	// original -> ptypes:operator
	Operator AttributeComparison `mapstructure:"operator" json:"operator,omitempty"`
	// original -> ptypes:value
	Value uint32 `mapstructure:"value" json:"value,omitempty"`
}

struct for container bgp-pol:as-path-length

func (*AsPathLength) Equal 

func (lhs *AsPathLength) Equal(rhs *AsPathLength) bool

type AsPathOptions 

type AsPathOptions struct {
	// original -> bgp:as-path-options-config
	Config AsPathOptionsConfig `mapstructure:"config" json:"config,omitempty"`
	// original -> bgp:as-path-options-state
	State AsPathOptionsState `mapstructure:"state" json:"state,omitempty"`
}

struct for container bgp:as-path-options

func (*AsPathOptions) Equal 

func (lhs *AsPathOptions) Equal(rhs *AsPathOptions) bool

type AsPathOptionsConfig 

type AsPathOptionsConfig struct {
	// original -> bgp:allow-own-as
	AllowOwnAs uint8 `mapstructure:"allow-own-as" json:"allow-own-as,omitempty"`
	// original -> bgp:replace-peer-as
	//bgp:replace-peer-as's original type is boolean
	ReplacePeerAs bool `mapstructure:"replace-peer-as" json:"replace-peer-as,omitempty"`
}

struct for container bgp:config

func (*AsPathOptionsConfig) Equal 

func (lhs *AsPathOptionsConfig) Equal(rhs *AsPathOptionsConfig) bool

type AsPathOptionsState 

type AsPathOptionsState struct {
	// original -> bgp:allow-own-as
	AllowOwnAs uint8 `mapstructure:"allow-own-as" json:"allow-own-as,omitempty"`
	// original -> bgp:replace-peer-as
	//bgp:replace-peer-as's original type is boolean
	ReplacePeerAs bool `mapstructure:"replace-peer-as" json:"replace-peer-as,omitempty"`
}

struct for container bgp:state

type AsPathSet 

type AsPathSet struct {
	// original -> bgp-pol:as-path-set-name
	AsPathSetName string `mapstructure:"as-path-set-name" json:"as-path-set-name,omitempty"`
	// original -> gobgp:as-path
	AsPathList []string `mapstructure:"as-path-list" json:"as-path-list,omitempty"`
}

struct for container bgp-pol:as-path-set

func (*AsPathSet) Equal 

func (lhs *AsPathSet) Equal(rhs *AsPathSet) bool

type AttributeComparison 

type AttributeComparison string

typedef for identity ptypes:attribute-comparison 

const (
	ATTRIBUTE_COMPARISON_ATTRIBUTE_EQ AttributeComparison = "attribute-eq"
	ATTRIBUTE_COMPARISON_ATTRIBUTE_GE AttributeComparison = "attribute-ge"
	ATTRIBUTE_COMPARISON_ATTRIBUTE_LE AttributeComparison = "attribute-le"
	ATTRIBUTE_COMPARISON_EQ           AttributeComparison = "eq"
	ATTRIBUTE_COMPARISON_GE           AttributeComparison = "ge"
	ATTRIBUTE_COMPARISON_LE           AttributeComparison = "le"
)

func (AttributeComparison) ToInt 

func (v AttributeComparison) ToInt() int

func (AttributeComparison) Validate 

func (v AttributeComparison) Validate() error

type Bgp 

type Bgp struct {
	// original -> bgp:global
	Global Global `mapstructure:"global" json:"global,omitempty"`
	// original -> bgp:neighbors
	Neighbors []Neighbor `mapstructure:"neighbors" json:"neighbors,omitempty"`
	// original -> bgp:peer-groups
	PeerGroups []PeerGroup `mapstructure:"peer-groups" json:"peer-groups,omitempty"`
	// original -> gobgp:rpki-servers
	RpkiServers []RpkiServer `mapstructure:"rpki-servers" json:"rpki-servers,omitempty"`
	// original -> gobgp:bmp-servers
	BmpServers []BmpServer `mapstructure:"bmp-servers" json:"bmp-servers,omitempty"`
	// original -> gobgp:mrt-dump
	MrtDump []Mrt `mapstructure:"mrt-dump" json:"mrt-dump,omitempty"`
	// original -> gobgp:zebra
	Zebra Zebra `mapstructure:"zebra" json:"zebra,omitempty"`
	// original -> gobgp:collector
	Collector Collector `mapstructure:"collector" json:"collector,omitempty"`
}

struct for container bgp:bgp

func (*Bgp) Equal 

func (lhs *Bgp) Equal(rhs *Bgp) bool

type BgpActions 

type BgpActions struct {
	// original -> bgp-pol:set-as-path-prepend
	SetAsPathPrepend SetAsPathPrepend `mapstructure:"set-as-path-prepend" json:"set-as-path-prepend,omitempty"`
	// original -> bgp-pol:set-community
	SetCommunity SetCommunity `mapstructure:"set-community" json:"set-community,omitempty"`
	// original -> bgp-pol:set-ext-community
	SetExtCommunity SetExtCommunity `mapstructure:"set-ext-community" json:"set-ext-community,omitempty"`
	// original -> bgp-pol:set-route-origin
	SetRouteOrigin BgpOriginAttrType `mapstructure:"set-route-origin" json:"set-route-origin,omitempty"`
	// original -> bgp-pol:set-local-pref
	SetLocalPref uint32 `mapstructure:"set-local-pref" json:"set-local-pref,omitempty"`
	// original -> bgp-pol:set-next-hop
	SetNextHop BgpNextHopType `mapstructure:"set-next-hop" json:"set-next-hop,omitempty"`
	// original -> bgp-pol:set-med
	SetMed BgpSetMedType `mapstructure:"set-med" json:"set-med,omitempty"`
	// original -> gobgp:set-large-community
	SetLargeCommunity SetLargeCommunity `mapstructure:"set-large-community" json:"set-large-community,omitempty"`
}

struct for container bgp-pol:bgp-actions

func (*BgpActions) Equal 

func (lhs *BgpActions) Equal(rhs *BgpActions) bool

type BgpAsPathPrependRepeat 

type BgpAsPathPrependRepeat uint8

typedef for typedef bgp-pol:bgp-as-path-prepend-repeat

type BgpCapability 

type BgpCapability string

typedef for identity bgp-types:bgp-capability 

const (
	BGP_CAPABILITY_MPBGP            BgpCapability = "mpbgp"
	BGP_CAPABILITY_ROUTE_REFRESH    BgpCapability = "route-refresh"
	BGP_CAPABILITY_ASN32            BgpCapability = "asn32"
	BGP_CAPABILITY_GRACEFUL_RESTART BgpCapability = "graceful-restart"
	BGP_CAPABILITY_ADD_PATHS        BgpCapability = "add-paths"
)

func (BgpCapability) ToInt 

func (v BgpCapability) ToInt() int

func (BgpCapability) Validate 

func (v BgpCapability) Validate() error

type BgpCommunityRegexpType 

type BgpCommunityRegexpType StdRegexp

typedef for typedef bgp-types:bgp-community-regexp-type

type BgpConditions 

type BgpConditions struct {
	// original -> bgp-pol:match-community-set
	MatchCommunitySet MatchCommunitySet `mapstructure:"match-community-set" json:"match-community-set,omitempty"`
	// original -> bgp-pol:match-ext-community-set
	MatchExtCommunitySet MatchExtCommunitySet `mapstructure:"match-ext-community-set" json:"match-ext-community-set,omitempty"`
	// original -> bgp-pol:match-as-path-set
	MatchAsPathSet MatchAsPathSet `mapstructure:"match-as-path-set" json:"match-as-path-set,omitempty"`
	// original -> bgp-pol:med-eq
	MedEq uint32 `mapstructure:"med-eq" json:"med-eq,omitempty"`
	// original -> bgp-pol:origin-eq
	OriginEq BgpOriginAttrType `mapstructure:"origin-eq" json:"origin-eq,omitempty"`
	// original -> bgp-pol:next-hop-in
	// original type is list of inet:ip-address
	NextHopInList []string `mapstructure:"next-hop-in-list" json:"next-hop-in-list,omitempty"`
	// original -> bgp-pol:afi-safi-in
	AfiSafiInList []AfiSafiType `mapstructure:"afi-safi-in-list" json:"afi-safi-in-list,omitempty"`
	// original -> bgp-pol:local-pref-eq
	LocalPrefEq uint32 `mapstructure:"local-pref-eq" json:"local-pref-eq,omitempty"`
	// original -> bgp-pol:community-count
	CommunityCount CommunityCount `mapstructure:"community-count" json:"community-count,omitempty"`
	// original -> bgp-pol:as-path-length
	AsPathLength AsPathLength `mapstructure:"as-path-length" json:"as-path-length,omitempty"`
	// original -> bgp-pol:route-type
	RouteType RouteType `mapstructure:"route-type" json:"route-type,omitempty"`
	// original -> gobgp:rpki-validation-result
	RpkiValidationResult RpkiValidationResultType `mapstructure:"rpki-validation-result" json:"rpki-validation-result,omitempty"`
	// original -> gobgp:match-large-community-set
	MatchLargeCommunitySet MatchLargeCommunitySet `mapstructure:"match-large-community-set" json:"match-large-community-set,omitempty"`
}

struct for container bgp-pol:bgp-conditions

func (*BgpConditions) Equal 

func (lhs *BgpConditions) Equal(rhs *BgpConditions) bool

type BgpConfigSet 

type BgpConfigSet struct {
	Global            Global             `mapstructure:"global"`
	Neighbors         []Neighbor         `mapstructure:"neighbors"`
	PeerGroups        []PeerGroup        `mapstructure:"peer-groups"`
	RpkiServers       []RpkiServer       `mapstructure:"rpki-servers"`
	BmpServers        []BmpServer        `mapstructure:"bmp-servers"`
	MrtDump           []Mrt              `mapstructure:"mrt-dump"`
	Zebra             Zebra              `mapstructure:"zebra"`
	Collector         Collector          `mapstructure:"collector"`
	DefinedSets       DefinedSets        `mapstructure:"defined-sets"`
	PolicyDefinitions []PolicyDefinition `mapstructure:"policy-definitions"`
}

type BgpDefinedSets 

type BgpDefinedSets struct {
	// original -> bgp-pol:community-sets
	CommunitySets []CommunitySet `mapstructure:"community-sets" json:"community-sets,omitempty"`
	// original -> bgp-pol:ext-community-sets
	ExtCommunitySets []ExtCommunitySet `mapstructure:"ext-community-sets" json:"ext-community-sets,omitempty"`
	// original -> bgp-pol:as-path-sets
	AsPathSets []AsPathSet `mapstructure:"as-path-sets" json:"as-path-sets,omitempty"`
	// original -> gobgp:large-community-sets
	LargeCommunitySets []LargeCommunitySet `mapstructure:"large-community-sets" json:"large-community-sets,omitempty"`
}

struct for container bgp-pol:bgp-defined-sets

func (*BgpDefinedSets) Equal 

func (lhs *BgpDefinedSets) Equal(rhs *BgpDefinedSets) bool

type BgpExtCommunityType 

type BgpExtCommunityType string

typedef for typedef bgp-types:bgp-ext-community-type

type BgpNextHopType 

type BgpNextHopType string

typedef for typedef bgp-pol:bgp-next-hop-type

type BgpOriginAttrType 

type BgpOriginAttrType string

typedef for identity bgp-types:bgp-origin-attr-type 

const (
	BGP_ORIGIN_ATTR_TYPE_IGP        BgpOriginAttrType = "igp"
	BGP_ORIGIN_ATTR_TYPE_EGP        BgpOriginAttrType = "egp"
	BGP_ORIGIN_ATTR_TYPE_INCOMPLETE BgpOriginAttrType = "incomplete"
)

func (BgpOriginAttrType) ToInt 

func (v BgpOriginAttrType) ToInt() int

func (BgpOriginAttrType) Validate 

func (v BgpOriginAttrType) Validate() error

type BgpSessionDirection 

type BgpSessionDirection string

typedef for identity bgp-types:bgp-session-direction 

const (
	BGP_SESSION_DIRECTION_INBOUND  BgpSessionDirection = "inbound"
	BGP_SESSION_DIRECTION_OUTBOUND BgpSessionDirection = "outbound"
)

func (BgpSessionDirection) ToInt 

func (v BgpSessionDirection) ToInt() int

func (BgpSessionDirection) Validate 

func (v BgpSessionDirection) Validate() error

type BgpSetCommunityOptionType 

type BgpSetCommunityOptionType string

typedef for identity bgp-pol:bgp-set-community-option-type 

const (
	BGP_SET_COMMUNITY_OPTION_TYPE_ADD     BgpSetCommunityOptionType = "add"
	BGP_SET_COMMUNITY_OPTION_TYPE_REMOVE  BgpSetCommunityOptionType = "remove"
	BGP_SET_COMMUNITY_OPTION_TYPE_REPLACE BgpSetCommunityOptionType = "replace"
)

func (BgpSetCommunityOptionType) ToInt 

func (v BgpSetCommunityOptionType) ToInt() int

func (BgpSetCommunityOptionType) Validate 

func (v BgpSetCommunityOptionType) Validate() error

type BgpSetMedType 

type BgpSetMedType string

typedef for typedef bgp-pol:bgp-set-med-type

type BgpStdCommunityType 

type BgpStdCommunityType string

typedef for typedef bgp-types:bgp-std-community-type

type BgpWellKnownStdCommunity 

type BgpWellKnownStdCommunity string

typedef for identity bgp-types:bgp-well-known-std-community 

const (
	BGP_WELL_KNOWN_STD_COMMUNITY_NO_EXPORT           BgpWellKnownStdCommunity = "no_export"
	BGP_WELL_KNOWN_STD_COMMUNITY_NO_ADVERTISE        BgpWellKnownStdCommunity = "no_advertise"
	BGP_WELL_KNOWN_STD_COMMUNITY_NO_EXPORT_SUBCONFED BgpWellKnownStdCommunity = "no_export_subconfed"
	BGP_WELL_KNOWN_STD_COMMUNITY_NOPEER              BgpWellKnownStdCommunity = "nopeer"
)

func (BgpWellKnownStdCommunity) ToInt 

func (v BgpWellKnownStdCommunity) ToInt() int

func (BgpWellKnownStdCommunity) Validate 

func (v BgpWellKnownStdCommunity) Validate() error

type BmpRouteMonitoringPolicyType 

type BmpRouteMonitoringPolicyType string

typedef for identity gobgp:bmp-route-monitoring-policy-type 

const (
	BMP_ROUTE_MONITORING_POLICY_TYPE_PRE_POLICY  BmpRouteMonitoringPolicyType = "pre-policy"
	BMP_ROUTE_MONITORING_POLICY_TYPE_POST_POLICY BmpRouteMonitoringPolicyType = "post-policy"
	BMP_ROUTE_MONITORING_POLICY_TYPE_BOTH        BmpRouteMonitoringPolicyType = "both"
	BMP_ROUTE_MONITORING_POLICY_TYPE_LOCAL_RIB   BmpRouteMonitoringPolicyType = "local-rib"
	BMP_ROUTE_MONITORING_POLICY_TYPE_ALL         BmpRouteMonitoringPolicyType = "all"
)

func (BmpRouteMonitoringPolicyType) ToInt 

func (v BmpRouteMonitoringPolicyType) ToInt() int

func (BmpRouteMonitoringPolicyType) Validate 

func (v BmpRouteMonitoringPolicyType) Validate() error

type BmpServer 

type BmpServer struct {
	// original -> gobgp:address
	// original -> gobgp:bmp-server-config
	Config BmpServerConfig `mapstructure:"config" json:"config,omitempty"`
	// original -> gobgp:bmp-server-state
	State BmpServerState `mapstructure:"state" json:"state,omitempty"`
}

struct for container gobgp:bmp-server

func (*BmpServer) Equal 

func (lhs *BmpServer) Equal(rhs *BmpServer) bool

type BmpServerConfig 

type BmpServerConfig struct {
	// original -> gobgp:address
	//gobgp:address's original type is inet:ip-address
	Address string `mapstructure:"address" json:"address,omitempty"`
	// original -> gobgp:port
	Port uint32 `mapstructure:"port" json:"port,omitempty"`
	// original -> gobgp:route-monitoring-policy
	RouteMonitoringPolicy BmpRouteMonitoringPolicyType `mapstructure:"route-monitoring-policy" json:"route-monitoring-policy,omitempty"`
	// original -> gobgp:statistics-timeout
	StatisticsTimeout uint16 `mapstructure:"statistics-timeout" json:"statistics-timeout,omitempty"`
	// original -> gobgp:route-mirroring-enabled
	//gobgp:route-mirroring-enabled's original type is boolean
	RouteMirroringEnabled bool `mapstructure:"route-mirroring-enabled" json:"route-mirroring-enabled,omitempty"`
}

struct for container gobgp:config

func (*BmpServerConfig) Equal 

func (lhs *BmpServerConfig) Equal(rhs *BmpServerConfig) bool

type BmpServerState 

type BmpServerState struct {
}

struct for container gobgp:state

type Collector 

type Collector struct {
	// original -> gobgp:collector-config
	Config CollectorConfig `mapstructure:"config" json:"config,omitempty"`
	// original -> gobgp:collector-state
	State CollectorState `mapstructure:"state" json:"state,omitempty"`
}

struct for container gobgp:collector

func (*Collector) Equal 

func (lhs *Collector) Equal(rhs *Collector) bool

type CollectorConfig 

type CollectorConfig struct {
	// original -> gobgp:url
	Url string `mapstructure:"url" json:"url,omitempty"`
	// original -> gobgp:db-name
	DbName string `mapstructure:"db-name" json:"db-name,omitempty"`
	// original -> gobgp:table-dump-interval
	TableDumpInterval uint64 `mapstructure:"table-dump-interval" json:"table-dump-interval,omitempty"`
}

struct for container gobgp:config

func (*CollectorConfig) Equal 

func (lhs *CollectorConfig) Equal(rhs *CollectorConfig) bool

type CollectorState 

type CollectorState struct {
	// original -> gobgp:url
	Url string `mapstructure:"url" json:"url,omitempty"`
	// original -> gobgp:db-name
	DbName string `mapstructure:"db-name" json:"db-name,omitempty"`
	// original -> gobgp:table-dump-interval
	TableDumpInterval uint64 `mapstructure:"table-dump-interval" json:"table-dump-interval,omitempty"`
}

struct for container gobgp:state

type CommunityCount 

type CommunityCount struct {
	// original -> ptypes:operator
	Operator AttributeComparison `mapstructure:"operator" json:"operator,omitempty"`
	// original -> ptypes:value
	Value uint32 `mapstructure:"value" json:"value,omitempty"`
}

struct for container bgp-pol:community-count

func (*CommunityCount) Equal 

func (lhs *CommunityCount) Equal(rhs *CommunityCount) bool

type CommunitySet 

type CommunitySet struct {
	// original -> bgp-pol:community-set-name
	CommunitySetName string `mapstructure:"community-set-name" json:"community-set-name,omitempty"`
	// original -> gobgp:community
	CommunityList []string `mapstructure:"community-list" json:"community-list,omitempty"`
}

struct for container bgp-pol:community-set

func (*CommunitySet) Equal 

func (lhs *CommunitySet) Equal(rhs *CommunitySet) bool

type CommunityType 

type CommunityType string

typedef for identity bgp-types:community-type 

const (
	COMMUNITY_TYPE_STANDARD CommunityType = "standard"
	COMMUNITY_TYPE_EXTENDED CommunityType = "extended"
	COMMUNITY_TYPE_BOTH     CommunityType = "both"
	COMMUNITY_TYPE_NONE     CommunityType = "none"
)

func (CommunityType) ToInt 

func (v CommunityType) ToInt() int

func (CommunityType) Validate 

func (v CommunityType) Validate() error

type Conditions 

type Conditions struct {
	// original -> rpol:call-policy
	CallPolicy string `mapstructure:"call-policy" json:"call-policy,omitempty"`
	// original -> rpol:match-prefix-set
	MatchPrefixSet MatchPrefixSet `mapstructure:"match-prefix-set" json:"match-prefix-set,omitempty"`
	// original -> rpol:match-neighbor-set
	MatchNeighborSet MatchNeighborSet `mapstructure:"match-neighbor-set" json:"match-neighbor-set,omitempty"`
	// original -> rpol:match-tag-set
	MatchTagSet MatchTagSet `mapstructure:"match-tag-set" json:"match-tag-set,omitempty"`
	// original -> rpol:install-protocol-eq
	InstallProtocolEq InstallProtocolType `mapstructure:"install-protocol-eq" json:"install-protocol-eq,omitempty"`
	// original -> rpol:igp-conditions
	IgpConditions IgpConditions `mapstructure:"igp-conditions" json:"igp-conditions,omitempty"`
	// original -> bgp-pol:bgp-conditions
	BgpConditions BgpConditions `mapstructure:"bgp-conditions" json:"bgp-conditions,omitempty"`
}

struct for container rpol:conditions

func (*Conditions) Equal 

func (lhs *Conditions) Equal(rhs *Conditions) bool

type Confederation 

type Confederation struct {
	// original -> bgp:confederation-config
	Config ConfederationConfig `mapstructure:"config" json:"config,omitempty"`
	// original -> bgp:confederation-state
	State ConfederationState `mapstructure:"state" json:"state,omitempty"`
}

struct for container bgp:confederation

func (*Confederation) Equal 

func (lhs *Confederation) Equal(rhs *Confederation) bool

type ConfederationConfig 

type ConfederationConfig struct {
	// original -> bgp:enabled
	//bgp:enabled's original type is boolean
	Enabled bool `mapstructure:"enabled" json:"enabled,omitempty"`
	// original -> bgp:identifier
	//bgp:identifier's original type is inet:as-number
	Identifier uint32 `mapstructure:"identifier" json:"identifier,omitempty"`
	// original -> bgp:member-as
	// original type is list of inet:as-number
	MemberAsList []uint32 `mapstructure:"member-as-list" json:"member-as-list,omitempty"`
}

struct for container bgp:config

func (*ConfederationConfig) Equal 

func (lhs *ConfederationConfig) Equal(rhs *ConfederationConfig) bool

type ConfederationState 

type ConfederationState struct {
	// original -> bgp:enabled
	//bgp:enabled's original type is boolean
	Enabled bool `mapstructure:"enabled" json:"enabled,omitempty"`
	// original -> bgp:identifier
	//bgp:identifier's original type is inet:as-number
	Identifier uint32 `mapstructure:"identifier" json:"identifier,omitempty"`
	// original -> bgp:member-as
	// original type is list of inet:as-number
	MemberAsList []uint32 `mapstructure:"member-as-list" json:"member-as-list,omitempty"`
}

struct for container bgp:state

type DefaultPolicyType 

type DefaultPolicyType string

typedef for identity rpol:default-policy-type 

const (
	DEFAULT_POLICY_TYPE_ACCEPT_ROUTE DefaultPolicyType = "accept-route"
	DEFAULT_POLICY_TYPE_REJECT_ROUTE DefaultPolicyType = "reject-route"
)

func (DefaultPolicyType) ToInt 

func (v DefaultPolicyType) ToInt() int

func (DefaultPolicyType) Validate 

func (v DefaultPolicyType) Validate() error

type DefaultRouteDistance 

type DefaultRouteDistance struct {
	// original -> bgp:default-route-distance-config
	Config DefaultRouteDistanceConfig `mapstructure:"config" json:"config,omitempty"`
	// original -> bgp:default-route-distance-state
	State DefaultRouteDistanceState `mapstructure:"state" json:"state,omitempty"`
}

struct for container bgp:default-route-distance

func (*DefaultRouteDistance) Equal 

func (lhs *DefaultRouteDistance) Equal(rhs *DefaultRouteDistance) bool

type DefaultRouteDistanceConfig 

type DefaultRouteDistanceConfig struct {
	// original -> bgp:external-route-distance
	ExternalRouteDistance uint8 `mapstructure:"external-route-distance" json:"external-route-distance,omitempty"`
	// original -> bgp:internal-route-distance
	InternalRouteDistance uint8 `mapstructure:"internal-route-distance" json:"internal-route-distance,omitempty"`
}

struct for container bgp:config

func (*DefaultRouteDistanceConfig) Equal 

func (lhs *DefaultRouteDistanceConfig) Equal(rhs *DefaultRouteDistanceConfig) bool

type DefaultRouteDistanceState 

type DefaultRouteDistanceState struct {
	// original -> bgp:external-route-distance
	ExternalRouteDistance uint8 `mapstructure:"external-route-distance" json:"external-route-distance,omitempty"`
	// original -> bgp:internal-route-distance
	InternalRouteDistance uint8 `mapstructure:"internal-route-distance" json:"internal-route-distance,omitempty"`
}

struct for container bgp:state

type DefinedSets 

type DefinedSets struct {
	// original -> rpol:prefix-sets
	PrefixSets []PrefixSet `mapstructure:"prefix-sets" json:"prefix-sets,omitempty"`
	// original -> rpol:neighbor-sets
	NeighborSets []NeighborSet `mapstructure:"neighbor-sets" json:"neighbor-sets,omitempty"`
	// original -> rpol:tag-sets
	TagSets []TagSet `mapstructure:"tag-sets" json:"tag-sets,omitempty"`
	// original -> bgp-pol:bgp-defined-sets
	BgpDefinedSets BgpDefinedSets `mapstructure:"bgp-defined-sets" json:"bgp-defined-sets,omitempty"`
}

struct for container rpol:defined-sets

func (*DefinedSets) Equal 

func (lhs *DefinedSets) Equal(rhs *DefinedSets) bool

type Ebgp 

type Ebgp struct {
	// original -> bgp-mp:ebgp-config
	Config EbgpConfig `mapstructure:"config" json:"config,omitempty"`
	// original -> bgp-mp:ebgp-state
	State EbgpState `mapstructure:"state" json:"state,omitempty"`
}

struct for container bgp-mp:ebgp

func (*Ebgp) Equal 

func (lhs *Ebgp) Equal(rhs *Ebgp) bool

type EbgpConfig 

type EbgpConfig struct {
	// original -> bgp-mp:allow-multiple-as
	//bgp-mp:allow-multiple-as's original type is boolean
	AllowMultipleAs bool `mapstructure:"allow-multiple-as" json:"allow-multiple-as,omitempty"`
	// original -> bgp-mp:maximum-paths
	MaximumPaths uint32 `mapstructure:"maximum-paths" json:"maximum-paths,omitempty"`
}

struct for container bgp-mp:config

func (*EbgpConfig) Equal 

func (lhs *EbgpConfig) Equal(rhs *EbgpConfig) bool

type EbgpMultihop 

type EbgpMultihop struct {
	// original -> bgp:ebgp-multihop-config
	Config EbgpMultihopConfig `mapstructure:"config" json:"config,omitempty"`
	// original -> bgp:ebgp-multihop-state
	State EbgpMultihopState `mapstructure:"state" json:"state,omitempty"`
}

struct for container bgp:ebgp-multihop

func (*EbgpMultihop) Equal 

func (lhs *EbgpMultihop) Equal(rhs *EbgpMultihop) bool

type EbgpMultihopConfig 

type EbgpMultihopConfig struct {
	// original -> bgp:enabled
	//bgp:enabled's original type is boolean
	Enabled bool `mapstructure:"enabled" json:"enabled,omitempty"`
	// original -> bgp:multihop-ttl
	MultihopTtl uint8 `mapstructure:"multihop-ttl" json:"multihop-ttl,omitempty"`
}

struct for container bgp:config

func (*EbgpMultihopConfig) Equal 

func (lhs *EbgpMultihopConfig) Equal(rhs *EbgpMultihopConfig) bool

type EbgpMultihopState 

type EbgpMultihopState struct {
	// original -> bgp:enabled
	//bgp:enabled's original type is boolean
	Enabled bool `mapstructure:"enabled" json:"enabled,omitempty"`
	// original -> bgp:multihop-ttl
	MultihopTtl uint8 `mapstructure:"multihop-ttl" json:"multihop-ttl,omitempty"`
}

struct for container bgp:state

type EbgpState 

type EbgpState struct {
	// original -> bgp-mp:allow-multiple-as
	//bgp-mp:allow-multiple-as's original type is boolean
	AllowMultipleAs bool `mapstructure:"allow-multiple-as" json:"allow-multiple-as,omitempty"`
	// original -> bgp-mp:maximum-paths
	MaximumPaths uint32 `mapstructure:"maximum-paths" json:"maximum-paths,omitempty"`
}

struct for container bgp-mp:state

type ErrorHandling 

type ErrorHandling struct {
	// original -> bgp:error-handling-config
	Config ErrorHandlingConfig `mapstructure:"config" json:"config,omitempty"`
	// original -> bgp:error-handling-state
	State ErrorHandlingState `mapstructure:"state" json:"state,omitempty"`
}

struct for container bgp:error-handling

func (*ErrorHandling) Equal 

func (lhs *ErrorHandling) Equal(rhs *ErrorHandling) bool

type ErrorHandlingConfig 

type ErrorHandlingConfig struct {
	// original -> bgp:treat-as-withdraw
	//bgp:treat-as-withdraw's original type is boolean
	TreatAsWithdraw bool `mapstructure:"treat-as-withdraw" json:"treat-as-withdraw,omitempty"`
}

struct for container bgp:config

func (*ErrorHandlingConfig) Equal 

func (lhs *ErrorHandlingConfig) Equal(rhs *ErrorHandlingConfig) bool

type ErrorHandlingState 

type ErrorHandlingState struct {
	// original -> bgp:treat-as-withdraw
	//bgp:treat-as-withdraw's original type is boolean
	TreatAsWithdraw bool `mapstructure:"treat-as-withdraw" json:"treat-as-withdraw,omitempty"`
	// original -> bgp-op:erroneous-update-messages
	ErroneousUpdateMessages uint32 `mapstructure:"erroneous-update-messages" json:"erroneous-update-messages,omitempty"`
}

struct for container bgp:state

type ExtCommunitySet 

type ExtCommunitySet struct {
	// original -> bgp-pol:ext-community-set-name
	ExtCommunitySetName string `mapstructure:"ext-community-set-name" json:"ext-community-set-name,omitempty"`
	// original -> gobgp:ext-community
	ExtCommunityList []string `mapstructure:"ext-community-list" json:"ext-community-list,omitempty"`
}

struct for container bgp-pol:ext-community-set

func (*ExtCommunitySet) Equal 

func (lhs *ExtCommunitySet) Equal(rhs *ExtCommunitySet) bool

type Global 

type Global struct {
	// original -> bgp:global-config
	Config GlobalConfig `mapstructure:"config" json:"config,omitempty"`
	// original -> bgp:global-state
	State GlobalState `mapstructure:"state" json:"state,omitempty"`
	// original -> bgp-mp:route-selection-options
	RouteSelectionOptions RouteSelectionOptions `mapstructure:"route-selection-options" json:"route-selection-options,omitempty"`
	// original -> bgp:default-route-distance
	DefaultRouteDistance DefaultRouteDistance `mapstructure:"default-route-distance" json:"default-route-distance,omitempty"`
	// original -> bgp:confederation
	Confederation Confederation `mapstructure:"confederation" json:"confederation,omitempty"`
	// original -> bgp-mp:use-multiple-paths
	UseMultiplePaths UseMultiplePaths `mapstructure:"use-multiple-paths" json:"use-multiple-paths,omitempty"`
	// original -> bgp:graceful-restart
	GracefulRestart GracefulRestart `mapstructure:"graceful-restart" json:"graceful-restart,omitempty"`
	// original -> bgp:afi-safis
	AfiSafis []AfiSafi `mapstructure:"afi-safis" json:"afi-safis,omitempty"`
	// original -> rpol:apply-policy
	ApplyPolicy ApplyPolicy `mapstructure:"apply-policy" json:"apply-policy,omitempty"`
}

struct for container bgp:global

func (*Global) Equal 

func (lhs *Global) Equal(rhs *Global) bool

type GlobalConfig 

type GlobalConfig struct {
	// original -> bgp:as
	//bgp:as's original type is inet:as-number
	As uint32 `mapstructure:"as" json:"as,omitempty"`
	// original -> bgp:router-id
	//bgp:router-id's original type is inet:ipv4-address
	RouterId string `mapstructure:"router-id" json:"router-id,omitempty"`
	// original -> gobgp:port
	Port int32 `mapstructure:"port" json:"port,omitempty"`
	// original -> gobgp:local-address
	LocalAddressList []string `mapstructure:"local-address-list" json:"local-address-list,omitempty"`
}

struct for container bgp:config

func (*GlobalConfig) Equal 

func (lhs *GlobalConfig) Equal(rhs *GlobalConfig) bool

type GlobalState 

type GlobalState struct {
	// original -> bgp:as
	//bgp:as's original type is inet:as-number
	As uint32 `mapstructure:"as" json:"as,omitempty"`
	// original -> bgp:router-id
	//bgp:router-id's original type is inet:ipv4-address
	RouterId string `mapstructure:"router-id" json:"router-id,omitempty"`
	// original -> bgp-op:total-paths
	TotalPaths uint32 `mapstructure:"total-paths" json:"total-paths,omitempty"`
	// original -> bgp-op:total-prefixes
	TotalPrefixes uint32 `mapstructure:"total-prefixes" json:"total-prefixes,omitempty"`
	// original -> gobgp:port
	Port int32 `mapstructure:"port" json:"port,omitempty"`
	// original -> gobgp:local-address
	LocalAddressList []string `mapstructure:"local-address-list" json:"local-address-list,omitempty"`
}

struct for container bgp:state

type GracefulRestart 

type GracefulRestart struct {
	// original -> bgp:graceful-restart-config
	Config GracefulRestartConfig `mapstructure:"config" json:"config,omitempty"`
	// original -> bgp:graceful-restart-state
	State GracefulRestartState `mapstructure:"state" json:"state,omitempty"`
}

struct for container bgp:graceful-restart

func (*GracefulRestart) Equal 

func (lhs *GracefulRestart) Equal(rhs *GracefulRestart) bool

type GracefulRestartConfig 

type GracefulRestartConfig struct {
	// original -> bgp:enabled
	//bgp:enabled's original type is boolean
	Enabled bool `mapstructure:"enabled" json:"enabled,omitempty"`
	// original -> bgp:restart-time
	RestartTime uint16 `mapstructure:"restart-time" json:"restart-time,omitempty"`
	// original -> bgp:stale-routes-time
	//bgp:stale-routes-time's original type is decimal64
	StaleRoutesTime float64 `mapstructure:"stale-routes-time" json:"stale-routes-time,omitempty"`
	// original -> bgp:helper-only
	//bgp:helper-only's original type is boolean
	HelperOnly bool `mapstructure:"helper-only" json:"helper-only,omitempty"`
	// original -> gobgp:deferral-time
	DeferralTime uint16 `mapstructure:"deferral-time" json:"deferral-time,omitempty"`
	// original -> gobgp:notification-enabled
	//gobgp:notification-enabled's original type is boolean
	NotificationEnabled bool `mapstructure:"notification-enabled" json:"notification-enabled,omitempty"`
	// original -> gobgp:long-lived-enabled
	//gobgp:long-lived-enabled's original type is boolean
	LongLivedEnabled bool `mapstructure:"long-lived-enabled" json:"long-lived-enabled,omitempty"`
}

struct for container bgp:config

func (*GracefulRestartConfig) Equal 

func (lhs *GracefulRestartConfig) Equal(rhs *GracefulRestartConfig) bool

type GracefulRestartState 

type GracefulRestartState struct {
	// original -> bgp:enabled
	//bgp:enabled's original type is boolean
	Enabled bool `mapstructure:"enabled" json:"enabled,omitempty"`
	// original -> bgp:restart-time
	RestartTime uint16 `mapstructure:"restart-time" json:"restart-time,omitempty"`
	// original -> bgp:stale-routes-time
	//bgp:stale-routes-time's original type is decimal64
	StaleRoutesTime float64 `mapstructure:"stale-routes-time" json:"stale-routes-time,omitempty"`
	// original -> bgp:helper-only
	//bgp:helper-only's original type is boolean
	HelperOnly bool `mapstructure:"helper-only" json:"helper-only,omitempty"`
	// original -> bgp-op:peer-restart-time
	PeerRestartTime uint16 `mapstructure:"peer-restart-time" json:"peer-restart-time,omitempty"`
	// original -> bgp-op:peer-restarting
	//bgp-op:peer-restarting's original type is boolean
	PeerRestarting bool `mapstructure:"peer-restarting" json:"peer-restarting,omitempty"`
	// original -> bgp-op:local-restarting
	//bgp-op:local-restarting's original type is boolean
	LocalRestarting bool `mapstructure:"local-restarting" json:"local-restarting,omitempty"`
	// original -> bgp-op:mode
	Mode Mode `mapstructure:"mode" json:"mode,omitempty"`
	// original -> gobgp:deferral-time
	DeferralTime uint16 `mapstructure:"deferral-time" json:"deferral-time,omitempty"`
	// original -> gobgp:notification-enabled
	//gobgp:notification-enabled's original type is boolean
	NotificationEnabled bool `mapstructure:"notification-enabled" json:"notification-enabled,omitempty"`
	// original -> gobgp:long-lived-enabled
	//gobgp:long-lived-enabled's original type is boolean
	LongLivedEnabled bool `mapstructure:"long-lived-enabled" json:"long-lived-enabled,omitempty"`
}

struct for container bgp:state

type Ibgp 

type Ibgp struct {
	// original -> bgp-mp:ibgp-config
	Config IbgpConfig `mapstructure:"config" json:"config,omitempty"`
	// original -> bgp-mp:ibgp-state
	State IbgpState `mapstructure:"state" json:"state,omitempty"`
}

struct for container bgp-mp:ibgp

func (*Ibgp) Equal 

func (lhs *Ibgp) Equal(rhs *Ibgp) bool

type IbgpConfig 

type IbgpConfig struct {
	// original -> bgp-mp:maximum-paths
	MaximumPaths uint32 `mapstructure:"maximum-paths" json:"maximum-paths,omitempty"`
}

struct for container bgp-mp:config

func (*IbgpConfig) Equal 

func (lhs *IbgpConfig) Equal(rhs *IbgpConfig) bool

type IbgpState 

type IbgpState struct {
	// original -> bgp-mp:maximum-paths
	MaximumPaths uint32 `mapstructure:"maximum-paths" json:"maximum-paths,omitempty"`
}

struct for container bgp-mp:state

type IgpActions 

type IgpActions struct {
	// original -> rpol:set-tag
	SetTag TagType `mapstructure:"set-tag" json:"set-tag,omitempty"`
}

struct for container rpol:igp-actions

func (*IgpActions) Equal 

func (lhs *IgpActions) Equal(rhs *IgpActions) bool

type IgpConditions 

type IgpConditions struct {
}

struct for container rpol:igp-conditions

func (*IgpConditions) Equal 

func (lhs *IgpConditions) Equal(rhs *IgpConditions) bool

type InstallProtocolType 

type InstallProtocolType string

typedef for identity ptypes:install-protocol-type 

const (
	INSTALL_PROTOCOL_TYPE_BGP                InstallProtocolType = "bgp"
	INSTALL_PROTOCOL_TYPE_ISIS               InstallProtocolType = "isis"
	INSTALL_PROTOCOL_TYPE_OSPF               InstallProtocolType = "ospf"
	INSTALL_PROTOCOL_TYPE_OSPF3              InstallProtocolType = "ospf3"
	INSTALL_PROTOCOL_TYPE_STATIC             InstallProtocolType = "static"
	INSTALL_PROTOCOL_TYPE_DIRECTLY_CONNECTED InstallProtocolType = "directly-connected"
	INSTALL_PROTOCOL_TYPE_LOCAL_AGGREGATE    InstallProtocolType = "local-aggregate"
)

func (InstallProtocolType) ToInt 

func (v InstallProtocolType) ToInt() int

func (InstallProtocolType) Validate 

func (v InstallProtocolType) Validate() error

type Ipv4LabelledUnicast 

type Ipv4LabelledUnicast struct {
	// original -> bgp-mp:prefix-limit
	PrefixLimit PrefixLimit `mapstructure:"prefix-limit" json:"prefix-limit,omitempty"`
}

struct for container bgp-mp:ipv4-labelled-unicast

func (*Ipv4LabelledUnicast) Equal 

func (lhs *Ipv4LabelledUnicast) Equal(rhs *Ipv4LabelledUnicast) bool

type Ipv4Unicast 

type Ipv4Unicast struct {
	// original -> bgp-mp:prefix-limit
	PrefixLimit PrefixLimit `mapstructure:"prefix-limit" json:"prefix-limit,omitempty"`
	// original -> bgp-mp:ipv4-unicast-config
	Config Ipv4UnicastConfig `mapstructure:"config" json:"config,omitempty"`
	// original -> bgp-mp:ipv4-unicast-state
	State Ipv4UnicastState `mapstructure:"state" json:"state,omitempty"`
}

struct for container bgp-mp:ipv4-unicast

func (*Ipv4Unicast) Equal 

func (lhs *Ipv4Unicast) Equal(rhs *Ipv4Unicast) bool

type Ipv4UnicastConfig 

type Ipv4UnicastConfig struct {
	// original -> bgp-mp:send-default-route
	//bgp-mp:send-default-route's original type is boolean
	SendDefaultRoute bool `mapstructure:"send-default-route" json:"send-default-route,omitempty"`
}

struct for container bgp-mp:config

func (*Ipv4UnicastConfig) Equal 

func (lhs *Ipv4UnicastConfig) Equal(rhs *Ipv4UnicastConfig) bool

type Ipv4UnicastState 

type Ipv4UnicastState struct {
	// original -> bgp-mp:send-default-route
	//bgp-mp:send-default-route's original type is boolean
	SendDefaultRoute bool `mapstructure:"send-default-route" json:"send-default-route,omitempty"`
}

struct for container bgp-mp:state

type Ipv6LabelledUnicast 

type Ipv6LabelledUnicast struct {
	// original -> bgp-mp:prefix-limit
	PrefixLimit PrefixLimit `mapstructure:"prefix-limit" json:"prefix-limit,omitempty"`
}

struct for container bgp-mp:ipv6-labelled-unicast

func (*Ipv6LabelledUnicast) Equal 

func (lhs *Ipv6LabelledUnicast) Equal(rhs *Ipv6LabelledUnicast) bool

type Ipv6Unicast 

type Ipv6Unicast struct {
	// original -> bgp-mp:prefix-limit
	PrefixLimit PrefixLimit `mapstructure:"prefix-limit" json:"prefix-limit,omitempty"`
	// original -> bgp-mp:ipv6-unicast-config
	Config Ipv6UnicastConfig `mapstructure:"config" json:"config,omitempty"`
	// original -> bgp-mp:ipv6-unicast-state
	State Ipv6UnicastState `mapstructure:"state" json:"state,omitempty"`
}

struct for container bgp-mp:ipv6-unicast

func (*Ipv6Unicast) Equal 

func (lhs *Ipv6Unicast) Equal(rhs *Ipv6Unicast) bool

type Ipv6UnicastConfig 

type Ipv6UnicastConfig struct {
	// original -> bgp-mp:send-default-route
	//bgp-mp:send-default-route's original type is boolean
	SendDefaultRoute bool `mapstructure:"send-default-route" json:"send-default-route,omitempty"`
}

struct for container bgp-mp:config

func (*Ipv6UnicastConfig) Equal 

func (lhs *Ipv6UnicastConfig) Equal(rhs *Ipv6UnicastConfig) bool

type Ipv6UnicastState 

type Ipv6UnicastState struct {
	// original -> bgp-mp:send-default-route
	//bgp-mp:send-default-route's original type is boolean
	SendDefaultRoute bool `mapstructure:"send-default-route" json:"send-default-route,omitempty"`
}

struct for container bgp-mp:state

type L2vpnEvpn 

type L2vpnEvpn struct {
	// original -> bgp-mp:prefix-limit
	PrefixLimit PrefixLimit `mapstructure:"prefix-limit" json:"prefix-limit,omitempty"`
}

struct for container bgp-mp:l2vpn-evpn

func (*L2vpnEvpn) Equal 

func (lhs *L2vpnEvpn) Equal(rhs *L2vpnEvpn) bool

type L2vpnVpls 

type L2vpnVpls struct {
	// original -> bgp-mp:prefix-limit
	PrefixLimit PrefixLimit `mapstructure:"prefix-limit" json:"prefix-limit,omitempty"`
}

struct for container bgp-mp:l2vpn-vpls

func (*L2vpnVpls) Equal 

func (lhs *L2vpnVpls) Equal(rhs *L2vpnVpls) bool

type L3vpnIpv4Multicast 

type L3vpnIpv4Multicast struct {
	// original -> bgp-mp:prefix-limit
	PrefixLimit PrefixLimit `mapstructure:"prefix-limit" json:"prefix-limit,omitempty"`
}

struct for container bgp-mp:l3vpn-ipv4-multicast

func (*L3vpnIpv4Multicast) Equal 

func (lhs *L3vpnIpv4Multicast) Equal(rhs *L3vpnIpv4Multicast) bool

type L3vpnIpv4Unicast 

type L3vpnIpv4Unicast struct {
	// original -> bgp-mp:prefix-limit
	PrefixLimit PrefixLimit `mapstructure:"prefix-limit" json:"prefix-limit,omitempty"`
}

struct for container bgp-mp:l3vpn-ipv4-unicast

func (*L3vpnIpv4Unicast) Equal 

func (lhs *L3vpnIpv4Unicast) Equal(rhs *L3vpnIpv4Unicast) bool

type L3vpnIpv6Multicast 

type L3vpnIpv6Multicast struct {
	// original -> bgp-mp:prefix-limit
	PrefixLimit PrefixLimit `mapstructure:"prefix-limit" json:"prefix-limit,omitempty"`
}

struct for container bgp-mp:l3vpn-ipv6-multicast

func (*L3vpnIpv6Multicast) Equal 

func (lhs *L3vpnIpv6Multicast) Equal(rhs *L3vpnIpv6Multicast) bool

type L3vpnIpv6Unicast 

type L3vpnIpv6Unicast struct {
	// original -> bgp-mp:prefix-limit
	PrefixLimit PrefixLimit `mapstructure:"prefix-limit" json:"prefix-limit,omitempty"`
}

struct for container bgp-mp:l3vpn-ipv6-unicast

func (*L3vpnIpv6Unicast) Equal 

func (lhs *L3vpnIpv6Unicast) Equal(rhs *L3vpnIpv6Unicast) bool

type LargeCommunitySet 

type LargeCommunitySet struct {
	// original -> gobgp:large-community-set-name
	LargeCommunitySetName string `mapstructure:"large-community-set-name" json:"large-community-set-name,omitempty"`
	// original -> gobgp:large-community
	LargeCommunityList []string `mapstructure:"large-community-list" json:"large-community-list,omitempty"`
}

struct for container gobgp:large-community-set

func (*LargeCommunitySet) Equal 

func (lhs *LargeCommunitySet) Equal(rhs *LargeCommunitySet) bool

type LoggingOptions 

type LoggingOptions struct {
	// original -> bgp:logging-options-config
	Config LoggingOptionsConfig `mapstructure:"config" json:"config,omitempty"`
	// original -> bgp:logging-options-state
	State LoggingOptionsState `mapstructure:"state" json:"state,omitempty"`
}

struct for container bgp:logging-options

func (*LoggingOptions) Equal 

func (lhs *LoggingOptions) Equal(rhs *LoggingOptions) bool

type LoggingOptionsConfig 

type LoggingOptionsConfig struct {
	// original -> bgp:log-neighbor-state-changes
	//bgp:log-neighbor-state-changes's original type is boolean
	LogNeighborStateChanges bool `mapstructure:"log-neighbor-state-changes" json:"log-neighbor-state-changes,omitempty"`
}

struct for container bgp:config

func (*LoggingOptionsConfig) Equal 

func (lhs *LoggingOptionsConfig) Equal(rhs *LoggingOptionsConfig) bool

type LoggingOptionsState 

type LoggingOptionsState struct {
	// original -> bgp:log-neighbor-state-changes
	//bgp:log-neighbor-state-changes's original type is boolean
	LogNeighborStateChanges bool `mapstructure:"log-neighbor-state-changes" json:"log-neighbor-state-changes,omitempty"`
}

struct for container bgp:state

type LongLivedGracefulRestart 

type LongLivedGracefulRestart struct {
	// original -> gobgp:long-lived-graceful-restart-config
	Config LongLivedGracefulRestartConfig `mapstructure:"config" json:"config,omitempty"`
	// original -> gobgp:long-lived-graceful-restart-state
	State LongLivedGracefulRestartState `mapstructure:"state" json:"state,omitempty"`
}

struct for container gobgp:long-lived-graceful-restart

func (*LongLivedGracefulRestart) Equal 

func (lhs *LongLivedGracefulRestart) Equal(rhs *LongLivedGracefulRestart) bool

type LongLivedGracefulRestartConfig 

type LongLivedGracefulRestartConfig struct {
	// original -> gobgp:enabled
	//gobgp:enabled's original type is boolean
	Enabled bool `mapstructure:"enabled" json:"enabled,omitempty"`
	// original -> gobgp:restart-time
	RestartTime uint32 `mapstructure:"restart-time" json:"restart-time,omitempty"`
}

struct for container gobgp:config

func (*LongLivedGracefulRestartConfig) Equal 

func (lhs *LongLivedGracefulRestartConfig) Equal(rhs *LongLivedGracefulRestartConfig) bool

type LongLivedGracefulRestartState 

type LongLivedGracefulRestartState struct {
	// original -> gobgp:enabled
	//gobgp:enabled's original type is boolean
	Enabled bool `mapstructure:"enabled" json:"enabled,omitempty"`
	// original -> gobgp:received
	//gobgp:received's original type is boolean
	Received bool `mapstructure:"received" json:"received,omitempty"`
	// original -> gobgp:advertised
	//gobgp:advertised's original type is boolean
	Advertised bool `mapstructure:"advertised" json:"advertised,omitempty"`
	// original -> gobgp:peer-restart-time
	PeerRestartTime uint32 `mapstructure:"peer-restart-time" json:"peer-restart-time,omitempty"`
	// original -> gobgp:peer-restart-timer-expired
	//gobgp:peer-restart-timer-expired's original type is boolean
	PeerRestartTimerExpired bool `mapstructure:"peer-restart-timer-expired" json:"peer-restart-timer-expired,omitempty"`
}

struct for container gobgp:state

type MatchAsPathSet 

type MatchAsPathSet struct {
	// original -> bgp-pol:as-path-set
	AsPathSet string `mapstructure:"as-path-set" json:"as-path-set,omitempty"`
	// original -> rpol:match-set-options
	MatchSetOptions MatchSetOptionsType `mapstructure:"match-set-options" json:"match-set-options,omitempty"`
}

struct for container bgp-pol:match-as-path-set

func (*MatchAsPathSet) Equal 

func (lhs *MatchAsPathSet) Equal(rhs *MatchAsPathSet) bool

type MatchCommunitySet 

type MatchCommunitySet struct {
	// original -> bgp-pol:community-set
	CommunitySet string `mapstructure:"community-set" json:"community-set,omitempty"`
	// original -> rpol:match-set-options
	MatchSetOptions MatchSetOptionsType `mapstructure:"match-set-options" json:"match-set-options,omitempty"`
}

struct for container bgp-pol:match-community-set

func (*MatchCommunitySet) Equal 

func (lhs *MatchCommunitySet) Equal(rhs *MatchCommunitySet) bool

type MatchExtCommunitySet 

type MatchExtCommunitySet struct {
	// original -> bgp-pol:ext-community-set
	ExtCommunitySet string `mapstructure:"ext-community-set" json:"ext-community-set,omitempty"`
	// original -> rpol:match-set-options
	MatchSetOptions MatchSetOptionsType `mapstructure:"match-set-options" json:"match-set-options,omitempty"`
}

struct for container bgp-pol:match-ext-community-set

func (*MatchExtCommunitySet) Equal 

func (lhs *MatchExtCommunitySet) Equal(rhs *MatchExtCommunitySet) bool

type MatchLargeCommunitySet 

type MatchLargeCommunitySet struct {
	// original -> gobgp:large-community-set
	LargeCommunitySet string `mapstructure:"large-community-set" json:"large-community-set,omitempty"`
	// original -> rpol:match-set-options
	MatchSetOptions MatchSetOptionsType `mapstructure:"match-set-options" json:"match-set-options,omitempty"`
}

struct for container gobgp:match-large-community-set

func (*MatchLargeCommunitySet) Equal 

func (lhs *MatchLargeCommunitySet) Equal(rhs *MatchLargeCommunitySet) bool

type MatchNeighborSet 

type MatchNeighborSet struct {
	// original -> rpol:neighbor-set
	NeighborSet string `mapstructure:"neighbor-set" json:"neighbor-set,omitempty"`
	// original -> rpol:match-set-options
	MatchSetOptions MatchSetOptionsRestrictedType `mapstructure:"match-set-options" json:"match-set-options,omitempty"`
}

struct for container rpol:match-neighbor-set

func (*MatchNeighborSet) Equal 

func (lhs *MatchNeighborSet) Equal(rhs *MatchNeighborSet) bool

type MatchPrefixSet 

type MatchPrefixSet struct {
	// original -> rpol:prefix-set
	PrefixSet string `mapstructure:"prefix-set" json:"prefix-set,omitempty"`
	// original -> rpol:match-set-options
	MatchSetOptions MatchSetOptionsRestrictedType `mapstructure:"match-set-options" json:"match-set-options,omitempty"`
}

struct for container rpol:match-prefix-set

func (*MatchPrefixSet) Equal 

func (lhs *MatchPrefixSet) Equal(rhs *MatchPrefixSet) bool

type MatchSetOptionsRestrictedType 

type MatchSetOptionsRestrictedType string

typedef for identity ptypes:match-set-options-restricted-type 

const (
	MATCH_SET_OPTIONS_RESTRICTED_TYPE_ANY    MatchSetOptionsRestrictedType = "any"
	MATCH_SET_OPTIONS_RESTRICTED_TYPE_INVERT MatchSetOptionsRestrictedType = "invert"
)

func (MatchSetOptionsRestrictedType) Default 

func (v MatchSetOptionsRestrictedType) Default() MatchSetOptionsRestrictedType

func (MatchSetOptionsRestrictedType) DefaultAsNeeded 

func (v MatchSetOptionsRestrictedType) DefaultAsNeeded() MatchSetOptionsRestrictedType

func (MatchSetOptionsRestrictedType) ToInt 

func (v MatchSetOptionsRestrictedType) ToInt() int

func (MatchSetOptionsRestrictedType) Validate 

func (v MatchSetOptionsRestrictedType) Validate() error

type MatchSetOptionsType 

type MatchSetOptionsType string

typedef for identity ptypes:match-set-options-type 

const (
	MATCH_SET_OPTIONS_TYPE_ANY    MatchSetOptionsType = "any"
	MATCH_SET_OPTIONS_TYPE_ALL    MatchSetOptionsType = "all"
	MATCH_SET_OPTIONS_TYPE_INVERT MatchSetOptionsType = "invert"
)

func (MatchSetOptionsType) Default 

func (v MatchSetOptionsType) Default() MatchSetOptionsType

func (MatchSetOptionsType) DefaultAsNeeded 

func (v MatchSetOptionsType) DefaultAsNeeded() MatchSetOptionsType

func (MatchSetOptionsType) ToInt 

func (v MatchSetOptionsType) ToInt() int

func (MatchSetOptionsType) Validate 

func (v MatchSetOptionsType) Validate() error

type MatchTagSet 

type MatchTagSet struct {
	// original -> rpol:tag-set
	TagSet string `mapstructure:"tag-set" json:"tag-set,omitempty"`
	// original -> rpol:match-set-options
	MatchSetOptions MatchSetOptionsRestrictedType `mapstructure:"match-set-options" json:"match-set-options,omitempty"`
}

struct for container rpol:match-tag-set

func (*MatchTagSet) Equal 

func (lhs *MatchTagSet) Equal(rhs *MatchTagSet) bool

type Messages 

type Messages struct {
	// original -> bgp:sent
	Sent Sent `mapstructure:"sent" json:"sent,omitempty"`
	// original -> bgp:received
	Received Received `mapstructure:"received" json:"received,omitempty"`
}

struct for container bgp:messages

func (*Messages) Equal 

func (lhs *Messages) Equal(rhs *Messages) bool

type Mode 

type Mode string

typedef for identity bgp:mode 

const (
	MODE_HELPER_ONLY   Mode = "helper-only"
	MODE_BILATERAL     Mode = "bilateral"
	MODE_REMOTE_HELPER Mode = "remote-helper"
)

func (Mode) ToInt 

func (v Mode) ToInt() int

func (Mode) Validate 

func (v Mode) Validate() error

type MpGracefulRestart 

type MpGracefulRestart struct {
	// original -> bgp-mp:mp-graceful-restart-config
	Config MpGracefulRestartConfig `mapstructure:"config" json:"config,omitempty"`
	// original -> bgp-mp:mp-graceful-restart-state
	State MpGracefulRestartState `mapstructure:"state" json:"state,omitempty"`
}

struct for container bgp-mp:graceful-restart

func (*MpGracefulRestart) Equal 

func (lhs *MpGracefulRestart) Equal(rhs *MpGracefulRestart) bool

type MpGracefulRestartConfig 

type MpGracefulRestartConfig struct {
	// original -> bgp-mp:enabled
	//bgp-mp:enabled's original type is boolean
	Enabled bool `mapstructure:"enabled" json:"enabled,omitempty"`
}

struct for container bgp-mp:config

func (*MpGracefulRestartConfig) Equal 

func (lhs *MpGracefulRestartConfig) Equal(rhs *MpGracefulRestartConfig) bool

type MpGracefulRestartState 

type MpGracefulRestartState struct {
	// original -> bgp-mp:enabled
	//bgp-mp:enabled's original type is boolean
	Enabled bool `mapstructure:"enabled" json:"enabled,omitempty"`
	// original -> bgp-op:received
	//bgp-op:received's original type is boolean
	Received bool `mapstructure:"received" json:"received,omitempty"`
	// original -> bgp-op:advertised
	//bgp-op:advertised's original type is boolean
	Advertised bool `mapstructure:"advertised" json:"advertised,omitempty"`
	// original -> gobgp:end-of-rib-received
	//gobgp:end-of-rib-received's original type is boolean
	EndOfRibReceived bool `mapstructure:"end-of-rib-received" json:"end-of-rib-received,omitempty"`
	// original -> gobgp:end-of-rib-sent
	//gobgp:end-of-rib-sent's original type is boolean
	EndOfRibSent bool `mapstructure:"end-of-rib-sent" json:"end-of-rib-sent,omitempty"`
}

struct for container bgp-mp:state

type Mrt 

type Mrt struct {
	// original -> gobgp:file-name
	// original -> gobgp:mrt-config
	Config MrtConfig `mapstructure:"config" json:"config,omitempty"`
}

struct for container gobgp:mrt

func (*Mrt) Equal 

func (lhs *Mrt) Equal(rhs *Mrt) bool

type MrtConfig 

type MrtConfig struct {
	// original -> gobgp:dump-type
	DumpType MrtType `mapstructure:"dump-type" json:"dump-type,omitempty"`
	// original -> gobgp:file-name
	FileName string `mapstructure:"file-name" json:"file-name,omitempty"`
	// original -> gobgp:table-name
	TableName string `mapstructure:"table-name" json:"table-name,omitempty"`
	// original -> gobgp:dump-interval
	DumpInterval uint64 `mapstructure:"dump-interval" json:"dump-interval,omitempty"`
	// original -> gobgp:rotation-interval
	RotationInterval uint64 `mapstructure:"rotation-interval" json:"rotation-interval,omitempty"`
}

struct for container gobgp:config

func (*MrtConfig) Equal 

func (lhs *MrtConfig) Equal(rhs *MrtConfig) bool

type MrtType 

type MrtType string

typedef for identity gobgp:mrt-type 

const (
	MRT_TYPE_UPDATES MrtType = "updates"
	MRT_TYPE_TABLE   MrtType = "table"
)

func (MrtType) ToInt 

func (v MrtType) ToInt() int

func (MrtType) Validate 

func (v MrtType) Validate() error

type Neighbor 

type Neighbor struct {
	// original -> bgp:neighbor-address
	// original -> bgp:neighbor-config
	Config NeighborConfig `mapstructure:"config" json:"config,omitempty"`
	// original -> bgp:neighbor-state
	State NeighborState `mapstructure:"state" json:"state,omitempty"`
	// original -> bgp:timers
	Timers Timers `mapstructure:"timers" json:"timers,omitempty"`
	// original -> bgp:transport
	Transport Transport `mapstructure:"transport" json:"transport,omitempty"`
	// original -> bgp:error-handling
	ErrorHandling ErrorHandling `mapstructure:"error-handling" json:"error-handling,omitempty"`
	// original -> bgp:logging-options
	LoggingOptions LoggingOptions `mapstructure:"logging-options" json:"logging-options,omitempty"`
	// original -> bgp:ebgp-multihop
	EbgpMultihop EbgpMultihop `mapstructure:"ebgp-multihop" json:"ebgp-multihop,omitempty"`
	// original -> bgp:route-reflector
	RouteReflector RouteReflector `mapstructure:"route-reflector" json:"route-reflector,omitempty"`
	// original -> bgp:as-path-options
	AsPathOptions AsPathOptions `mapstructure:"as-path-options" json:"as-path-options,omitempty"`
	// original -> bgp:add-paths
	AddPaths AddPaths `mapstructure:"add-paths" json:"add-paths,omitempty"`
	// original -> bgp:afi-safis
	AfiSafis []AfiSafi `mapstructure:"afi-safis" json:"afi-safis,omitempty"`
	// original -> bgp:graceful-restart
	GracefulRestart GracefulRestart `mapstructure:"graceful-restart" json:"graceful-restart,omitempty"`
	// original -> rpol:apply-policy
	ApplyPolicy ApplyPolicy `mapstructure:"apply-policy" json:"apply-policy,omitempty"`
	// original -> bgp-mp:use-multiple-paths
	UseMultiplePaths UseMultiplePaths `mapstructure:"use-multiple-paths" json:"use-multiple-paths,omitempty"`
	// original -> gobgp:route-server
	RouteServer RouteServer `mapstructure:"route-server" json:"route-server,omitempty"`
}

struct for container bgp:neighbor

func (*Neighbor) Equal 

func (lhs *Neighbor) Equal(rhs *Neighbor) bool

type NeighborConfig 

type NeighborConfig struct {
	// original -> bgp:peer-as
	//bgp:peer-as's original type is inet:as-number
	PeerAs uint32 `mapstructure:"peer-as" json:"peer-as,omitempty"`
	// original -> bgp:local-as
	//bgp:local-as's original type is inet:as-number
	LocalAs uint32 `mapstructure:"local-as" json:"local-as,omitempty"`
	// original -> bgp:peer-type
	PeerType PeerType `mapstructure:"peer-type" json:"peer-type,omitempty"`
	// original -> bgp:auth-password
	AuthPassword string `mapstructure:"auth-password" json:"auth-password,omitempty"`
	// original -> bgp:remove-private-as
	RemovePrivateAs RemovePrivateAsOption `mapstructure:"remove-private-as" json:"remove-private-as,omitempty"`
	// original -> bgp:route-flap-damping
	//bgp:route-flap-damping's original type is boolean
	RouteFlapDamping bool `mapstructure:"route-flap-damping" json:"route-flap-damping,omitempty"`
	// original -> bgp:send-community
	SendCommunity CommunityType `mapstructure:"send-community" json:"send-community,omitempty"`
	// original -> bgp:description
	Description string `mapstructure:"description" json:"description,omitempty"`
	// original -> bgp:peer-group
	PeerGroup string `mapstructure:"peer-group" json:"peer-group,omitempty"`
	// original -> bgp:neighbor-address
	//bgp:neighbor-address's original type is inet:ip-address
	NeighborAddress string `mapstructure:"neighbor-address" json:"neighbor-address,omitempty"`
	// original -> gobgp:admin-down
	//gobgp:admin-down's original type is boolean
	AdminDown bool `mapstructure:"admin-down" json:"admin-down,omitempty"`
	// original -> gobgp:neighbor-interface
	NeighborInterface string `mapstructure:"neighbor-interface" json:"neighbor-interface,omitempty"`
	// original -> gobgp:vrf
	Vrf string `mapstructure:"vrf" json:"vrf,omitempty"`
}

struct for container bgp:config

func (*NeighborConfig) Equal 

func (lhs *NeighborConfig) Equal(rhs *NeighborConfig) bool

type NeighborSet 

type NeighborSet struct {
	// original -> rpol:neighbor-set-name
	NeighborSetName string `mapstructure:"neighbor-set-name" json:"neighbor-set-name,omitempty"`
	// original -> gobgp:neighbor-info
	// original type is list of inet:ip-address
	NeighborInfoList []string `mapstructure:"neighbor-info-list" json:"neighbor-info-list,omitempty"`
}

struct for container rpol:neighbor-set

func (*NeighborSet) Equal 

func (lhs *NeighborSet) Equal(rhs *NeighborSet) bool

type NeighborState 

type NeighborState struct {
	// original -> bgp:peer-as
	//bgp:peer-as's original type is inet:as-number
	PeerAs uint32 `mapstructure:"peer-as" json:"peer-as,omitempty"`
	// original -> bgp:local-as
	//bgp:local-as's original type is inet:as-number
	LocalAs uint32 `mapstructure:"local-as" json:"local-as,omitempty"`
	// original -> bgp:peer-type
	PeerType PeerType `mapstructure:"peer-type" json:"peer-type,omitempty"`
	// original -> bgp:auth-password
	AuthPassword string `mapstructure:"auth-password" json:"auth-password,omitempty"`
	// original -> bgp:remove-private-as
	RemovePrivateAs RemovePrivateAsOption `mapstructure:"remove-private-as" json:"remove-private-as,omitempty"`
	// original -> bgp:route-flap-damping
	//bgp:route-flap-damping's original type is boolean
	RouteFlapDamping bool `mapstructure:"route-flap-damping" json:"route-flap-damping,omitempty"`
	// original -> bgp:send-community
	SendCommunity CommunityType `mapstructure:"send-community" json:"send-community,omitempty"`
	// original -> bgp:description
	Description string `mapstructure:"description" json:"description,omitempty"`
	// original -> bgp:peer-group
	PeerGroup string `mapstructure:"peer-group" json:"peer-group,omitempty"`
	// original -> bgp:neighbor-address
	//bgp:neighbor-address's original type is inet:ip-address
	NeighborAddress string `mapstructure:"neighbor-address" json:"neighbor-address,omitempty"`
	// original -> bgp-op:session-state
	SessionState SessionState `mapstructure:"session-state" json:"session-state,omitempty"`
	// original -> bgp-op:supported-capabilities
	SupportedCapabilitiesList []BgpCapability `mapstructure:"supported-capabilities-list" json:"supported-capabilities-list,omitempty"`
	// original -> bgp:messages
	Messages Messages `mapstructure:"messages" json:"messages,omitempty"`
	// original -> bgp:queues
	Queues Queues `mapstructure:"queues" json:"queues,omitempty"`
	// original -> gobgp:adj-table
	AdjTable AdjTable `mapstructure:"adj-table" json:"adj-table,omitempty"`
	// original -> gobgp:remote-capability
	// original type is list of bgp-capability
	RemoteCapabilityList []bgp.ParameterCapabilityInterface `mapstructure:"remote-capability-list" json:"remote-capability-list,omitempty"`
	// original -> gobgp:local-capability
	// original type is list of bgp-capability
	LocalCapabilityList []bgp.ParameterCapabilityInterface `mapstructure:"local-capability-list" json:"local-capability-list,omitempty"`
	// original -> gobgp:received-open-message
	//gobgp:received-open-message's original type is bgp-open-message
	ReceivedOpenMessage *bgp.BGPMessage `mapstructure:"received-open-message" json:"received-open-message,omitempty"`
	// original -> gobgp:admin-down
	//gobgp:admin-down's original type is boolean
	AdminDown bool `mapstructure:"admin-down" json:"admin-down,omitempty"`
	// original -> gobgp:admin-state
	AdminState AdminState `mapstructure:"admin-state" json:"admin-state,omitempty"`
	// original -> gobgp:established-count
	EstablishedCount uint32 `mapstructure:"established-count" json:"established-count,omitempty"`
	// original -> gobgp:flops
	Flops uint32 `mapstructure:"flops" json:"flops,omitempty"`
	// original -> gobgp:neighbor-interface
	NeighborInterface string `mapstructure:"neighbor-interface" json:"neighbor-interface,omitempty"`
	// original -> gobgp:vrf
	Vrf string `mapstructure:"vrf" json:"vrf,omitempty"`
	// original -> gobgp:remote-router-id
	RemoteRouterId string `mapstructure:"remote-router-id" json:"remote-router-id,omitempty"`
}

struct for container bgp:state

type PeerGroup 

type PeerGroup struct {
	// original -> bgp:peer-group-name
	// original -> bgp:peer-group-config
	Config PeerGroupConfig `mapstructure:"config" json:"config,omitempty"`
	// original -> bgp:peer-group-state
	State PeerGroupState `mapstructure:"state" json:"state,omitempty"`
	// original -> bgp:timers
	Timers Timers `mapstructure:"timers" json:"timers,omitempty"`
	// original -> bgp:transport
	Transport Transport `mapstructure:"transport" json:"transport,omitempty"`
	// original -> bgp:error-handling
	ErrorHandling ErrorHandling `mapstructure:"error-handling" json:"error-handling,omitempty"`
	// original -> bgp:logging-options
	LoggingOptions LoggingOptions `mapstructure:"logging-options" json:"logging-options,omitempty"`
	// original -> bgp:ebgp-multihop
	EbgpMultihop EbgpMultihop `mapstructure:"ebgp-multihop" json:"ebgp-multihop,omitempty"`
	// original -> bgp:route-reflector
	RouteReflector RouteReflector `mapstructure:"route-reflector" json:"route-reflector,omitempty"`
	// original -> bgp:as-path-options
	AsPathOptions AsPathOptions `mapstructure:"as-path-options" json:"as-path-options,omitempty"`
	// original -> bgp:add-paths
	AddPaths AddPaths `mapstructure:"add-paths" json:"add-paths,omitempty"`
	// original -> bgp:afi-safis
	AfiSafis []AfiSafi `mapstructure:"afi-safis" json:"afi-safis,omitempty"`
	// original -> bgp:graceful-restart
	GracefulRestart GracefulRestart `mapstructure:"graceful-restart" json:"graceful-restart,omitempty"`
	// original -> rpol:apply-policy
	ApplyPolicy ApplyPolicy `mapstructure:"apply-policy" json:"apply-policy,omitempty"`
	// original -> bgp-mp:use-multiple-paths
	UseMultiplePaths UseMultiplePaths `mapstructure:"use-multiple-paths" json:"use-multiple-paths,omitempty"`
	// original -> gobgp:route-server
	RouteServer RouteServer `mapstructure:"route-server" json:"route-server,omitempty"`
}

struct for container bgp:peer-group

func (*PeerGroup) Equal 

func (lhs *PeerGroup) Equal(rhs *PeerGroup) bool

type PeerGroupConfig 

type PeerGroupConfig struct {
	// original -> bgp:peer-as
	//bgp:peer-as's original type is inet:as-number
	PeerAs uint32 `mapstructure:"peer-as" json:"peer-as,omitempty"`
	// original -> bgp:local-as
	//bgp:local-as's original type is inet:as-number
	LocalAs uint32 `mapstructure:"local-as" json:"local-as,omitempty"`
	// original -> bgp:peer-type
	PeerType PeerType `mapstructure:"peer-type" json:"peer-type,omitempty"`
	// original -> bgp:auth-password
	AuthPassword string `mapstructure:"auth-password" json:"auth-password,omitempty"`
	// original -> bgp:remove-private-as
	RemovePrivateAs RemovePrivateAsOption `mapstructure:"remove-private-as" json:"remove-private-as,omitempty"`
	// original -> bgp:route-flap-damping
	//bgp:route-flap-damping's original type is boolean
	RouteFlapDamping bool `mapstructure:"route-flap-damping" json:"route-flap-damping,omitempty"`
	// original -> bgp:send-community
	SendCommunity CommunityType `mapstructure:"send-community" json:"send-community,omitempty"`
	// original -> bgp:description
	Description string `mapstructure:"description" json:"description,omitempty"`
	// original -> bgp:peer-group-name
	PeerGroupName string `mapstructure:"peer-group-name" json:"peer-group-name,omitempty"`
}

struct for container bgp:config

func (*PeerGroupConfig) Equal 

func (lhs *PeerGroupConfig) Equal(rhs *PeerGroupConfig) bool

type PeerGroupState 

type PeerGroupState struct {
	// original -> bgp:peer-as
	//bgp:peer-as's original type is inet:as-number
	PeerAs uint32 `mapstructure:"peer-as" json:"peer-as,omitempty"`
	// original -> bgp:local-as
	//bgp:local-as's original type is inet:as-number
	LocalAs uint32 `mapstructure:"local-as" json:"local-as,omitempty"`
	// original -> bgp:peer-type
	PeerType PeerType `mapstructure:"peer-type" json:"peer-type,omitempty"`
	// original -> bgp:auth-password
	AuthPassword string `mapstructure:"auth-password" json:"auth-password,omitempty"`
	// original -> bgp:remove-private-as
	RemovePrivateAs RemovePrivateAsOption `mapstructure:"remove-private-as" json:"remove-private-as,omitempty"`
	// original -> bgp:route-flap-damping
	//bgp:route-flap-damping's original type is boolean
	RouteFlapDamping bool `mapstructure:"route-flap-damping" json:"route-flap-damping,omitempty"`
	// original -> bgp:send-community
	SendCommunity CommunityType `mapstructure:"send-community" json:"send-community,omitempty"`
	// original -> bgp:description
	Description string `mapstructure:"description" json:"description,omitempty"`
	// original -> bgp:peer-group-name
	PeerGroupName string `mapstructure:"peer-group-name" json:"peer-group-name,omitempty"`
	// original -> bgp-op:total-paths
	TotalPaths uint32 `mapstructure:"total-paths" json:"total-paths,omitempty"`
	// original -> bgp-op:total-prefixes
	TotalPrefixes uint32 `mapstructure:"total-prefixes" json:"total-prefixes,omitempty"`
}

struct for container bgp:state

type PeerType 

type PeerType string

typedef for identity bgp-types:peer-type 

const (
	PEER_TYPE_INTERNAL PeerType = "internal"
	PEER_TYPE_EXTERNAL PeerType = "external"
)

func (PeerType) ToInt 

func (v PeerType) ToInt() int

func (PeerType) Validate 

func (v PeerType) Validate() error

type Percentage 

type Percentage uint8

typedef for typedef openconfig-types:percentage

type PolicyDefinition 

type PolicyDefinition struct {
	// original -> rpol:name
	Name string `mapstructure:"name" json:"name,omitempty"`
	// original -> rpol:statements
	Statements []Statement `mapstructure:"statements" json:"statements,omitempty"`
}

struct for container rpol:policy-definition

func (*PolicyDefinition) Equal 

func (lhs *PolicyDefinition) Equal(rhs *PolicyDefinition) bool

type Prefix 

type Prefix struct {
	// original -> rpol:ip-prefix
	//rpol:ip-prefix's original type is inet:ip-prefix
	IpPrefix string `mapstructure:"ip-prefix" json:"ip-prefix,omitempty"`
	// original -> rpol:masklength-range
	MasklengthRange string `mapstructure:"masklength-range" json:"masklength-range,omitempty"`
}

struct for container rpol:prefix

func (*Prefix) Equal 

func (lhs *Prefix) Equal(rhs *Prefix) bool

type PrefixLimit 

type PrefixLimit struct {
	// original -> bgp-mp:prefix-limit-config
	Config PrefixLimitConfig `mapstructure:"config" json:"config,omitempty"`
	// original -> bgp-mp:prefix-limit-state
	State PrefixLimitState `mapstructure:"state" json:"state,omitempty"`
}

struct for container bgp-mp:prefix-limit

func (*PrefixLimit) Equal 

func (lhs *PrefixLimit) Equal(rhs *PrefixLimit) bool

type PrefixLimitConfig 

type PrefixLimitConfig struct {
	// original -> bgp-mp:max-prefixes
	MaxPrefixes uint32 `mapstructure:"max-prefixes" json:"max-prefixes,omitempty"`
	// original -> bgp-mp:shutdown-threshold-pct
	ShutdownThresholdPct Percentage `mapstructure:"shutdown-threshold-pct" json:"shutdown-threshold-pct,omitempty"`
	// original -> bgp-mp:restart-timer
	//bgp-mp:restart-timer's original type is decimal64
	RestartTimer float64 `mapstructure:"restart-timer" json:"restart-timer,omitempty"`
}

struct for container bgp-mp:config

func (*PrefixLimitConfig) Equal 

func (lhs *PrefixLimitConfig) Equal(rhs *PrefixLimitConfig) bool

type PrefixLimitState 

type PrefixLimitState struct {
	// original -> bgp-mp:max-prefixes
	MaxPrefixes uint32 `mapstructure:"max-prefixes" json:"max-prefixes,omitempty"`
	// original -> bgp-mp:shutdown-threshold-pct
	ShutdownThresholdPct Percentage `mapstructure:"shutdown-threshold-pct" json:"shutdown-threshold-pct,omitempty"`
	// original -> bgp-mp:restart-timer
	//bgp-mp:restart-timer's original type is decimal64
	RestartTimer float64 `mapstructure:"restart-timer" json:"restart-timer,omitempty"`
}

struct for container bgp-mp:state

type PrefixSet 

type PrefixSet struct {
	// original -> rpol:prefix-set-name
	PrefixSetName string `mapstructure:"prefix-set-name" json:"prefix-set-name,omitempty"`
	// original -> rpol:prefix
	PrefixList []Prefix `mapstructure:"prefix-list" json:"prefix-list,omitempty"`
}

struct for container rpol:prefix-set

func (*PrefixSet) Equal 

func (lhs *PrefixSet) Equal(rhs *PrefixSet) bool

type Prefixes 

type Prefixes struct {
	// original -> bgp-op:received
	Received uint32 `mapstructure:"received" json:"received,omitempty"`
	// original -> bgp-op:sent
	Sent uint32 `mapstructure:"sent" json:"sent,omitempty"`
	// original -> bgp-op:installed
	Installed uint32 `mapstructure:"installed" json:"installed,omitempty"`
}

struct for container bgp-op:prefixes

func (*Prefixes) Equal 

func (lhs *Prefixes) Equal(rhs *Prefixes) bool

type Queues 

type Queues struct {
	// original -> bgp-op:input
	Input uint32 `mapstructure:"input" json:"input,omitempty"`
	// original -> bgp-op:output
	Output uint32 `mapstructure:"output" json:"output,omitempty"`
}

struct for container bgp:queues

func (*Queues) Equal 

func (lhs *Queues) Equal(rhs *Queues) bool

type Received 

type Received struct {
	// original -> bgp-op:UPDATE
	Update uint64 `mapstructure:"update" json:"update,omitempty"`
	// original -> bgp-op:NOTIFICATION
	Notification uint64 `mapstructure:"notification" json:"notification,omitempty"`
	// original -> gobgp:OPEN
	Open uint64 `mapstructure:"open" json:"open,omitempty"`
	// original -> gobgp:REFRESH
	Refresh uint64 `mapstructure:"refresh" json:"refresh,omitempty"`
	// original -> gobgp:KEEPALIVE
	Keepalive uint64 `mapstructure:"keepalive" json:"keepalive,omitempty"`
	// original -> gobgp:DYNAMIC-CAP
	DynamicCap uint64 `mapstructure:"dynamic-cap" json:"dynamic-cap,omitempty"`
	// original -> gobgp:DISCARDED
	Discarded uint64 `mapstructure:"discarded" json:"discarded,omitempty"`
	// original -> gobgp:TOTAL
	Total uint64 `mapstructure:"total" json:"total,omitempty"`
}

struct for container bgp:received

func (*Received) Equal 

func (lhs *Received) Equal(rhs *Received) bool

type RemovePrivateAsOption 

type RemovePrivateAsOption string

typedef for identity bgp-types:remove-private-as-option 

const (
	REMOVE_PRIVATE_AS_OPTION_ALL     RemovePrivateAsOption = "all"
	REMOVE_PRIVATE_AS_OPTION_REPLACE RemovePrivateAsOption = "replace"
)

func (RemovePrivateAsOption) ToInt 

func (v RemovePrivateAsOption) ToInt() int

func (RemovePrivateAsOption) Validate 

func (v RemovePrivateAsOption) Validate() error

type RouteDisposition 

type RouteDisposition string

typedef for identity rpol:route-disposition 

const (
	ROUTE_DISPOSITION_NONE         RouteDisposition = "none"
	ROUTE_DISPOSITION_ACCEPT_ROUTE RouteDisposition = "accept-route"
	ROUTE_DISPOSITION_REJECT_ROUTE RouteDisposition = "reject-route"
)

func (RouteDisposition) ToInt 

func (v RouteDisposition) ToInt() int

func (RouteDisposition) Validate 

func (v RouteDisposition) Validate() error

type RouteReflector 

type RouteReflector struct {
	// original -> bgp:route-reflector-config
	Config RouteReflectorConfig `mapstructure:"config" json:"config,omitempty"`
	// original -> bgp:route-reflector-state
	State RouteReflectorState `mapstructure:"state" json:"state,omitempty"`
}

struct for container bgp:route-reflector

func (*RouteReflector) Equal 

func (lhs *RouteReflector) Equal(rhs *RouteReflector) bool

type RouteReflectorConfig 

type RouteReflectorConfig struct {
	// original -> bgp:route-reflector-cluster-id
	RouteReflectorClusterId RrClusterIdType `mapstructure:"route-reflector-cluster-id" json:"route-reflector-cluster-id,omitempty"`
	// original -> bgp:route-reflector-client
	//bgp:route-reflector-client's original type is boolean
	RouteReflectorClient bool `mapstructure:"route-reflector-client" json:"route-reflector-client,omitempty"`
}

struct for container bgp:config

func (*RouteReflectorConfig) Equal 

func (lhs *RouteReflectorConfig) Equal(rhs *RouteReflectorConfig) bool

type RouteReflectorState 

type RouteReflectorState struct {
	// original -> bgp:route-reflector-cluster-id
	RouteReflectorClusterId RrClusterIdType `mapstructure:"route-reflector-cluster-id" json:"route-reflector-cluster-id,omitempty"`
	// original -> bgp:route-reflector-client
	//bgp:route-reflector-client's original type is boolean
	RouteReflectorClient bool `mapstructure:"route-reflector-client" json:"route-reflector-client,omitempty"`
}

struct for container bgp:state

type RouteSelectionOptions 

type RouteSelectionOptions struct {
	// original -> bgp-mp:route-selection-options-config
	Config RouteSelectionOptionsConfig `mapstructure:"config" json:"config,omitempty"`
	// original -> bgp-mp:route-selection-options-state
	State RouteSelectionOptionsState `mapstructure:"state" json:"state,omitempty"`
}

struct for container bgp-mp:route-selection-options

func (*RouteSelectionOptions) Equal 

func (lhs *RouteSelectionOptions) Equal(rhs *RouteSelectionOptions) bool

type RouteSelectionOptionsConfig 

type RouteSelectionOptionsConfig struct {
	// original -> bgp-mp:always-compare-med
	//bgp-mp:always-compare-med's original type is boolean
	AlwaysCompareMed bool `mapstructure:"always-compare-med" json:"always-compare-med,omitempty"`
	// original -> bgp-mp:ignore-as-path-length
	//bgp-mp:ignore-as-path-length's original type is boolean
	IgnoreAsPathLength bool `mapstructure:"ignore-as-path-length" json:"ignore-as-path-length,omitempty"`
	// original -> bgp-mp:external-compare-router-id
	//bgp-mp:external-compare-router-id's original type is boolean
	ExternalCompareRouterId bool `mapstructure:"external-compare-router-id" json:"external-compare-router-id,omitempty"`
	// original -> bgp-mp:advertise-inactive-routes
	//bgp-mp:advertise-inactive-routes's original type is boolean
	AdvertiseInactiveRoutes bool `mapstructure:"advertise-inactive-routes" json:"advertise-inactive-routes,omitempty"`
	// original -> bgp-mp:enable-aigp
	//bgp-mp:enable-aigp's original type is boolean
	EnableAigp bool `mapstructure:"enable-aigp" json:"enable-aigp,omitempty"`
	// original -> bgp-mp:ignore-next-hop-igp-metric
	//bgp-mp:ignore-next-hop-igp-metric's original type is boolean
	IgnoreNextHopIgpMetric bool `mapstructure:"ignore-next-hop-igp-metric" json:"ignore-next-hop-igp-metric,omitempty"`
}

struct for container bgp-mp:config

func (*RouteSelectionOptionsConfig) Equal 

func (lhs *RouteSelectionOptionsConfig) Equal(rhs *RouteSelectionOptionsConfig) bool

type RouteSelectionOptionsState 

type RouteSelectionOptionsState struct {
	// original -> bgp-mp:always-compare-med
	//bgp-mp:always-compare-med's original type is boolean
	AlwaysCompareMed bool `mapstructure:"always-compare-med" json:"always-compare-med,omitempty"`
	// original -> bgp-mp:ignore-as-path-length
	//bgp-mp:ignore-as-path-length's original type is boolean
	IgnoreAsPathLength bool `mapstructure:"ignore-as-path-length" json:"ignore-as-path-length,omitempty"`
	// original -> bgp-mp:external-compare-router-id
	//bgp-mp:external-compare-router-id's original type is boolean
	ExternalCompareRouterId bool `mapstructure:"external-compare-router-id" json:"external-compare-router-id,omitempty"`
	// original -> bgp-mp:advertise-inactive-routes
	//bgp-mp:advertise-inactive-routes's original type is boolean
	AdvertiseInactiveRoutes bool `mapstructure:"advertise-inactive-routes" json:"advertise-inactive-routes,omitempty"`
	// original -> bgp-mp:enable-aigp
	//bgp-mp:enable-aigp's original type is boolean
	EnableAigp bool `mapstructure:"enable-aigp" json:"enable-aigp,omitempty"`
	// original -> bgp-mp:ignore-next-hop-igp-metric
	//bgp-mp:ignore-next-hop-igp-metric's original type is boolean
	IgnoreNextHopIgpMetric bool `mapstructure:"ignore-next-hop-igp-metric" json:"ignore-next-hop-igp-metric,omitempty"`
}

struct for container bgp-mp:state

type RouteServer 

type RouteServer struct {
	// original -> gobgp:route-server-config
	Config RouteServerConfig `mapstructure:"config" json:"config,omitempty"`
	// original -> gobgp:route-server-state
	State RouteServerState `mapstructure:"state" json:"state,omitempty"`
}

struct for container gobgp:route-server

func (*RouteServer) Equal 

func (lhs *RouteServer) Equal(rhs *RouteServer) bool

type RouteServerConfig 

type RouteServerConfig struct {
	// original -> gobgp:route-server-client
	//gobgp:route-server-client's original type is boolean
	RouteServerClient bool `mapstructure:"route-server-client" json:"route-server-client,omitempty"`
}

struct for container gobgp:config

func (*RouteServerConfig) Equal 

func (lhs *RouteServerConfig) Equal(rhs *RouteServerConfig) bool

type RouteServerState 

type RouteServerState struct {
	// original -> gobgp:route-server-client
	//gobgp:route-server-client's original type is boolean
	RouteServerClient bool `mapstructure:"route-server-client" json:"route-server-client,omitempty"`
}

struct for container gobgp:state

type RouteTargetMembership 

type RouteTargetMembership struct {
	// original -> gobgp:route-target-membership-config
	Config RouteTargetMembershipConfig `mapstructure:"config" json:"config,omitempty"`
	// original -> gobgp:route-target-membership-state
	State RouteTargetMembershipState `mapstructure:"state" json:"state,omitempty"`
}

struct for container gobgp:route-target-membership

func (*RouteTargetMembership) Equal 

func (lhs *RouteTargetMembership) Equal(rhs *RouteTargetMembership) bool

type RouteTargetMembershipConfig 

type RouteTargetMembershipConfig struct {
	// original -> gobgp:deferral-time
	DeferralTime uint16 `mapstructure:"deferral-time" json:"deferral-time,omitempty"`
}

struct for container gobgp:config

func (*RouteTargetMembershipConfig) Equal 

func (lhs *RouteTargetMembershipConfig) Equal(rhs *RouteTargetMembershipConfig) bool

type RouteTargetMembershipState 

type RouteTargetMembershipState struct {
	// original -> gobgp:deferral-time
	DeferralTime uint16 `mapstructure:"deferral-time" json:"deferral-time,omitempty"`
}

struct for container gobgp:state

type RouteType 

type RouteType string

typedef for identity rpol:route-type 

const (
	ROUTE_TYPE_NONE     RouteType = "none"
	ROUTE_TYPE_INTERNAL RouteType = "internal"
	ROUTE_TYPE_EXTERNAL RouteType = "external"
	ROUTE_TYPE_LOCAL    RouteType = "local"
)

func (RouteType) ToInt 

func (v RouteType) ToInt() int

func (RouteType) Validate 

func (v RouteType) Validate() error

type RoutingPolicy 

type RoutingPolicy struct {
	// original -> rpol:defined-sets
	DefinedSets DefinedSets `mapstructure:"defined-sets" json:"defined-sets,omitempty"`
	// original -> rpol:policy-definitions
	PolicyDefinitions []PolicyDefinition `mapstructure:"policy-definitions" json:"policy-definitions,omitempty"`
}

struct for container rpol:routing-policy

func ConfigSetToRoutingPolicy 

func ConfigSetToRoutingPolicy(c *BgpConfigSet) *RoutingPolicy

func (*RoutingPolicy) Equal 

func (lhs *RoutingPolicy) Equal(rhs *RoutingPolicy) bool

type RpkiMessages 

type RpkiMessages struct {
	// original -> gobgp:rpki-sent
	RpkiSent RpkiSent `mapstructure:"rpki-sent" json:"rpki-sent,omitempty"`
	// original -> gobgp:rpki-received
	RpkiReceived RpkiReceived `mapstructure:"rpki-received" json:"rpki-received,omitempty"`
}

struct for container gobgp:rpki-messages

func (*RpkiMessages) Equal 

func (lhs *RpkiMessages) Equal(rhs *RpkiMessages) bool

type RpkiReceived 

type RpkiReceived struct {
	// original -> gobgp:serial-notify
	SerialNotify int64 `mapstructure:"serial-notify" json:"serial-notify,omitempty"`
	// original -> gobgp:cache-reset
	CacheReset int64 `mapstructure:"cache-reset" json:"cache-reset,omitempty"`
	// original -> gobgp:cache-response
	CacheResponse int64 `mapstructure:"cache-response" json:"cache-response,omitempty"`
	// original -> gobgp:ipv4-prefix
	Ipv4Prefix int64 `mapstructure:"ipv4-prefix" json:"ipv4-prefix,omitempty"`
	// original -> gobgp:ipv6-prefix
	Ipv6Prefix int64 `mapstructure:"ipv6-prefix" json:"ipv6-prefix,omitempty"`
	// original -> gobgp:end-of-data
	EndOfData int64 `mapstructure:"end-of-data" json:"end-of-data,omitempty"`
	// original -> gobgp:error
	Error int64 `mapstructure:"error" json:"error,omitempty"`
}

struct for container gobgp:rpki-received

func (*RpkiReceived) Equal 

func (lhs *RpkiReceived) Equal(rhs *RpkiReceived) bool

type RpkiSent 

type RpkiSent struct {
	// original -> gobgp:serial-query
	SerialQuery int64 `mapstructure:"serial-query" json:"serial-query,omitempty"`
	// original -> gobgp:reset-query
	ResetQuery int64 `mapstructure:"reset-query" json:"reset-query,omitempty"`
	// original -> gobgp:error
	Error int64 `mapstructure:"error" json:"error,omitempty"`
}

struct for container gobgp:rpki-sent

func (*RpkiSent) Equal 

func (lhs *RpkiSent) Equal(rhs *RpkiSent) bool

type RpkiServer 

type RpkiServer struct {
	// original -> gobgp:address
	// original -> gobgp:rpki-server-config
	Config RpkiServerConfig `mapstructure:"config" json:"config,omitempty"`
	// original -> gobgp:rpki-server-state
	State RpkiServerState `mapstructure:"state" json:"state,omitempty"`
}

struct for container gobgp:rpki-server

func (*RpkiServer) Equal 

func (lhs *RpkiServer) Equal(rhs *RpkiServer) bool

type RpkiServerConfig 

type RpkiServerConfig struct {
	// original -> gobgp:address
	//gobgp:address's original type is inet:ip-address
	Address string `mapstructure:"address" json:"address,omitempty"`
	// original -> gobgp:port
	Port uint32 `mapstructure:"port" json:"port,omitempty"`
	// original -> gobgp:refresh-time
	RefreshTime int64 `mapstructure:"refresh-time" json:"refresh-time,omitempty"`
	// original -> gobgp:hold-time
	HoldTime int64 `mapstructure:"hold-time" json:"hold-time,omitempty"`
	// original -> gobgp:record-lifetime
	RecordLifetime int64 `mapstructure:"record-lifetime" json:"record-lifetime,omitempty"`
	// original -> gobgp:preference
	Preference uint8 `mapstructure:"preference" json:"preference,omitempty"`
}

struct for container gobgp:config

func (*RpkiServerConfig) Equal 

func (lhs *RpkiServerConfig) Equal(rhs *RpkiServerConfig) bool

type RpkiServerState 

type RpkiServerState struct {
	// original -> gobgp:up
	//gobgp:up's original type is boolean
	Up bool `mapstructure:"up" json:"up,omitempty"`
	// original -> gobgp:serial-number
	SerialNumber uint32 `mapstructure:"serial-number" json:"serial-number,omitempty"`
	// original -> gobgp:records-v4
	RecordsV4 uint32 `mapstructure:"records-v4" json:"records-v4,omitempty"`
	// original -> gobgp:records-v6
	RecordsV6 uint32 `mapstructure:"records-v6" json:"records-v6,omitempty"`
	// original -> gobgp:prefixes-v4
	PrefixesV4 uint32 `mapstructure:"prefixes-v4" json:"prefixes-v4,omitempty"`
	// original -> gobgp:prefixes-v6
	PrefixesV6 uint32 `mapstructure:"prefixes-v6" json:"prefixes-v6,omitempty"`
	// original -> gobgp:uptime
	Uptime int64 `mapstructure:"uptime" json:"uptime,omitempty"`
	// original -> gobgp:downtime
	Downtime int64 `mapstructure:"downtime" json:"downtime,omitempty"`
	// original -> gobgp:last-pdu-recv-time
	LastPduRecvTime int64 `mapstructure:"last-pdu-recv-time" json:"last-pdu-recv-time,omitempty"`
	// original -> gobgp:rpki-messages
	RpkiMessages RpkiMessages `mapstructure:"rpki-messages" json:"rpki-messages,omitempty"`
}

struct for container gobgp:state

type RpkiValidationResultType 

type RpkiValidationResultType string

typedef for identity gobgp:rpki-validation-result-type 

const (
	RPKI_VALIDATION_RESULT_TYPE_NONE      RpkiValidationResultType = "none"
	RPKI_VALIDATION_RESULT_TYPE_NOT_FOUND RpkiValidationResultType = "not-found"
	RPKI_VALIDATION_RESULT_TYPE_VALID     RpkiValidationResultType = "valid"
	RPKI_VALIDATION_RESULT_TYPE_INVALID   RpkiValidationResultType = "invalid"
)

func (RpkiValidationResultType) ToInt 

func (v RpkiValidationResultType) ToInt() int

func (RpkiValidationResultType) Validate 

func (v RpkiValidationResultType) Validate() error

type RrClusterIdType 

type RrClusterIdType string

typedef for typedef bgp-types:rr-cluster-id-type

type Sent 

type Sent struct {
	// original -> bgp-op:UPDATE
	Update uint64 `mapstructure:"update" json:"update,omitempty"`
	// original -> bgp-op:NOTIFICATION
	Notification uint64 `mapstructure:"notification" json:"notification,omitempty"`
	// original -> gobgp:OPEN
	Open uint64 `mapstructure:"open" json:"open,omitempty"`
	// original -> gobgp:REFRESH
	Refresh uint64 `mapstructure:"refresh" json:"refresh,omitempty"`
	// original -> gobgp:KEEPALIVE
	Keepalive uint64 `mapstructure:"keepalive" json:"keepalive,omitempty"`
	// original -> gobgp:DYNAMIC-CAP
	DynamicCap uint64 `mapstructure:"dynamic-cap" json:"dynamic-cap,omitempty"`
	// original -> gobgp:DISCARDED
	Discarded uint64 `mapstructure:"discarded" json:"discarded,omitempty"`
	// original -> gobgp:TOTAL
	Total uint64 `mapstructure:"total" json:"total,omitempty"`
}

struct for container bgp:sent

func (*Sent) Equal 

func (lhs *Sent) Equal(rhs *Sent) bool

type SessionState 

type SessionState string

typedef for identity bgp:session-state 

const (
	SESSION_STATE_IDLE        SessionState = "idle"
	SESSION_STATE_CONNECT     SessionState = "connect"
	SESSION_STATE_ACTIVE      SessionState = "active"
	SESSION_STATE_OPENSENT    SessionState = "opensent"
	SESSION_STATE_OPENCONFIRM SessionState = "openconfirm"
	SESSION_STATE_ESTABLISHED SessionState = "established"
)

func (SessionState) ToInt 

func (v SessionState) ToInt() int

func (SessionState) Validate 

func (v SessionState) Validate() error

type SetAsPathPrepend 

type SetAsPathPrepend struct {
	// original -> bgp-pol:repeat-n
	RepeatN uint8 `mapstructure:"repeat-n" json:"repeat-n,omitempty"`
	// original -> gobgp:as
	//gobgp:as's original type is union
	As string `mapstructure:"as" json:"as,omitempty"`
}

struct for container bgp-pol:set-as-path-prepend

func (*SetAsPathPrepend) Equal 

func (lhs *SetAsPathPrepend) Equal(rhs *SetAsPathPrepend) bool

type SetCommunity 

type SetCommunity struct {
	// original -> bgp-pol:set-community-method
	SetCommunityMethod SetCommunityMethod `mapstructure:"set-community-method" json:"set-community-method,omitempty"`
	// original -> bgp-pol:options
	//bgp-pol:options's original type is bgp-set-community-option-type
	Options string `mapstructure:"options" json:"options,omitempty"`
}

struct for container bgp-pol:set-community

func (*SetCommunity) Equal 

func (lhs *SetCommunity) Equal(rhs *SetCommunity) bool

type SetCommunityMethod 

type SetCommunityMethod struct {
	// original -> bgp-pol:communities
	// original type is list of union
	CommunitiesList []string `mapstructure:"communities-list" json:"communities-list,omitempty"`
	// original -> bgp-pol:community-set-ref
	CommunitySetRef string `mapstructure:"community-set-ref" json:"community-set-ref,omitempty"`
}

struct for container bgp-pol:set-community-method

func (*SetCommunityMethod) Equal 

func (lhs *SetCommunityMethod) Equal(rhs *SetCommunityMethod) bool

type SetExtCommunity 

type SetExtCommunity struct {
	// original -> bgp-pol:set-ext-community-method
	SetExtCommunityMethod SetExtCommunityMethod `mapstructure:"set-ext-community-method" json:"set-ext-community-method,omitempty"`
	// original -> bgp-pol:options
	//bgp-pol:options's original type is bgp-set-community-option-type
	Options string `mapstructure:"options" json:"options,omitempty"`
}

struct for container bgp-pol:set-ext-community

func (*SetExtCommunity) Equal 

func (lhs *SetExtCommunity) Equal(rhs *SetExtCommunity) bool

type SetExtCommunityMethod 

type SetExtCommunityMethod struct {
	// original -> bgp-pol:communities
	// original type is list of union
	CommunitiesList []string `mapstructure:"communities-list" json:"communities-list,omitempty"`
	// original -> bgp-pol:ext-community-set-ref
	ExtCommunitySetRef string `mapstructure:"ext-community-set-ref" json:"ext-community-set-ref,omitempty"`
}

struct for container bgp-pol:set-ext-community-method

func (*SetExtCommunityMethod) Equal 

func (lhs *SetExtCommunityMethod) Equal(rhs *SetExtCommunityMethod) bool

type SetLargeCommunity 

type SetLargeCommunity struct {
	// original -> gobgp:set-large-community-method
	SetLargeCommunityMethod SetLargeCommunityMethod `mapstructure:"set-large-community-method" json:"set-large-community-method,omitempty"`
	// original -> gobgp:options
	Options BgpSetCommunityOptionType `mapstructure:"options" json:"options,omitempty"`
}

struct for container gobgp:set-large-community

func (*SetLargeCommunity) Equal 

func (lhs *SetLargeCommunity) Equal(rhs *SetLargeCommunity) bool

type SetLargeCommunityMethod 

type SetLargeCommunityMethod struct {
	// original -> gobgp:communities
	CommunitiesList []string `mapstructure:"communities-list" json:"communities-list,omitempty"`
}

struct for container gobgp:set-large-community-method

func (*SetLargeCommunityMethod) Equal 

func (lhs *SetLargeCommunityMethod) Equal(rhs *SetLargeCommunityMethod) bool

type Statement 

type Statement struct {
	// original -> rpol:name
	Name string `mapstructure:"name" json:"name,omitempty"`
	// original -> rpol:conditions
	Conditions Conditions `mapstructure:"conditions" json:"conditions,omitempty"`
	// original -> rpol:actions
	Actions Actions `mapstructure:"actions" json:"actions,omitempty"`
}

struct for container rpol:statement

func (*Statement) Equal 

func (lhs *Statement) Equal(rhs *Statement) bool

type StdRegexp 

type StdRegexp string

typedef for typedef openconfig-types:std-regexp

type Tag 

type Tag struct {
	// original -> rpol:value
	Value TagType `mapstructure:"value" json:"value,omitempty"`
}

struct for container rpol:tag

func (*Tag) Equal 

func (lhs *Tag) Equal(rhs *Tag) bool

type TagSet 

type TagSet struct {
	// original -> rpol:tag-set-name
	TagSetName string `mapstructure:"tag-set-name" json:"tag-set-name,omitempty"`
	// original -> rpol:tag
	TagList []Tag `mapstructure:"tag-list" json:"tag-list,omitempty"`
}

struct for container rpol:tag-set

func (*TagSet) Equal 

func (lhs *TagSet) Equal(rhs *TagSet) bool

type TagType 

type TagType string

typedef for typedef ptypes:tag-type

type Timers 

type Timers struct {
	// original -> bgp:timers-config
	Config TimersConfig `mapstructure:"config" json:"config,omitempty"`
	// original -> bgp:timers-state
	State TimersState `mapstructure:"state" json:"state,omitempty"`
}

struct for container bgp:timers

func (*Timers) Equal 

func (lhs *Timers) Equal(rhs *Timers) bool

type TimersConfig 

type TimersConfig struct {
	// original -> bgp:connect-retry
	//bgp:connect-retry's original type is decimal64
	ConnectRetry float64 `mapstructure:"connect-retry" json:"connect-retry,omitempty"`
	// original -> bgp:hold-time
	//bgp:hold-time's original type is decimal64
	HoldTime float64 `mapstructure:"hold-time" json:"hold-time,omitempty"`
	// original -> bgp:keepalive-interval
	//bgp:keepalive-interval's original type is decimal64
	KeepaliveInterval float64 `mapstructure:"keepalive-interval" json:"keepalive-interval,omitempty"`
	// original -> bgp:minimum-advertisement-interval
	//bgp:minimum-advertisement-interval's original type is decimal64
	MinimumAdvertisementInterval float64 `mapstructure:"minimum-advertisement-interval" json:"minimum-advertisement-interval,omitempty"`
	// original -> gobgp:idle-hold-time-after-reset
	//gobgp:idle-hold-time-after-reset's original type is decimal64
	IdleHoldTimeAfterReset float64 `mapstructure:"idle-hold-time-after-reset" json:"idle-hold-time-after-reset,omitempty"`
}

struct for container bgp:config

func (*TimersConfig) Equal 

func (lhs *TimersConfig) Equal(rhs *TimersConfig) bool

type TimersState 

type TimersState struct {
	// original -> bgp:connect-retry
	//bgp:connect-retry's original type is decimal64
	ConnectRetry float64 `mapstructure:"connect-retry" json:"connect-retry,omitempty"`
	// original -> bgp:hold-time
	//bgp:hold-time's original type is decimal64
	HoldTime float64 `mapstructure:"hold-time" json:"hold-time,omitempty"`
	// original -> bgp:keepalive-interval
	//bgp:keepalive-interval's original type is decimal64
	KeepaliveInterval float64 `mapstructure:"keepalive-interval" json:"keepalive-interval,omitempty"`
	// original -> bgp:minimum-advertisement-interval
	//bgp:minimum-advertisement-interval's original type is decimal64
	MinimumAdvertisementInterval float64 `mapstructure:"minimum-advertisement-interval" json:"minimum-advertisement-interval,omitempty"`
	// original -> bgp-op:uptime
	//bgp-op:uptime's original type is yang:timeticks
	Uptime int64 `mapstructure:"uptime" json:"uptime,omitempty"`
	// original -> bgp-op:negotiated-hold-time
	//bgp-op:negotiated-hold-time's original type is decimal64
	NegotiatedHoldTime float64 `mapstructure:"negotiated-hold-time" json:"negotiated-hold-time,omitempty"`
	// original -> gobgp:idle-hold-time-after-reset
	//gobgp:idle-hold-time-after-reset's original type is decimal64
	IdleHoldTimeAfterReset float64 `mapstructure:"idle-hold-time-after-reset" json:"idle-hold-time-after-reset,omitempty"`
	// original -> gobgp:downtime
	//gobgp:downtime's original type is yang:timeticks
	Downtime int64 `mapstructure:"downtime" json:"downtime,omitempty"`
	// original -> gobgp:update-recv-time
	UpdateRecvTime int64 `mapstructure:"update-recv-time" json:"update-recv-time,omitempty"`
}

struct for container bgp:state

type Transport 

type Transport struct {
	// original -> bgp:transport-config
	Config TransportConfig `mapstructure:"config" json:"config,omitempty"`
	// original -> bgp:transport-state
	State TransportState `mapstructure:"state" json:"state,omitempty"`
}

struct for container bgp:transport

func (*Transport) Equal 

func (lhs *Transport) Equal(rhs *Transport) bool

type TransportConfig 

type TransportConfig struct {
	// original -> bgp:tcp-mss
	TcpMss uint16 `mapstructure:"tcp-mss" json:"tcp-mss,omitempty"`
	// original -> bgp:mtu-discovery
	//bgp:mtu-discovery's original type is boolean
	MtuDiscovery bool `mapstructure:"mtu-discovery" json:"mtu-discovery,omitempty"`
	// original -> bgp:passive-mode
	//bgp:passive-mode's original type is boolean
	PassiveMode bool `mapstructure:"passive-mode" json:"passive-mode,omitempty"`
	// original -> bgp:local-address
	//bgp:local-address's original type is union
	LocalAddress string `mapstructure:"local-address" json:"local-address,omitempty"`
	// original -> gobgp:remote-port
	//gobgp:remote-port's original type is inet:port-number
	RemotePort uint16 `mapstructure:"remote-port" json:"remote-port,omitempty"`
}

struct for container bgp:config

func (*TransportConfig) Equal 

func (lhs *TransportConfig) Equal(rhs *TransportConfig) bool

type TransportState 

type TransportState struct {
	// original -> bgp:tcp-mss
	TcpMss uint16 `mapstructure:"tcp-mss" json:"tcp-mss,omitempty"`
	// original -> bgp:mtu-discovery
	//bgp:mtu-discovery's original type is boolean
	MtuDiscovery bool `mapstructure:"mtu-discovery" json:"mtu-discovery,omitempty"`
	// original -> bgp:passive-mode
	//bgp:passive-mode's original type is boolean
	PassiveMode bool `mapstructure:"passive-mode" json:"passive-mode,omitempty"`
	// original -> bgp:local-address
	//bgp:local-address's original type is union
	LocalAddress string `mapstructure:"local-address" json:"local-address,omitempty"`
	// original -> bgp-op:local-port
	//bgp-op:local-port's original type is inet:port-number
	LocalPort uint16 `mapstructure:"local-port" json:"local-port,omitempty"`
	// original -> bgp-op:remote-address
	//bgp-op:remote-address's original type is inet:ip-address
	RemoteAddress string `mapstructure:"remote-address" json:"remote-address,omitempty"`
	// original -> bgp-op:remote-port
	//bgp-op:remote-port's original type is inet:port-number
	RemotePort uint16 `mapstructure:"remote-port" json:"remote-port,omitempty"`
}

struct for container bgp:state

type UseMultiplePaths 

type UseMultiplePaths struct {
	// original -> bgp-mp:use-multiple-paths-config
	Config UseMultiplePathsConfig `mapstructure:"config" json:"config,omitempty"`
	// original -> bgp-mp:use-multiple-paths-state
	State UseMultiplePathsState `mapstructure:"state" json:"state,omitempty"`
	// original -> bgp-mp:ebgp
	Ebgp Ebgp `mapstructure:"ebgp" json:"ebgp,omitempty"`
	// original -> bgp-mp:ibgp
	Ibgp Ibgp `mapstructure:"ibgp" json:"ibgp,omitempty"`
}

struct for container bgp-mp:use-multiple-paths

func (*UseMultiplePaths) Equal 

func (lhs *UseMultiplePaths) Equal(rhs *UseMultiplePaths) bool

type UseMultiplePathsConfig 

type UseMultiplePathsConfig struct {
	// original -> bgp-mp:enabled
	//bgp-mp:enabled's original type is boolean
	Enabled bool `mapstructure:"enabled" json:"enabled,omitempty"`
}

struct for container bgp-mp:config

func (*UseMultiplePathsConfig) Equal 

func (lhs *UseMultiplePathsConfig) Equal(rhs *UseMultiplePathsConfig) bool

type UseMultiplePathsState 

type UseMultiplePathsState struct {
	// original -> bgp-mp:enabled
	//bgp-mp:enabled's original type is boolean
	Enabled bool `mapstructure:"enabled" json:"enabled,omitempty"`
}

struct for container bgp-mp:state

type Zebra 

type Zebra struct {
	// original -> gobgp:zebra-config
	Config ZebraConfig `mapstructure:"config" json:"config,omitempty"`
	// original -> gobgp:zebra-state
	State ZebraState `mapstructure:"state" json:"state,omitempty"`
}

struct for container gobgp:zebra

func (*Zebra) Equal 

func (lhs *Zebra) Equal(rhs *Zebra) bool

type ZebraConfig 

type ZebraConfig struct {
	// original -> gobgp:enabled
	//gobgp:enabled's original type is boolean
	Enabled bool `mapstructure:"enabled" json:"enabled,omitempty"`
	// original -> gobgp:url
	Url string `mapstructure:"url" json:"url,omitempty"`
	// original -> gobgp:redistribute-route-type
	RedistributeRouteTypeList []InstallProtocolType `mapstructure:"redistribute-route-type-list" json:"redistribute-route-type-list,omitempty"`
	// original -> gobgp:version
	Version uint8 `mapstructure:"version" json:"version,omitempty"`
	// original -> gobgp:nexthop-trigger-enable
	//gobgp:nexthop-trigger-enable's original type is boolean
	NexthopTriggerEnable bool `mapstructure:"nexthop-trigger-enable" json:"nexthop-trigger-enable,omitempty"`
	// original -> gobgp:nexthop-trigger-delay
	NexthopTriggerDelay uint8 `mapstructure:"nexthop-trigger-delay" json:"nexthop-trigger-delay,omitempty"`
}

struct for container gobgp:config

func (*ZebraConfig) Equal 

func (lhs *ZebraConfig) Equal(rhs *ZebraConfig) bool

type ZebraState 

type ZebraState struct {
	// original -> gobgp:enabled
	//gobgp:enabled's original type is boolean
	Enabled bool `mapstructure:"enabled" json:"enabled,omitempty"`
	// original -> gobgp:url
	Url string `mapstructure:"url" json:"url,omitempty"`
	// original -> gobgp:redistribute-route-type
	RedistributeRouteTypeList []InstallProtocolType `mapstructure:"redistribute-route-type-list" json:"redistribute-route-type-list,omitempty"`
	// original -> gobgp:version
	Version uint8 `mapstructure:"version" json:"version,omitempty"`
	// original -> gobgp:nexthop-trigger-enable
	//gobgp:nexthop-trigger-enable's original type is boolean
	NexthopTriggerEnable bool `mapstructure:"nexthop-trigger-enable" json:"nexthop-trigger-enable,omitempty"`
	// original -> gobgp:nexthop-trigger-delay
	NexthopTriggerDelay uint8 `mapstructure:"nexthop-trigger-delay" json:"nexthop-trigger-delay,omitempty"`
}

struct for container gobgp:state

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.