// DO NOT EDIT
// generated by pyang using OpenConfig https://github.com/openconfig/public
//
// Copyright (C) 2014,2015 Nippon Telegraph and Telephone Corporation.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
// implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package config

import "fmt"

// typedef for typedef openconfig-types:std-regexp
type StdRegexp string

// typedef for typedef openconfig-types:percentage
type Percentage uint8

// typedef for typedef bgp-types:rr-cluster-id-type
type RrClusterIdType string

// typedef for identity bgp-types:remove-private-as-option
type RemovePrivateAsOption string

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

var RemovePrivateAsOptionToIntMap = map[RemovePrivateAsOption]int{
	REMOVE_PRIVATE_AS_OPTION_ALL:     0,
	REMOVE_PRIVATE_AS_OPTION_REPLACE: 1,
}

func (v RemovePrivateAsOption) ToInt() int {
	i, ok := RemovePrivateAsOptionToIntMap[v]
	if !ok {
		return -1
	}
	return i
}

var IntToRemovePrivateAsOptionMap = map[int]RemovePrivateAsOption{
	0: REMOVE_PRIVATE_AS_OPTION_ALL,
	1: REMOVE_PRIVATE_AS_OPTION_REPLACE,
}

func (v RemovePrivateAsOption) Validate() error {
	if _, ok := RemovePrivateAsOptionToIntMap[v]; !ok {
		return fmt.Errorf("invalid RemovePrivateAsOption: %s", v)
	}
	return nil
}

// typedef for typedef bgp-types:bgp-community-regexp-type
type BgpCommunityRegexpType StdRegexp

// typedef for identity bgp-types:community-type
type CommunityType string

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

var CommunityTypeToIntMap = map[CommunityType]int{
	COMMUNITY_TYPE_STANDARD: 0,
	COMMUNITY_TYPE_EXTENDED: 1,
	COMMUNITY_TYPE_BOTH:     2,
	COMMUNITY_TYPE_NONE:     3,
}

func (v CommunityType) ToInt() int {
	i, ok := CommunityTypeToIntMap[v]
	if !ok {
		return -1
	}
	return i
}

var IntToCommunityTypeMap = map[int]CommunityType{
	0: COMMUNITY_TYPE_STANDARD,
	1: COMMUNITY_TYPE_EXTENDED,
	2: COMMUNITY_TYPE_BOTH,
	3: COMMUNITY_TYPE_NONE,
}

func (v CommunityType) Validate() error {
	if _, ok := CommunityTypeToIntMap[v]; !ok {
		return fmt.Errorf("invalid CommunityType: %s", v)
	}
	return nil
}

// typedef for typedef bgp-types:bgp-ext-community-type
type BgpExtCommunityType string

// typedef for typedef bgp-types:bgp-std-community-type
type BgpStdCommunityType string

// typedef for identity bgp-types:peer-type
type PeerType string

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

var PeerTypeToIntMap = map[PeerType]int{
	PEER_TYPE_INTERNAL: 0,
	PEER_TYPE_EXTERNAL: 1,
}

func (v PeerType) ToInt() int {
	i, ok := PeerTypeToIntMap[v]
	if !ok {
		return -1
	}
	return i
}

var IntToPeerTypeMap = map[int]PeerType{
	0: PEER_TYPE_INTERNAL,
	1: PEER_TYPE_EXTERNAL,
}

func (v PeerType) Validate() error {
	if _, ok := PeerTypeToIntMap[v]; !ok {
		return fmt.Errorf("invalid PeerType: %s", v)
	}
	return nil
}

// typedef for identity bgp-types:bgp-session-direction
type BgpSessionDirection string

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

var BgpSessionDirectionToIntMap = map[BgpSessionDirection]int{
	BGP_SESSION_DIRECTION_INBOUND:  0,
	BGP_SESSION_DIRECTION_OUTBOUND: 1,
}

func (v BgpSessionDirection) ToInt() int {
	i, ok := BgpSessionDirectionToIntMap[v]
	if !ok {
		return -1
	}
	return i
}

var IntToBgpSessionDirectionMap = map[int]BgpSessionDirection{
	0: BGP_SESSION_DIRECTION_INBOUND,
	1: BGP_SESSION_DIRECTION_OUTBOUND,
}

func (v BgpSessionDirection) Validate() error {
	if _, ok := BgpSessionDirectionToIntMap[v]; !ok {
		return fmt.Errorf("invalid BgpSessionDirection: %s", v)
	}
	return nil
}

// typedef for identity bgp-types:bgp-origin-attr-type
type BgpOriginAttrType string

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

var BgpOriginAttrTypeToIntMap = map[BgpOriginAttrType]int{
	BGP_ORIGIN_ATTR_TYPE_IGP:        0,
	BGP_ORIGIN_ATTR_TYPE_EGP:        1,
	BGP_ORIGIN_ATTR_TYPE_INCOMPLETE: 2,
}

func (v BgpOriginAttrType) ToInt() int {
	i, ok := BgpOriginAttrTypeToIntMap[v]
	if !ok {
		return -1
	}
	return i
}

var IntToBgpOriginAttrTypeMap = map[int]BgpOriginAttrType{
	0: BGP_ORIGIN_ATTR_TYPE_IGP,
	1: BGP_ORIGIN_ATTR_TYPE_EGP,
	2: BGP_ORIGIN_ATTR_TYPE_INCOMPLETE,
}

func (v BgpOriginAttrType) Validate() error {
	if _, ok := BgpOriginAttrTypeToIntMap[v]; !ok {
		return fmt.Errorf("invalid BgpOriginAttrType: %s", v)
	}
	return nil
}

// typedef for identity bgp-types:afi-safi-type
type AfiSafiType string

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_ENCAP                 AfiSafiType = "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"
)

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_ENCAP:                 13,
	AFI_SAFI_TYPE_IPV4_FLOWSPEC:         14,
	AFI_SAFI_TYPE_L3VPN_IPV4_FLOWSPEC:   15,
	AFI_SAFI_TYPE_IPV6_FLOWSPEC:         16,
	AFI_SAFI_TYPE_L3VPN_IPV6_FLOWSPEC:   17,
}

func (v AfiSafiType) ToInt() int {
	i, ok := AfiSafiTypeToIntMap[v]
	if !ok {
		return -1
	}
	return i
}

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_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,
}

func (v AfiSafiType) Validate() error {
	if _, ok := AfiSafiTypeToIntMap[v]; !ok {
		return fmt.Errorf("invalid AfiSafiType: %s", v)
	}
	return nil
}

// typedef for identity bgp-types:bgp-capability
type BgpCapability string

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"
)

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,
}

func (v BgpCapability) ToInt() int {
	i, ok := BgpCapabilityToIntMap[v]
	if !ok {
		return -1
	}
	return i
}

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,
}

func (v BgpCapability) Validate() error {
	if _, ok := BgpCapabilityToIntMap[v]; !ok {
		return fmt.Errorf("invalid BgpCapability: %s", v)
	}
	return nil
}

// typedef for identity bgp-types:bgp-well-known-std-community
type BgpWellKnownStdCommunity string

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"
)

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,
}

func (v BgpWellKnownStdCommunity) ToInt() int {
	i, ok := BgpWellKnownStdCommunityToIntMap[v]
	if !ok {
		return -1
	}
	return i
}

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,
}

func (v BgpWellKnownStdCommunity) Validate() error {
	if _, ok := BgpWellKnownStdCommunityToIntMap[v]; !ok {
		return fmt.Errorf("invalid BgpWellKnownStdCommunity: %s", v)
	}
	return nil
}

// typedef for identity ptypes:match-set-options-restricted-type
type MatchSetOptionsRestrictedType string

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

var MatchSetOptionsRestrictedTypeToIntMap = map[MatchSetOptionsRestrictedType]int{
	MATCH_SET_OPTIONS_RESTRICTED_TYPE_ANY:    0,
	MATCH_SET_OPTIONS_RESTRICTED_TYPE_INVERT: 1,
}

func (v MatchSetOptionsRestrictedType) ToInt() int {
	i, ok := MatchSetOptionsRestrictedTypeToIntMap[v]
	if !ok {
		return -1
	}
	return i
}

var IntToMatchSetOptionsRestrictedTypeMap = map[int]MatchSetOptionsRestrictedType{
	0: MATCH_SET_OPTIONS_RESTRICTED_TYPE_ANY,
	1: MATCH_SET_OPTIONS_RESTRICTED_TYPE_INVERT,
}

func (v MatchSetOptionsRestrictedType) Validate() error {
	if _, ok := MatchSetOptionsRestrictedTypeToIntMap[v]; !ok {
		return fmt.Errorf("invalid MatchSetOptionsRestrictedType: %s", v)
	}
	return nil
}

func (v MatchSetOptionsRestrictedType) Default() MatchSetOptionsRestrictedType {
	return MATCH_SET_OPTIONS_RESTRICTED_TYPE_ANY
}

func (v MatchSetOptionsRestrictedType) DefaultAsNeeded() MatchSetOptionsRestrictedType {
	if string(v) == "" {
		return v.Default()
	}
	return v
}

// typedef for identity ptypes:match-set-options-type
type MatchSetOptionsType string

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

var MatchSetOptionsTypeToIntMap = map[MatchSetOptionsType]int{
	MATCH_SET_OPTIONS_TYPE_ANY:    0,
	MATCH_SET_OPTIONS_TYPE_ALL:    1,
	MATCH_SET_OPTIONS_TYPE_INVERT: 2,
}

func (v MatchSetOptionsType) ToInt() int {
	i, ok := MatchSetOptionsTypeToIntMap[v]
	if !ok {
		return -1
	}
	return i
}

var IntToMatchSetOptionsTypeMap = map[int]MatchSetOptionsType{
	0: MATCH_SET_OPTIONS_TYPE_ANY,
	1: MATCH_SET_OPTIONS_TYPE_ALL,
	2: MATCH_SET_OPTIONS_TYPE_INVERT,
}

func (v MatchSetOptionsType) Validate() error {
	if _, ok := MatchSetOptionsTypeToIntMap[v]; !ok {
		return fmt.Errorf("invalid MatchSetOptionsType: %s", v)
	}
	return nil
}

func (v MatchSetOptionsType) Default() MatchSetOptionsType {
	return MATCH_SET_OPTIONS_TYPE_ANY
}

func (v MatchSetOptionsType) DefaultAsNeeded() MatchSetOptionsType {
	if string(v) == "" {
		return v.Default()
	}
	return v
}

// typedef for typedef ptypes:tag-type
type TagType string

// typedef for identity ptypes:install-protocol-type
type InstallProtocolType string

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"
)

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,
}

func (v InstallProtocolType) ToInt() int {
	i, ok := InstallProtocolTypeToIntMap[v]
	if !ok {
		return -1
	}
	return i
}

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,
}

func (v InstallProtocolType) Validate() error {
	if _, ok := InstallProtocolTypeToIntMap[v]; !ok {
		return fmt.Errorf("invalid InstallProtocolType: %s", v)
	}
	return nil
}

// typedef for identity ptypes:attribute-comparison
type AttributeComparison string

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"
)

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,
}

func (v AttributeComparison) ToInt() int {
	i, ok := AttributeComparisonToIntMap[v]
	if !ok {
		return -1
	}
	return i
}

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,
}

func (v AttributeComparison) Validate() error {
	if _, ok := AttributeComparisonToIntMap[v]; !ok {
		return fmt.Errorf("invalid AttributeComparison: %s", v)
	}
	return nil
}

// typedef for identity rpol:route-type
type RouteType string

const (
	ROUTE_TYPE_INTERNAL RouteType = "internal"
	ROUTE_TYPE_EXTERNAL RouteType = "external"
)

var RouteTypeToIntMap = map[RouteType]int{
	ROUTE_TYPE_INTERNAL: 0,
	ROUTE_TYPE_EXTERNAL: 1,
}

func (v RouteType) ToInt() int {
	i, ok := RouteTypeToIntMap[v]
	if !ok {
		return -1
	}
	return i
}

var IntToRouteTypeMap = map[int]RouteType{
	0: ROUTE_TYPE_INTERNAL,
	1: ROUTE_TYPE_EXTERNAL,
}

func (v RouteType) Validate() error {
	if _, ok := RouteTypeToIntMap[v]; !ok {
		return fmt.Errorf("invalid RouteType: %s", v)
	}
	return nil
}

// typedef for identity rpol:default-policy-type
type DefaultPolicyType string

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

var DefaultPolicyTypeToIntMap = map[DefaultPolicyType]int{
	DEFAULT_POLICY_TYPE_ACCEPT_ROUTE: 0,
	DEFAULT_POLICY_TYPE_REJECT_ROUTE: 1,
}

func (v DefaultPolicyType) ToInt() int {
	i, ok := DefaultPolicyTypeToIntMap[v]
	if !ok {
		return -1
	}
	return i
}

var IntToDefaultPolicyTypeMap = map[int]DefaultPolicyType{
	0: DEFAULT_POLICY_TYPE_ACCEPT_ROUTE,
	1: DEFAULT_POLICY_TYPE_REJECT_ROUTE,
}

func (v DefaultPolicyType) Validate() error {
	if _, ok := DefaultPolicyTypeToIntMap[v]; !ok {
		return fmt.Errorf("invalid DefaultPolicyType: %s", v)
	}
	return nil
}

// typedef for identity bgp:session-state
type SessionState string

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"
)

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,
}

func (v SessionState) ToInt() int {
	i, ok := SessionStateToIntMap[v]
	if !ok {
		return -1
	}
	return i
}

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,
}

func (v SessionState) Validate() error {
	if _, ok := SessionStateToIntMap[v]; !ok {
		return fmt.Errorf("invalid SessionState: %s", v)
	}
	return nil
}

// typedef for identity bgp:mode
type Mode string

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

var ModeToIntMap = map[Mode]int{
	MODE_HELPER_ONLY:   0,
	MODE_BILATERAL:     1,
	MODE_REMOTE_HELPER: 2,
}

func (v Mode) ToInt() int {
	i, ok := ModeToIntMap[v]
	if !ok {
		return -1
	}
	return i
}

var IntToModeMap = map[int]Mode{
	0: MODE_HELPER_ONLY,
	1: MODE_BILATERAL,
	2: MODE_REMOTE_HELPER,
}

func (v Mode) Validate() error {
	if _, ok := ModeToIntMap[v]; !ok {
		return fmt.Errorf("invalid Mode: %s", v)
	}
	return nil
}

// typedef for typedef bgp-pol:bgp-next-hop-type
type BgpNextHopType string

// typedef for typedef bgp-pol:bgp-as-path-prepend-repeat
type BgpAsPathPrependRepeat uint8

// typedef for typedef bgp-pol:bgp-set-med-type
type BgpSetMedType string

// typedef for identity bgp-pol:bgp-set-community-option-type
type BgpSetCommunityOptionType string

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"
)

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,
}

func (v BgpSetCommunityOptionType) ToInt() int {
	i, ok := BgpSetCommunityOptionTypeToIntMap[v]
	if !ok {
		return -1
	}
	return i
}

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,
}

func (v BgpSetCommunityOptionType) Validate() error {
	if _, ok := BgpSetCommunityOptionTypeToIntMap[v]; !ok {
		return fmt.Errorf("invalid BgpSetCommunityOptionType: %s", v)
	}
	return nil
}

// typedef for identity gobgp:bmp-route-monitoring-policy-type
type BmpRouteMonitoringPolicyType string

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"
)

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,
}

func (v BmpRouteMonitoringPolicyType) ToInt() int {
	i, ok := BmpRouteMonitoringPolicyTypeToIntMap[v]
	if !ok {
		return -1
	}
	return i
}

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,
}

func (v BmpRouteMonitoringPolicyType) Validate() error {
	if _, ok := BmpRouteMonitoringPolicyTypeToIntMap[v]; !ok {
		return fmt.Errorf("invalid BmpRouteMonitoringPolicyType: %s", v)
	}
	return nil
}

// typedef for identity gobgp:rpki-validation-result-type
type RpkiValidationResultType string

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"
)

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,
}

func (v RpkiValidationResultType) ToInt() int {
	i, ok := RpkiValidationResultTypeToIntMap[v]
	if !ok {
		return -1
	}
	return i
}

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,
}

func (v RpkiValidationResultType) Validate() error {
	if _, ok := RpkiValidationResultTypeToIntMap[v]; !ok {
		return fmt.Errorf("invalid RpkiValidationResultType: %s", v)
	}
	return nil
}

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

//struct for container gobgp:rpki-sent
type RpkiSent struct {
	// original -> gobgp:serial-query
	SerialQuery int64 `mapstructure:"serial-query"`
	// original -> gobgp:reset-query
	ResetQuery int64 `mapstructure:"reset-query"`
	// original -> gobgp:error
	Error int64 `mapstructure:"error"`
}

//struct for container gobgp:rpki-messages
type RpkiMessages struct {
	// original -> gobgp:rpki-sent
	RpkiSent RpkiSent `mapstructure:"rpki-sent"`
	// original -> gobgp:rpki-received
	RpkiReceived RpkiReceived `mapstructure:"rpki-received"`
}

//struct for container gobgp:state
type RpkiServerState struct {
	// original -> gobgp:uptime
	Uptime int64 `mapstructure:"uptime"`
	// original -> gobgp:downtime
	Downtime int64 `mapstructure:"downtime"`
	// original -> gobgp:last-pdu-recv-time
	LastPduRecvTime int64 `mapstructure:"last-pdu-recv-time"`
	// original -> gobgp:rpki-messages
	RpkiMessages RpkiMessages `mapstructure:"rpki-messages"`
}

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

//struct for container gobgp:rpki-server
type RpkiServer struct {
	// original -> gobgp:address
	//gobgp:address's original type is inet:ip-address
	Address string `mapstructure:"address"`
	// original -> gobgp:rpki-server-config
	Config RpkiServerConfig `mapstructure:"config"`
	// original -> gobgp:rpki-server-state
	State RpkiServerState `mapstructure:"state"`
}

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

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

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

//struct for container gobgp:state
type RouteServerState struct {
	// original -> gobgp:route-server-client
	//gobgp:route-server-client's original type is boolean
	RouteServerClient bool `mapstructure:"route-server-client"`
}

//struct for container gobgp:config
type RouteServerConfig struct {
	// original -> gobgp:route-server-client
	//gobgp:route-server-client's original type is boolean
	RouteServerClient bool `mapstructure:"route-server-client"`
}

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

//struct for container bgp-op:prefixes
type Prefixes struct {
	// original -> bgp-op:received
	Received uint32 `mapstructure:"received"`
	// original -> bgp-op:sent
	Sent uint32 `mapstructure:"sent"`
	// original -> bgp-op:installed
	Installed uint32 `mapstructure:"installed"`
}

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

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

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

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

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

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

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

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

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

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

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

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

//struct for container bgp:state
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"`
}

//struct for container bgp:config
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"`
}

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

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

//struct for container bgp:config
type ErrorHandlingConfig struct {
	// original -> bgp:treat-as-withdraw
	//bgp:treat-as-withdraw's original type is boolean
	TreatAsWithdraw bool `mapstructure:"treat-as-withdraw"`
}

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

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

//struct for container bgp:config
type TransportConfig struct {
	// original -> bgp:tcp-mss
	TcpMss uint16 `mapstructure:"tcp-mss"`
	// original -> bgp:mtu-discovery
	//bgp:mtu-discovery's original type is boolean
	MtuDiscovery bool `mapstructure:"mtu-discovery"`
	// original -> bgp:passive-mode
	//bgp:passive-mode's original type is boolean
	PassiveMode bool `mapstructure:"passive-mode"`
	// original -> bgp:local-address
	//bgp:local-address's original type is union
	LocalAddress string `mapstructure:"local-address"`
}

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

//struct for container bgp:state
type TimersState struct {
	// original -> bgp:connect-retry
	//bgp:connect-retry's original type is decimal64
	ConnectRetry float64 `mapstructure:"connect-retry"`
	// original -> bgp:hold-time
	//bgp:hold-time's original type is decimal64
	HoldTime float64 `mapstructure:"hold-time"`
	// original -> bgp:keepalive-interval
	//bgp:keepalive-interval's original type is decimal64
	KeepaliveInterval float64 `mapstructure:"keepalive-interval"`
	// original -> bgp:minimum-advertisement-interval
	//bgp:minimum-advertisement-interval's original type is decimal64
	MinimumAdvertisementInterval float64 `mapstructure:"minimum-advertisement-interval"`
	// original -> bgp-op:uptime
	//bgp-op:uptime's original type is yang:timeticks
	Uptime int64 `mapstructure:"uptime"`
	// original -> bgp-op:negotiated-hold-time
	//bgp-op:negotiated-hold-time's original type is decimal64
	NegotiatedHoldTime float64 `mapstructure:"negotiated-hold-time"`
	// 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"`
	// original -> gobgp:downtime
	//gobgp:downtime's original type is yang:timeticks
	Downtime int64 `mapstructure:"downtime"`
	// original -> gobgp:update-recv-time
	UpdateRecvTime int64 `mapstructure:"update-recv-time"`
}

//struct for container bgp:config
type TimersConfig struct {
	// original -> bgp:connect-retry
	//bgp:connect-retry's original type is decimal64
	ConnectRetry float64 `mapstructure:"connect-retry"`
	// original -> bgp:hold-time
	//bgp:hold-time's original type is decimal64
	HoldTime float64 `mapstructure:"hold-time"`
	// original -> bgp:keepalive-interval
	//bgp:keepalive-interval's original type is decimal64
	KeepaliveInterval float64 `mapstructure:"keepalive-interval"`
	// original -> bgp:minimum-advertisement-interval
	//bgp:minimum-advertisement-interval's original type is decimal64
	MinimumAdvertisementInterval float64 `mapstructure:"minimum-advertisement-interval"`
	// 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"`
}

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

//struct for container bgp:queues
type Queues struct {
	// original -> bgp-op:input
	Input uint32 `mapstructure:"input"`
	// original -> bgp-op:output
	Output uint32 `mapstructure:"output"`
}

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

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

//struct for container bgp:messages
type Messages struct {
	// original -> bgp:sent
	Sent Sent `mapstructure:"sent"`
	// original -> bgp:received
	Received Received `mapstructure:"received"`
}

//struct for container bgp:state
type NeighborState struct {
	// original -> bgp:peer-as
	//bgp:peer-as's original type is inet:as-number
	PeerAs uint32 `mapstructure:"peer-as"`
	// original -> bgp:local-as
	//bgp:local-as's original type is inet:as-number
	LocalAs uint32 `mapstructure:"local-as"`
	// original -> bgp:peer-type
	PeerType PeerType `mapstructure:"peer-type"`
	// original -> bgp:auth-password
	AuthPassword string `mapstructure:"auth-password"`
	// original -> bgp:remove-private-as
	RemovePrivateAs RemovePrivateAsOption `mapstructure:"remove-private-as"`
	// original -> bgp:route-flap-damping
	//bgp:route-flap-damping's original type is boolean
	RouteFlapDamping bool `mapstructure:"route-flap-damping"`
	// original -> bgp:send-community
	SendCommunity CommunityType `mapstructure:"send-community"`
	// original -> bgp:description
	Description string `mapstructure:"description"`
	// original -> bgp:peer-group
	PeerGroup string `mapstructure:"peer-group"`
	// original -> bgp:neighbor-address
	//bgp:neighbor-address's original type is inet:ip-address
	NeighborAddress string `mapstructure:"neighbor-address"`
	// original -> bgp-op:session-state
	SessionState SessionState `mapstructure:"session-state"`
	// original -> bgp-op:supported-capabilities
	SupportedCapabilitiesList []BgpCapability `mapstructure:"supported-capabilities-list"`
	// original -> bgp:messages
	Messages Messages `mapstructure:"messages"`
	// original -> bgp:queues
	Queues Queues `mapstructure:"queues"`
	// original -> gobgp:admin-down
	//gobgp:admin-down's original type is boolean
	AdminDown bool `mapstructure:"admin-down"`
	// original -> gobgp:established-count
	EstablishedCount uint32 `mapstructure:"established-count"`
	// original -> gobgp:flops
	Flops uint32 `mapstructure:"flops"`
}

//struct for container bgp:config
type NeighborConfig struct {
	// original -> bgp:peer-as
	//bgp:peer-as's original type is inet:as-number
	PeerAs uint32 `mapstructure:"peer-as"`
	// original -> bgp:local-as
	//bgp:local-as's original type is inet:as-number
	LocalAs uint32 `mapstructure:"local-as"`
	// original -> bgp:peer-type
	PeerType PeerType `mapstructure:"peer-type"`
	// original -> bgp:auth-password
	AuthPassword string `mapstructure:"auth-password"`
	// original -> bgp:remove-private-as
	RemovePrivateAs RemovePrivateAsOption `mapstructure:"remove-private-as"`
	// original -> bgp:route-flap-damping
	//bgp:route-flap-damping's original type is boolean
	RouteFlapDamping bool `mapstructure:"route-flap-damping"`
	// original -> bgp:send-community
	SendCommunity CommunityType `mapstructure:"send-community"`
	// original -> bgp:description
	Description string `mapstructure:"description"`
	// original -> bgp:peer-group
	PeerGroup string `mapstructure:"peer-group"`
	// original -> bgp:neighbor-address
	//bgp:neighbor-address's original type is inet:ip-address
	NeighborAddress string `mapstructure:"neighbor-address"`
}

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

//struct for container gobgp:listen-config
type ListenConfig struct {
	// original -> gobgp:port
	Port int32 `mapstructure:"port"`
	// original -> gobgp:local-address
	LocalAddressList []string `mapstructure:"local-address-list"`
}

//struct for container gobgp:mpls-label-range
type MplsLabelRange struct {
	// original -> gobgp:min-label
	MinLabel uint32 `mapstructure:"min-label"`
	// original -> gobgp:max-label
	MaxLabel uint32 `mapstructure:"max-label"`
}

//struct for container gobgp:zebra
type Zebra struct {
	// original -> gobgp:enabled
	//gobgp:enabled's original type is boolean
	Enabled bool `mapstructure:"enabled"`
	// original -> gobgp:url
	Url string `mapstructure:"url"`
	// original -> gobgp:redistribute-route-type
	RedistributeRouteTypeList []InstallProtocolType `mapstructure:"redistribute-route-type-list"`
}

//struct for container gobgp:mrt
type Mrt struct {
	// original -> gobgp:file-name
	FileName string `mapstructure:"file-name"`
}

//struct for container gobgp:state
type BmpServerState struct {
}

//struct for container gobgp:config
type BmpServerConfig struct {
	// original -> gobgp:address
	//gobgp:address's original type is inet:ip-address
	Address string `mapstructure:"address"`
	// original -> gobgp:port
	Port uint32 `mapstructure:"port"`
	// original -> gobgp:route-monitoring-policy
	RouteMonitoringPolicy BmpRouteMonitoringPolicyType `mapstructure:"route-monitoring-policy"`
}

//struct for container gobgp:bmp-server
type BmpServer struct {
	// original -> gobgp:address
	//gobgp:address's original type is inet:ip-address
	Address string `mapstructure:"address"`
	// original -> gobgp:bmp-server-config
	Config BmpServerConfig `mapstructure:"config"`
	// original -> gobgp:bmp-server-state
	State BmpServerState `mapstructure:"state"`
}

//struct for container gobgp:collector
type Collector struct {
	// original -> gobgp:enabled
	//gobgp:enabled's original type is boolean
	Enabled bool `mapstructure:"enabled"`
}

//struct for container bgp-mp:l2vpn-evpn
type L2vpnEvpn struct {
	// original -> bgp-mp:prefix-limit
	PrefixLimit PrefixLimit `mapstructure:"prefix-limit"`
}

//struct for container bgp-mp:l2vpn-vpls
type L2vpnVpls struct {
	// original -> bgp-mp:prefix-limit
	PrefixLimit PrefixLimit `mapstructure:"prefix-limit"`
}

//struct for container bgp-mp:l3vpn-ipv6-multicast
type L3vpnIpv6Multicast struct {
	// original -> bgp-mp:prefix-limit
	PrefixLimit PrefixLimit `mapstructure:"prefix-limit"`
}

//struct for container bgp-mp:l3vpn-ipv4-multicast
type L3vpnIpv4Multicast struct {
	// original -> bgp-mp:prefix-limit
	PrefixLimit PrefixLimit `mapstructure:"prefix-limit"`
}

//struct for container bgp-mp:l3vpn-ipv6-unicast
type L3vpnIpv6Unicast struct {
	// original -> bgp-mp:prefix-limit
	PrefixLimit PrefixLimit `mapstructure:"prefix-limit"`
}

//struct for container bgp-mp:l3vpn-ipv4-unicast
type L3vpnIpv4Unicast struct {
	// original -> bgp-mp:prefix-limit
	PrefixLimit PrefixLimit `mapstructure:"prefix-limit"`
}

//struct for container bgp-mp:ipv6-labelled-unicast
type Ipv6LabelledUnicast struct {
	// original -> bgp-mp:prefix-limit
	PrefixLimit PrefixLimit `mapstructure:"prefix-limit"`
}

//struct for container bgp-mp:ipv4-labelled-unicast
type Ipv4LabelledUnicast struct {
	// original -> bgp-mp:prefix-limit
	PrefixLimit PrefixLimit `mapstructure:"prefix-limit"`
}

//struct for container bgp-mp:state
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"`
}

//struct for container bgp-mp:config
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"`
}

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

//struct for container bgp-mp:state
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"`
}

//struct for container bgp-mp:config
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"`
}

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

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

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

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

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

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

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

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

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

//struct for container bgp-mp:state
type MpGracefulRestartState struct {
	// original -> bgp-mp:enabled
	//bgp-mp:enabled's original type is boolean
	Enabled bool `mapstructure:"enabled"`
	// original -> bgp-op:received
	//bgp-op:received's original type is boolean
	Received bool `mapstructure:"received"`
	// original -> bgp-op:advertised
	//bgp-op:advertised's original type is boolean
	Advertised bool `mapstructure:"advertised"`
}

//struct for container bgp-mp:config
type MpGracefulRestartConfig struct {
	// original -> bgp-mp:enabled
	//bgp-mp:enabled's original type is boolean
	Enabled bool `mapstructure:"enabled"`
}

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

//struct for container bgp-mp:afi-safi
type AfiSafi struct {
	// original -> bgp-mp:afi-safi-name
	AfiSafiName AfiSafiType `mapstructure:"afi-safi-name"`
	// original -> bgp-mp:mp-graceful-restart
	MpGracefulRestart MpGracefulRestart `mapstructure:"mp-graceful-restart"`
	// original -> bgp-mp:afi-safi-config
	Config AfiSafiConfig `mapstructure:"config"`
	// original -> bgp-mp:afi-safi-state
	State AfiSafiState `mapstructure:"state"`
	// original -> rpol:apply-policy
	ApplyPolicy ApplyPolicy `mapstructure:"apply-policy"`
	// original -> bgp-mp:ipv4-unicast
	Ipv4Unicast Ipv4Unicast `mapstructure:"ipv4-unicast"`
	// original -> bgp-mp:ipv6-unicast
	Ipv6Unicast Ipv6Unicast `mapstructure:"ipv6-unicast"`
	// original -> bgp-mp:ipv4-labelled-unicast
	Ipv4LabelledUnicast Ipv4LabelledUnicast `mapstructure:"ipv4-labelled-unicast"`
	// original -> bgp-mp:ipv6-labelled-unicast
	Ipv6LabelledUnicast Ipv6LabelledUnicast `mapstructure:"ipv6-labelled-unicast"`
	// original -> bgp-mp:l3vpn-ipv4-unicast
	L3vpnIpv4Unicast L3vpnIpv4Unicast `mapstructure:"l3vpn-ipv4-unicast"`
	// original -> bgp-mp:l3vpn-ipv6-unicast
	L3vpnIpv6Unicast L3vpnIpv6Unicast `mapstructure:"l3vpn-ipv6-unicast"`
	// original -> bgp-mp:l3vpn-ipv4-multicast
	L3vpnIpv4Multicast L3vpnIpv4Multicast `mapstructure:"l3vpn-ipv4-multicast"`
	// original -> bgp-mp:l3vpn-ipv6-multicast
	L3vpnIpv6Multicast L3vpnIpv6Multicast `mapstructure:"l3vpn-ipv6-multicast"`
	// original -> bgp-mp:l2vpn-vpls
	L2vpnVpls L2vpnVpls `mapstructure:"l2vpn-vpls"`
	// original -> bgp-mp:l2vpn-evpn
	L2vpnEvpn L2vpnEvpn `mapstructure:"l2vpn-evpn"`
	// original -> bgp-mp:route-selection-options
	RouteSelectionOptions RouteSelectionOptions `mapstructure:"route-selection-options"`
	// original -> bgp-mp:use-multiple-paths
	UseMultiplePaths UseMultiplePaths `mapstructure:"use-multiple-paths"`
}

//struct for container bgp:state
type GracefulRestartState struct {
	// original -> bgp:enabled
	//bgp:enabled's original type is boolean
	Enabled bool `mapstructure:"enabled"`
	// original -> bgp:restart-time
	RestartTime uint16 `mapstructure:"restart-time"`
	// original -> bgp:stale-routes-time
	//bgp:stale-routes-time's original type is decimal64
	StaleRoutesTime float64 `mapstructure:"stale-routes-time"`
	// original -> bgp:helper-only
	//bgp:helper-only's original type is boolean
	HelperOnly bool `mapstructure:"helper-only"`
	// original -> bgp-op:peer-restart-time
	PeerRestartTime uint16 `mapstructure:"peer-restart-time"`
	// original -> bgp-op:peer-restarting
	//bgp-op:peer-restarting's original type is boolean
	PeerRestarting bool `mapstructure:"peer-restarting"`
	// original -> bgp-op:local-restarting
	//bgp-op:local-restarting's original type is boolean
	LocalRestarting bool `mapstructure:"local-restarting"`
	// original -> bgp-op:mode
	Mode Mode `mapstructure:"mode"`
}

//struct for container bgp:config
type GracefulRestartConfig struct {
	// original -> bgp:enabled
	//bgp:enabled's original type is boolean
	Enabled bool `mapstructure:"enabled"`
	// original -> bgp:restart-time
	RestartTime uint16 `mapstructure:"restart-time"`
	// original -> bgp:stale-routes-time
	//bgp:stale-routes-time's original type is decimal64
	StaleRoutesTime float64 `mapstructure:"stale-routes-time"`
	// original -> bgp:helper-only
	//bgp:helper-only's original type is boolean
	HelperOnly bool `mapstructure:"helper-only"`
}

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

//struct for container bgp-mp:state
type IbgpState struct {
	// original -> bgp-mp:maximum-paths
	MaximumPaths uint32 `mapstructure:"maximum-paths"`
}

//struct for container bgp-mp:config
type IbgpConfig struct {
	// original -> bgp-mp:maximum-paths
	MaximumPaths uint32 `mapstructure:"maximum-paths"`
}

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

//struct for container bgp-mp:state
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"`
	// original -> bgp-mp:maximum-paths
	MaximumPaths uint32 `mapstructure:"maximum-paths"`
}

//struct for container bgp-mp:config
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"`
	// original -> bgp-mp:maximum-paths
	MaximumPaths uint32 `mapstructure:"maximum-paths"`
}

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

//struct for container bgp-mp:state
type UseMultiplePathsState struct {
	// original -> bgp-mp:enabled
	//bgp-mp:enabled's original type is boolean
	Enabled bool `mapstructure:"enabled"`
}

//struct for container bgp-mp:config
type UseMultiplePathsConfig struct {
	// original -> bgp-mp:enabled
	//bgp-mp:enabled's original type is boolean
	Enabled bool `mapstructure:"enabled"`
}

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

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

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

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

//struct for container bgp:state
type DefaultRouteDistanceState struct {
	// original -> bgp:external-route-distance
	ExternalRouteDistance uint8 `mapstructure:"external-route-distance"`
	// original -> bgp:internal-route-distance
	InternalRouteDistance uint8 `mapstructure:"internal-route-distance"`
}

//struct for container bgp:config
type DefaultRouteDistanceConfig struct {
	// original -> bgp:external-route-distance
	ExternalRouteDistance uint8 `mapstructure:"external-route-distance"`
	// original -> bgp:internal-route-distance
	InternalRouteDistance uint8 `mapstructure:"internal-route-distance"`
}

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

//struct for container bgp-mp:state
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"`
	// 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"`
	// 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"`
	// original -> bgp-mp:advertise-inactive-routes
	//bgp-mp:advertise-inactive-routes's original type is boolean
	AdvertiseInactiveRoutes bool `mapstructure:"advertise-inactive-routes"`
	// original -> bgp-mp:enable-aigp
	//bgp-mp:enable-aigp's original type is boolean
	EnableAigp bool `mapstructure:"enable-aigp"`
	// 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"`
}

//struct for container bgp-mp:config
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"`
	// 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"`
	// 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"`
	// original -> bgp-mp:advertise-inactive-routes
	//bgp-mp:advertise-inactive-routes's original type is boolean
	AdvertiseInactiveRoutes bool `mapstructure:"advertise-inactive-routes"`
	// original -> bgp-mp:enable-aigp
	//bgp-mp:enable-aigp's original type is boolean
	EnableAigp bool `mapstructure:"enable-aigp"`
	// 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"`
}

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

//struct for container bgp:state
type GlobalState struct {
	// original -> bgp:as
	//bgp:as's original type is inet:as-number
	As uint32 `mapstructure:"as"`
	// original -> bgp:router-id
	//bgp:router-id's original type is inet:ipv4-address
	RouterId string `mapstructure:"router-id"`
	// original -> bgp-op:total-paths
	TotalPaths uint32 `mapstructure:"total-paths"`
	// original -> bgp-op:total-prefixes
	TotalPrefixes uint32 `mapstructure:"total-prefixes"`
}

//struct for container bgp:config
type GlobalConfig struct {
	// original -> bgp:as
	//bgp:as's original type is inet:as-number
	As uint32 `mapstructure:"as"`
	// original -> bgp:router-id
	//bgp:router-id's original type is inet:ipv4-address
	RouterId string `mapstructure:"router-id"`
}

//struct for container bgp:global
type Global struct {
	// original -> bgp:global-config
	Config GlobalConfig `mapstructure:"config"`
	// original -> bgp:global-state
	State GlobalState `mapstructure:"state"`
	// original -> bgp-mp:route-selection-options
	RouteSelectionOptions RouteSelectionOptions `mapstructure:"route-selection-options"`
	// original -> bgp:default-route-distance
	DefaultRouteDistance DefaultRouteDistance `mapstructure:"default-route-distance"`
	// original -> bgp:confederation
	Confederation Confederation `mapstructure:"confederation"`
	// original -> bgp-mp:use-multiple-paths
	UseMultiplePaths UseMultiplePaths `mapstructure:"use-multiple-paths"`
	// original -> bgp:graceful-restart
	GracefulRestart GracefulRestart `mapstructure:"graceful-restart"`
	// original -> bgp:afi-safis
	AfiSafis []AfiSafi `mapstructure:"afi-safis"`
	// original -> rpol:apply-policy
	ApplyPolicy ApplyPolicy `mapstructure:"apply-policy"`
	// original -> gobgp:collector
	Collector Collector `mapstructure:"collector"`
	// original -> gobgp:bmp-servers
	BmpServers []BmpServer `mapstructure:"bmp-servers"`
	// original -> gobgp:mrt
	Mrt Mrt `mapstructure:"mrt"`
	// original -> gobgp:zebra
	Zebra Zebra `mapstructure:"zebra"`
	// original -> gobgp:mpls-label-range
	MplsLabelRange MplsLabelRange `mapstructure:"mpls-label-range"`
	// original -> gobgp:listen-config
	ListenConfig ListenConfig `mapstructure:"listen-config"`
}

//struct for container bgp:bgp
type Bgp struct {
	// original -> bgp:global
	Global Global `mapstructure:"global"`
	// original -> bgp:neighbors
	Neighbors []Neighbor `mapstructure:"neighbors"`
	// original -> bgp:peer-groups
	PeerGroups []PeerGroup `mapstructure:"peer-groups"`
	// original -> gobgp:rpki-servers
	RpkiServers []RpkiServer `mapstructure:"rpki-servers"`
}

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

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

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

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

//struct for container bgp-pol:set-as-path-prepend
type SetAsPathPrepend struct {
	// original -> bgp-pol:repeat-n
	RepeatN uint8 `mapstructure:"repeat-n"`
	// original -> gobgp:as
	//gobgp:as's original type is union
	As string `mapstructure:"as"`
}

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

//struct for container rpol:igp-actions
type IgpActions struct {
	// original -> rpol:set-tag
	SetTag TagType `mapstructure:"set-tag"`
}

//struct for container rpol:route-disposition
type RouteDisposition struct {
	// original -> rpol:accept-route
	//rpol:accept-route's original type is empty
	AcceptRoute bool `mapstructure:"accept-route"`
	// original -> rpol:reject-route
	//rpol:reject-route's original type is empty
	RejectRoute bool `mapstructure:"reject-route"`
}

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

//struct for container bgp-pol:as-path-length
type AsPathLength struct {
	// original -> ptypes:operator
	Operator AttributeComparison `mapstructure:"operator"`
	// original -> ptypes:value
	Value uint32 `mapstructure:"value"`
}

//struct for container bgp-pol:community-count
type CommunityCount struct {
	// original -> ptypes:operator
	Operator AttributeComparison `mapstructure:"operator"`
	// original -> ptypes:value
	Value uint32 `mapstructure:"value"`
}

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

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

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

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

//struct for container rpol:igp-conditions
type IgpConditions struct {
}

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

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

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

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

//struct for container rpol:statement
type Statement struct {
	// original -> rpol:name
	Name string `mapstructure:"name"`
	// original -> rpol:conditions
	Conditions Conditions `mapstructure:"conditions"`
	// original -> rpol:actions
	Actions Actions `mapstructure:"actions"`
}

//struct for container rpol:policy-definition
type PolicyDefinition struct {
	// original -> rpol:name
	Name string `mapstructure:"name"`
	// original -> rpol:statements
	Statements []Statement `mapstructure:"statements"`
}

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

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

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

//struct for container bgp-pol:bgp-defined-sets
type BgpDefinedSets struct {
	// original -> bgp-pol:community-sets
	CommunitySets []CommunitySet `mapstructure:"community-sets"`
	// original -> bgp-pol:ext-community-sets
	ExtCommunitySets []ExtCommunitySet `mapstructure:"ext-community-sets"`
	// original -> bgp-pol:as-path-sets
	AsPathSets []AsPathSet `mapstructure:"as-path-sets"`
}

//struct for container rpol:tag
type Tag struct {
	// original -> rpol:value
	Value TagType `mapstructure:"value"`
}

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

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

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

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

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

//struct for container rpol:routing-policy
type RoutingPolicy struct {
	// original -> rpol:defined-sets
	DefinedSets DefinedSets `mapstructure:"defined-sets"`
	// original -> rpol:policy-definitions
	PolicyDefinitions []PolicyDefinition `mapstructure:"policy-definitions"`
}