config: generate Equal() method

Signed-off-by: ISHIDA Wataru <ishida.wataru@lab.ntt.co.jp>

1 files changed, 2691 insertions, 45 deletions

diff --git a/config/bgp_configs.go b/config/bgp_configs.go
index d5eb930d..63389547 100644
--- a/config/bgp_configs.go
+++ b/config/bgp_configs.go
@@ -633,51 +633,6 @@ func (v DefaultPolicyType) Validate() error {
 	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 bgp:session-state
 type SessionState string
 
@@ -759,6 +714,51 @@ func (v Mode) Validate() error {
 	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
 
@@ -877,10 +877,33 @@ type Mrt struct {
 	Interval uint64 `mapstructure:"interval"`
 }
 
+func (lhs *Mrt) Equal(rhs *Mrt) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.DumpType != rhs.DumpType {
+		return false
+	}
+	if lhs.FileName != rhs.FileName {
+		return false
+	}
+	if lhs.Interval != rhs.Interval {
+		return false
+	}
+	return true
+}
+
 //struct for container gobgp:state
 type BmpServerState struct {
 }
 
+func (lhs *BmpServerState) Equal(rhs *BmpServerState) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	return true
+}
+
 //struct for container gobgp:config
 type BmpServerConfig struct {
 	// original -> gobgp:address
@@ -892,6 +915,22 @@ type BmpServerConfig struct {
 	RouteMonitoringPolicy BmpRouteMonitoringPolicyType `mapstructure:"route-monitoring-policy"`
 }
 
+func (lhs *BmpServerConfig) Equal(rhs *BmpServerConfig) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.Address != rhs.Address {
+		return false
+	}
+	if lhs.Port != rhs.Port {
+		return false
+	}
+	if lhs.RouteMonitoringPolicy != rhs.RouteMonitoringPolicy {
+		return false
+	}
+	return true
+}
+
 //struct for container gobgp:bmp-server
 type BmpServer struct {
 	// original -> gobgp:address
@@ -903,6 +942,22 @@ type BmpServer struct {
 	State BmpServerState `mapstructure:"state"`
 }
 
+func (lhs *BmpServer) Equal(rhs *BmpServer) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.Address != rhs.Address {
+		return false
+	}
+	if !lhs.Config.Equal(&(rhs.Config)) {
+		return false
+	}
+	if !lhs.State.Equal(&(rhs.State)) {
+		return false
+	}
+	return true
+}
+
 //struct for container gobgp:rpki-received
 type RpkiReceived struct {
 	// original -> gobgp:serial-notify
@@ -921,6 +976,34 @@ type RpkiReceived struct {
 	Error int64 `mapstructure:"error"`
 }
 
+func (lhs *RpkiReceived) Equal(rhs *RpkiReceived) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.SerialNotify != rhs.SerialNotify {
+		return false
+	}
+	if lhs.CacheReset != rhs.CacheReset {
+		return false
+	}
+	if lhs.CacheResponse != rhs.CacheResponse {
+		return false
+	}
+	if lhs.Ipv4Prefix != rhs.Ipv4Prefix {
+		return false
+	}
+	if lhs.Ipv6Prefix != rhs.Ipv6Prefix {
+		return false
+	}
+	if lhs.EndOfData != rhs.EndOfData {
+		return false
+	}
+	if lhs.Error != rhs.Error {
+		return false
+	}
+	return true
+}
+
 //struct for container gobgp:rpki-sent
 type RpkiSent struct {
 	// original -> gobgp:serial-query
@@ -931,6 +1014,22 @@ type RpkiSent struct {
 	Error int64 `mapstructure:"error"`
 }
 
+func (lhs *RpkiSent) Equal(rhs *RpkiSent) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.SerialQuery != rhs.SerialQuery {
+		return false
+	}
+	if lhs.ResetQuery != rhs.ResetQuery {
+		return false
+	}
+	if lhs.Error != rhs.Error {
+		return false
+	}
+	return true
+}
+
 //struct for container gobgp:rpki-messages
 type RpkiMessages struct {
 	// original -> gobgp:rpki-sent
@@ -939,6 +1038,19 @@ type RpkiMessages struct {
 	RpkiReceived RpkiReceived `mapstructure:"rpki-received"`
 }
 
+func (lhs *RpkiMessages) Equal(rhs *RpkiMessages) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if !lhs.RpkiSent.Equal(&(rhs.RpkiSent)) {
+		return false
+	}
+	if !lhs.RpkiReceived.Equal(&(rhs.RpkiReceived)) {
+		return false
+	}
+	return true
+}
+
 //struct for container gobgp:state
 type RpkiServerState struct {
 	// original -> gobgp:uptime
@@ -951,6 +1063,25 @@ type RpkiServerState struct {
 	RpkiMessages RpkiMessages `mapstructure:"rpki-messages"`
 }
 
+func (lhs *RpkiServerState) Equal(rhs *RpkiServerState) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.Uptime != rhs.Uptime {
+		return false
+	}
+	if lhs.Downtime != rhs.Downtime {
+		return false
+	}
+	if lhs.LastPduRecvTime != rhs.LastPduRecvTime {
+		return false
+	}
+	if !lhs.RpkiMessages.Equal(&(rhs.RpkiMessages)) {
+		return false
+	}
+	return true
+}
+
 //struct for container gobgp:config
 type RpkiServerConfig struct {
 	// original -> gobgp:address
@@ -968,6 +1099,31 @@ type RpkiServerConfig struct {
 	Preference uint8 `mapstructure:"preference"`
 }
 
+func (lhs *RpkiServerConfig) Equal(rhs *RpkiServerConfig) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.Address != rhs.Address {
+		return false
+	}
+	if lhs.Port != rhs.Port {
+		return false
+	}
+	if lhs.RefreshTime != rhs.RefreshTime {
+		return false
+	}
+	if lhs.HoldTime != rhs.HoldTime {
+		return false
+	}
+	if lhs.RecordLifetime != rhs.RecordLifetime {
+		return false
+	}
+	if lhs.Preference != rhs.Preference {
+		return false
+	}
+	return true
+}
+
 //struct for container gobgp:rpki-server
 type RpkiServer struct {
 	// original -> gobgp:address
@@ -979,6 +1135,22 @@ type RpkiServer struct {
 	State RpkiServerState `mapstructure:"state"`
 }
 
+func (lhs *RpkiServer) Equal(rhs *RpkiServer) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.Address != rhs.Address {
+		return false
+	}
+	if !lhs.Config.Equal(&(rhs.Config)) {
+		return false
+	}
+	if !lhs.State.Equal(&(rhs.State)) {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp:state
 type PeerGroupState struct {
 	// original -> bgp:peer-as
@@ -1008,6 +1180,46 @@ type PeerGroupState struct {
 	TotalPrefixes uint32 `mapstructure:"total-prefixes"`
 }
 
+func (lhs *PeerGroupState) Equal(rhs *PeerGroupState) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.PeerAs != rhs.PeerAs {
+		return false
+	}
+	if lhs.LocalAs != rhs.LocalAs {
+		return false
+	}
+	if lhs.PeerType != rhs.PeerType {
+		return false
+	}
+	if lhs.AuthPassword != rhs.AuthPassword {
+		return false
+	}
+	if lhs.RemovePrivateAs != rhs.RemovePrivateAs {
+		return false
+	}
+	if lhs.RouteFlapDamping != rhs.RouteFlapDamping {
+		return false
+	}
+	if lhs.SendCommunity != rhs.SendCommunity {
+		return false
+	}
+	if lhs.Description != rhs.Description {
+		return false
+	}
+	if lhs.PeerGroupName != rhs.PeerGroupName {
+		return false
+	}
+	if lhs.TotalPaths != rhs.TotalPaths {
+		return false
+	}
+	if lhs.TotalPrefixes != rhs.TotalPrefixes {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp:config
 type PeerGroupConfig struct {
 	// original -> bgp:peer-as
@@ -1033,6 +1245,40 @@ type PeerGroupConfig struct {
 	PeerGroupName string `mapstructure:"peer-group-name"`
 }
 
+func (lhs *PeerGroupConfig) Equal(rhs *PeerGroupConfig) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.PeerAs != rhs.PeerAs {
+		return false
+	}
+	if lhs.LocalAs != rhs.LocalAs {
+		return false
+	}
+	if lhs.PeerType != rhs.PeerType {
+		return false
+	}
+	if lhs.AuthPassword != rhs.AuthPassword {
+		return false
+	}
+	if lhs.RemovePrivateAs != rhs.RemovePrivateAs {
+		return false
+	}
+	if lhs.RouteFlapDamping != rhs.RouteFlapDamping {
+		return false
+	}
+	if lhs.SendCommunity != rhs.SendCommunity {
+		return false
+	}
+	if lhs.Description != rhs.Description {
+		return false
+	}
+	if lhs.PeerGroupName != rhs.PeerGroupName {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp:peer-group
 type PeerGroup struct {
 	// original -> bgp:peer-group-name
@@ -1069,6 +1315,74 @@ type PeerGroup struct {
 	RouteServer RouteServer `mapstructure:"route-server"`
 }
 
+func (lhs *PeerGroup) Equal(rhs *PeerGroup) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.PeerGroupName != rhs.PeerGroupName {
+		return false
+	}
+	if !lhs.Config.Equal(&(rhs.Config)) {
+		return false
+	}
+	if !lhs.State.Equal(&(rhs.State)) {
+		return false
+	}
+	if !lhs.Timers.Equal(&(rhs.Timers)) {
+		return false
+	}
+	if !lhs.Transport.Equal(&(rhs.Transport)) {
+		return false
+	}
+	if !lhs.ErrorHandling.Equal(&(rhs.ErrorHandling)) {
+		return false
+	}
+	if !lhs.LoggingOptions.Equal(&(rhs.LoggingOptions)) {
+		return false
+	}
+	if !lhs.EbgpMultihop.Equal(&(rhs.EbgpMultihop)) {
+		return false
+	}
+	if !lhs.RouteReflector.Equal(&(rhs.RouteReflector)) {
+		return false
+	}
+	if !lhs.AsPathOptions.Equal(&(rhs.AsPathOptions)) {
+		return false
+	}
+	if !lhs.AddPaths.Equal(&(rhs.AddPaths)) {
+		return false
+	}
+	if len(lhs.AfiSafis) != len(rhs.AfiSafis) {
+		return false
+	}
+	{
+		lmap := make(map[string]*AfiSafi)
+		for _, l := range lhs.AfiSafis {
+			lmap[string(l.AfiSafiName)] = &l
+		}
+		for _, r := range rhs.AfiSafis {
+			if l, y := lmap[string(r.AfiSafiName)]; !y {
+				return false
+			} else if !r.Equal(l) {
+				return false
+			}
+		}
+	}
+	if !lhs.GracefulRestart.Equal(&(rhs.GracefulRestart)) {
+		return false
+	}
+	if !lhs.ApplyPolicy.Equal(&(rhs.ApplyPolicy)) {
+		return false
+	}
+	if !lhs.UseMultiplePaths.Equal(&(rhs.UseMultiplePaths)) {
+		return false
+	}
+	if !lhs.RouteServer.Equal(&(rhs.RouteServer)) {
+		return false
+	}
+	return true
+}
+
 //struct for container gobgp:state
 type RouteServerState struct {
 	// original -> gobgp:route-server-client
@@ -1076,6 +1390,16 @@ type RouteServerState struct {
 	RouteServerClient bool `mapstructure:"route-server-client"`
 }
 
+func (lhs *RouteServerState) Equal(rhs *RouteServerState) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.RouteServerClient != rhs.RouteServerClient {
+		return false
+	}
+	return true
+}
+
 //struct for container gobgp:config
 type RouteServerConfig struct {
 	// original -> gobgp:route-server-client
@@ -1083,6 +1407,16 @@ type RouteServerConfig struct {
 	RouteServerClient bool `mapstructure:"route-server-client"`
 }
 
+func (lhs *RouteServerConfig) Equal(rhs *RouteServerConfig) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.RouteServerClient != rhs.RouteServerClient {
+		return false
+	}
+	return true
+}
+
 //struct for container gobgp:route-server
 type RouteServer struct {
 	// original -> gobgp:route-server-config
@@ -1091,6 +1425,19 @@ type RouteServer struct {
 	State RouteServerState `mapstructure:"state"`
 }
 
+func (lhs *RouteServer) Equal(rhs *RouteServer) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if !lhs.Config.Equal(&(rhs.Config)) {
+		return false
+	}
+	if !lhs.State.Equal(&(rhs.State)) {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp-op:prefixes
 type Prefixes struct {
 	// original -> bgp-op:received
@@ -1101,6 +1448,22 @@ type Prefixes struct {
 	Installed uint32 `mapstructure:"installed"`
 }
 
+func (lhs *Prefixes) Equal(rhs *Prefixes) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.Received != rhs.Received {
+		return false
+	}
+	if lhs.Sent != rhs.Sent {
+		return false
+	}
+	if lhs.Installed != rhs.Installed {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp:state
 type AddPathsState struct {
 	// original -> bgp:receive
@@ -1110,6 +1473,19 @@ type AddPathsState struct {
 	SendMax uint8 `mapstructure:"send-max"`
 }
 
+func (lhs *AddPathsState) Equal(rhs *AddPathsState) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.Receive != rhs.Receive {
+		return false
+	}
+	if lhs.SendMax != rhs.SendMax {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp:config
 type AddPathsConfig struct {
 	// original -> bgp:receive
@@ -1119,6 +1495,19 @@ type AddPathsConfig struct {
 	SendMax uint8 `mapstructure:"send-max"`
 }
 
+func (lhs *AddPathsConfig) Equal(rhs *AddPathsConfig) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.Receive != rhs.Receive {
+		return false
+	}
+	if lhs.SendMax != rhs.SendMax {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp:add-paths
 type AddPaths struct {
 	// original -> bgp:add-paths-config
@@ -1127,6 +1516,19 @@ type AddPaths struct {
 	State AddPathsState `mapstructure:"state"`
 }
 
+func (lhs *AddPaths) Equal(rhs *AddPaths) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if !lhs.Config.Equal(&(rhs.Config)) {
+		return false
+	}
+	if !lhs.State.Equal(&(rhs.State)) {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp:state
 type AsPathOptionsState struct {
 	// original -> bgp:allow-own-as
@@ -1136,6 +1538,19 @@ type AsPathOptionsState struct {
 	ReplacePeerAs bool `mapstructure:"replace-peer-as"`
 }
 
+func (lhs *AsPathOptionsState) Equal(rhs *AsPathOptionsState) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.AllowOwnAs != rhs.AllowOwnAs {
+		return false
+	}
+	if lhs.ReplacePeerAs != rhs.ReplacePeerAs {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp:config
 type AsPathOptionsConfig struct {
 	// original -> bgp:allow-own-as
@@ -1145,6 +1560,19 @@ type AsPathOptionsConfig struct {
 	ReplacePeerAs bool `mapstructure:"replace-peer-as"`
 }
 
+func (lhs *AsPathOptionsConfig) Equal(rhs *AsPathOptionsConfig) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.AllowOwnAs != rhs.AllowOwnAs {
+		return false
+	}
+	if lhs.ReplacePeerAs != rhs.ReplacePeerAs {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp:as-path-options
 type AsPathOptions struct {
 	// original -> bgp:as-path-options-config
@@ -1153,6 +1581,19 @@ type AsPathOptions struct {
 	State AsPathOptionsState `mapstructure:"state"`
 }
 
+func (lhs *AsPathOptions) Equal(rhs *AsPathOptions) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if !lhs.Config.Equal(&(rhs.Config)) {
+		return false
+	}
+	if !lhs.State.Equal(&(rhs.State)) {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp:state
 type RouteReflectorState struct {
 	// original -> bgp:route-reflector-cluster-id
@@ -1162,6 +1603,19 @@ type RouteReflectorState struct {
 	RouteReflectorClient bool `mapstructure:"route-reflector-client"`
 }
 
+func (lhs *RouteReflectorState) Equal(rhs *RouteReflectorState) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.RouteReflectorClusterId != rhs.RouteReflectorClusterId {
+		return false
+	}
+	if lhs.RouteReflectorClient != rhs.RouteReflectorClient {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp:config
 type RouteReflectorConfig struct {
 	// original -> bgp:route-reflector-cluster-id
@@ -1171,6 +1625,19 @@ type RouteReflectorConfig struct {
 	RouteReflectorClient bool `mapstructure:"route-reflector-client"`
 }
 
+func (lhs *RouteReflectorConfig) Equal(rhs *RouteReflectorConfig) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.RouteReflectorClusterId != rhs.RouteReflectorClusterId {
+		return false
+	}
+	if lhs.RouteReflectorClient != rhs.RouteReflectorClient {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp:route-reflector
 type RouteReflector struct {
 	// original -> bgp:route-reflector-config
@@ -1179,6 +1646,19 @@ type RouteReflector struct {
 	State RouteReflectorState `mapstructure:"state"`
 }
 
+func (lhs *RouteReflector) Equal(rhs *RouteReflector) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if !lhs.Config.Equal(&(rhs.Config)) {
+		return false
+	}
+	if !lhs.State.Equal(&(rhs.State)) {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp:state
 type EbgpMultihopState struct {
 	// original -> bgp:enabled
@@ -1188,6 +1668,19 @@ type EbgpMultihopState struct {
 	MultihopTtl uint8 `mapstructure:"multihop-ttl"`
 }
 
+func (lhs *EbgpMultihopState) Equal(rhs *EbgpMultihopState) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.Enabled != rhs.Enabled {
+		return false
+	}
+	if lhs.MultihopTtl != rhs.MultihopTtl {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp:config
 type EbgpMultihopConfig struct {
 	// original -> bgp:enabled
@@ -1197,6 +1690,19 @@ type EbgpMultihopConfig struct {
 	MultihopTtl uint8 `mapstructure:"multihop-ttl"`
 }
 
+func (lhs *EbgpMultihopConfig) Equal(rhs *EbgpMultihopConfig) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.Enabled != rhs.Enabled {
+		return false
+	}
+	if lhs.MultihopTtl != rhs.MultihopTtl {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp:ebgp-multihop
 type EbgpMultihop struct {
 	// original -> bgp:ebgp-multihop-config
@@ -1205,6 +1711,19 @@ type EbgpMultihop struct {
 	State EbgpMultihopState `mapstructure:"state"`
 }
 
+func (lhs *EbgpMultihop) Equal(rhs *EbgpMultihop) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if !lhs.Config.Equal(&(rhs.Config)) {
+		return false
+	}
+	if !lhs.State.Equal(&(rhs.State)) {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp:state
 type LoggingOptionsState struct {
 	// original -> bgp:log-neighbor-state-changes
@@ -1212,6 +1731,16 @@ type LoggingOptionsState struct {
 	LogNeighborStateChanges bool `mapstructure:"log-neighbor-state-changes"`
 }
 
+func (lhs *LoggingOptionsState) Equal(rhs *LoggingOptionsState) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.LogNeighborStateChanges != rhs.LogNeighborStateChanges {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp:config
 type LoggingOptionsConfig struct {
 	// original -> bgp:log-neighbor-state-changes
@@ -1219,6 +1748,16 @@ type LoggingOptionsConfig struct {
 	LogNeighborStateChanges bool `mapstructure:"log-neighbor-state-changes"`
 }
 
+func (lhs *LoggingOptionsConfig) Equal(rhs *LoggingOptionsConfig) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.LogNeighborStateChanges != rhs.LogNeighborStateChanges {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp:logging-options
 type LoggingOptions struct {
 	// original -> bgp:logging-options-config
@@ -1227,6 +1766,19 @@ type LoggingOptions struct {
 	State LoggingOptionsState `mapstructure:"state"`
 }
 
+func (lhs *LoggingOptions) Equal(rhs *LoggingOptions) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if !lhs.Config.Equal(&(rhs.Config)) {
+		return false
+	}
+	if !lhs.State.Equal(&(rhs.State)) {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp:state
 type ErrorHandlingState struct {
 	// original -> bgp:treat-as-withdraw
@@ -1236,6 +1788,19 @@ type ErrorHandlingState struct {
 	ErroneousUpdateMessages uint32 `mapstructure:"erroneous-update-messages"`
 }
 
+func (lhs *ErrorHandlingState) Equal(rhs *ErrorHandlingState) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.TreatAsWithdraw != rhs.TreatAsWithdraw {
+		return false
+	}
+	if lhs.ErroneousUpdateMessages != rhs.ErroneousUpdateMessages {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp:config
 type ErrorHandlingConfig struct {
 	// original -> bgp:treat-as-withdraw
@@ -1243,6 +1808,16 @@ type ErrorHandlingConfig struct {
 	TreatAsWithdraw bool `mapstructure:"treat-as-withdraw"`
 }
 
+func (lhs *ErrorHandlingConfig) Equal(rhs *ErrorHandlingConfig) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.TreatAsWithdraw != rhs.TreatAsWithdraw {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp:error-handling
 type ErrorHandling struct {
 	// original -> bgp:error-handling-config
@@ -1251,6 +1826,19 @@ type ErrorHandling struct {
 	State ErrorHandlingState `mapstructure:"state"`
 }
 
+func (lhs *ErrorHandling) Equal(rhs *ErrorHandling) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if !lhs.Config.Equal(&(rhs.Config)) {
+		return false
+	}
+	if !lhs.State.Equal(&(rhs.State)) {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp:state
 type TransportState struct {
 	// original -> bgp:tcp-mss
@@ -1275,6 +1863,34 @@ type TransportState struct {
 	RemotePort uint16 `mapstructure:"remote-port"`
 }
 
+func (lhs *TransportState) Equal(rhs *TransportState) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.TcpMss != rhs.TcpMss {
+		return false
+	}
+	if lhs.MtuDiscovery != rhs.MtuDiscovery {
+		return false
+	}
+	if lhs.PassiveMode != rhs.PassiveMode {
+		return false
+	}
+	if lhs.LocalAddress != rhs.LocalAddress {
+		return false
+	}
+	if lhs.LocalPort != rhs.LocalPort {
+		return false
+	}
+	if lhs.RemoteAddress != rhs.RemoteAddress {
+		return false
+	}
+	if lhs.RemotePort != rhs.RemotePort {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp:config
 type TransportConfig struct {
 	// original -> bgp:tcp-mss
@@ -1290,6 +1906,25 @@ type TransportConfig struct {
 	LocalAddress string `mapstructure:"local-address"`
 }
 
+func (lhs *TransportConfig) Equal(rhs *TransportConfig) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.TcpMss != rhs.TcpMss {
+		return false
+	}
+	if lhs.MtuDiscovery != rhs.MtuDiscovery {
+		return false
+	}
+	if lhs.PassiveMode != rhs.PassiveMode {
+		return false
+	}
+	if lhs.LocalAddress != rhs.LocalAddress {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp:transport
 type Transport struct {
 	// original -> bgp:transport-config
@@ -1298,6 +1933,19 @@ type Transport struct {
 	State TransportState `mapstructure:"state"`
 }
 
+func (lhs *Transport) Equal(rhs *Transport) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if !lhs.Config.Equal(&(rhs.Config)) {
+		return false
+	}
+	if !lhs.State.Equal(&(rhs.State)) {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp:state
 type TimersState struct {
 	// original -> bgp:connect-retry
@@ -1328,6 +1976,40 @@ type TimersState struct {
 	UpdateRecvTime int64 `mapstructure:"update-recv-time"`
 }
 
+func (lhs *TimersState) Equal(rhs *TimersState) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.ConnectRetry != rhs.ConnectRetry {
+		return false
+	}
+	if lhs.HoldTime != rhs.HoldTime {
+		return false
+	}
+	if lhs.KeepaliveInterval != rhs.KeepaliveInterval {
+		return false
+	}
+	if lhs.MinimumAdvertisementInterval != rhs.MinimumAdvertisementInterval {
+		return false
+	}
+	if lhs.Uptime != rhs.Uptime {
+		return false
+	}
+	if lhs.NegotiatedHoldTime != rhs.NegotiatedHoldTime {
+		return false
+	}
+	if lhs.IdleHoldTimeAfterReset != rhs.IdleHoldTimeAfterReset {
+		return false
+	}
+	if lhs.Downtime != rhs.Downtime {
+		return false
+	}
+	if lhs.UpdateRecvTime != rhs.UpdateRecvTime {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp:config
 type TimersConfig struct {
 	// original -> bgp:connect-retry
@@ -1347,6 +2029,28 @@ type TimersConfig struct {
 	IdleHoldTimeAfterReset float64 `mapstructure:"idle-hold-time-after-reset"`
 }
 
+func (lhs *TimersConfig) Equal(rhs *TimersConfig) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.ConnectRetry != rhs.ConnectRetry {
+		return false
+	}
+	if lhs.HoldTime != rhs.HoldTime {
+		return false
+	}
+	if lhs.KeepaliveInterval != rhs.KeepaliveInterval {
+		return false
+	}
+	if lhs.MinimumAdvertisementInterval != rhs.MinimumAdvertisementInterval {
+		return false
+	}
+	if lhs.IdleHoldTimeAfterReset != rhs.IdleHoldTimeAfterReset {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp:timers
 type Timers struct {
 	// original -> bgp:timers-config
@@ -1355,6 +2059,19 @@ type Timers struct {
 	State TimersState `mapstructure:"state"`
 }
 
+func (lhs *Timers) Equal(rhs *Timers) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if !lhs.Config.Equal(&(rhs.Config)) {
+		return false
+	}
+	if !lhs.State.Equal(&(rhs.State)) {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp:queues
 type Queues struct {
 	// original -> bgp-op:input
@@ -1363,6 +2080,19 @@ type Queues struct {
 	Output uint32 `mapstructure:"output"`
 }
 
+func (lhs *Queues) Equal(rhs *Queues) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.Input != rhs.Input {
+		return false
+	}
+	if lhs.Output != rhs.Output {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp:received
 type Received struct {
 	// original -> bgp-op:UPDATE
@@ -1383,6 +2113,37 @@ type Received struct {
 	Total uint64 `mapstructure:"total"`
 }
 
+func (lhs *Received) Equal(rhs *Received) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.Update != rhs.Update {
+		return false
+	}
+	if lhs.Notification != rhs.Notification {
+		return false
+	}
+	if lhs.Open != rhs.Open {
+		return false
+	}
+	if lhs.Refresh != rhs.Refresh {
+		return false
+	}
+	if lhs.Keepalive != rhs.Keepalive {
+		return false
+	}
+	if lhs.DynamicCap != rhs.DynamicCap {
+		return false
+	}
+	if lhs.Discarded != rhs.Discarded {
+		return false
+	}
+	if lhs.Total != rhs.Total {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp:sent
 type Sent struct {
 	// original -> bgp-op:UPDATE
@@ -1403,6 +2164,37 @@ type Sent struct {
 	Total uint64 `mapstructure:"total"`
 }
 
+func (lhs *Sent) Equal(rhs *Sent) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.Update != rhs.Update {
+		return false
+	}
+	if lhs.Notification != rhs.Notification {
+		return false
+	}
+	if lhs.Open != rhs.Open {
+		return false
+	}
+	if lhs.Refresh != rhs.Refresh {
+		return false
+	}
+	if lhs.Keepalive != rhs.Keepalive {
+		return false
+	}
+	if lhs.DynamicCap != rhs.DynamicCap {
+		return false
+	}
+	if lhs.Discarded != rhs.Discarded {
+		return false
+	}
+	if lhs.Total != rhs.Total {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp:messages
 type Messages struct {
 	// original -> bgp:sent
@@ -1411,6 +2203,19 @@ type Messages struct {
 	Received Received `mapstructure:"received"`
 }
 
+func (lhs *Messages) Equal(rhs *Messages) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if !lhs.Sent.Equal(&(rhs.Sent)) {
+		return false
+	}
+	if !lhs.Received.Equal(&(rhs.Received)) {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp:state
 type NeighborState struct {
 	// original -> bgp:peer-as
@@ -1454,6 +2259,69 @@ type NeighborState struct {
 	Flops uint32 `mapstructure:"flops"`
 }
 
+func (lhs *NeighborState) Equal(rhs *NeighborState) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.PeerAs != rhs.PeerAs {
+		return false
+	}
+	if lhs.LocalAs != rhs.LocalAs {
+		return false
+	}
+	if lhs.PeerType != rhs.PeerType {
+		return false
+	}
+	if lhs.AuthPassword != rhs.AuthPassword {
+		return false
+	}
+	if lhs.RemovePrivateAs != rhs.RemovePrivateAs {
+		return false
+	}
+	if lhs.RouteFlapDamping != rhs.RouteFlapDamping {
+		return false
+	}
+	if lhs.SendCommunity != rhs.SendCommunity {
+		return false
+	}
+	if lhs.Description != rhs.Description {
+		return false
+	}
+	if lhs.PeerGroup != rhs.PeerGroup {
+		return false
+	}
+	if lhs.NeighborAddress != rhs.NeighborAddress {
+		return false
+	}
+	if lhs.SessionState != rhs.SessionState {
+		return false
+	}
+	if len(lhs.SupportedCapabilitiesList) != len(rhs.SupportedCapabilitiesList) {
+		return false
+	}
+	for idx, l := range lhs.SupportedCapabilitiesList {
+		if l != rhs.SupportedCapabilitiesList[idx] {
+			return false
+		}
+	}
+	if !lhs.Messages.Equal(&(rhs.Messages)) {
+		return false
+	}
+	if !lhs.Queues.Equal(&(rhs.Queues)) {
+		return false
+	}
+	if lhs.AdminDown != rhs.AdminDown {
+		return false
+	}
+	if lhs.EstablishedCount != rhs.EstablishedCount {
+		return false
+	}
+	if lhs.Flops != rhs.Flops {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp:config
 type NeighborConfig struct {
 	// original -> bgp:peer-as
@@ -1485,6 +2353,46 @@ type NeighborConfig struct {
 	NeighborPortNumber uint16 `mapstructure:"neighbor-port-number"`
 }
 
+func (lhs *NeighborConfig) Equal(rhs *NeighborConfig) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.PeerAs != rhs.PeerAs {
+		return false
+	}
+	if lhs.LocalAs != rhs.LocalAs {
+		return false
+	}
+	if lhs.PeerType != rhs.PeerType {
+		return false
+	}
+	if lhs.AuthPassword != rhs.AuthPassword {
+		return false
+	}
+	if lhs.RemovePrivateAs != rhs.RemovePrivateAs {
+		return false
+	}
+	if lhs.RouteFlapDamping != rhs.RouteFlapDamping {
+		return false
+	}
+	if lhs.SendCommunity != rhs.SendCommunity {
+		return false
+	}
+	if lhs.Description != rhs.Description {
+		return false
+	}
+	if lhs.PeerGroup != rhs.PeerGroup {
+		return false
+	}
+	if lhs.NeighborAddress != rhs.NeighborAddress {
+		return false
+	}
+	if lhs.NeighborPortNumber != rhs.NeighborPortNumber {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp:neighbor
 type Neighbor struct {
 	// original -> bgp:neighbor-address
@@ -1522,6 +2430,74 @@ type Neighbor struct {
 	RouteServer RouteServer `mapstructure:"route-server"`
 }
 
+func (lhs *Neighbor) Equal(rhs *Neighbor) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.NeighborAddress != rhs.NeighborAddress {
+		return false
+	}
+	if !lhs.Config.Equal(&(rhs.Config)) {
+		return false
+	}
+	if !lhs.State.Equal(&(rhs.State)) {
+		return false
+	}
+	if !lhs.Timers.Equal(&(rhs.Timers)) {
+		return false
+	}
+	if !lhs.Transport.Equal(&(rhs.Transport)) {
+		return false
+	}
+	if !lhs.ErrorHandling.Equal(&(rhs.ErrorHandling)) {
+		return false
+	}
+	if !lhs.LoggingOptions.Equal(&(rhs.LoggingOptions)) {
+		return false
+	}
+	if !lhs.EbgpMultihop.Equal(&(rhs.EbgpMultihop)) {
+		return false
+	}
+	if !lhs.RouteReflector.Equal(&(rhs.RouteReflector)) {
+		return false
+	}
+	if !lhs.AsPathOptions.Equal(&(rhs.AsPathOptions)) {
+		return false
+	}
+	if !lhs.AddPaths.Equal(&(rhs.AddPaths)) {
+		return false
+	}
+	if len(lhs.AfiSafis) != len(rhs.AfiSafis) {
+		return false
+	}
+	{
+		lmap := make(map[string]*AfiSafi)
+		for _, l := range lhs.AfiSafis {
+			lmap[string(l.AfiSafiName)] = &l
+		}
+		for _, r := range rhs.AfiSafis {
+			if l, y := lmap[string(r.AfiSafiName)]; !y {
+				return false
+			} else if !r.Equal(l) {
+				return false
+			}
+		}
+	}
+	if !lhs.GracefulRestart.Equal(&(rhs.GracefulRestart)) {
+		return false
+	}
+	if !lhs.ApplyPolicy.Equal(&(rhs.ApplyPolicy)) {
+		return false
+	}
+	if !lhs.UseMultiplePaths.Equal(&(rhs.UseMultiplePaths)) {
+		return false
+	}
+	if !lhs.RouteServer.Equal(&(rhs.RouteServer)) {
+		return false
+	}
+	return true
+}
+
 //struct for container gobgp:listen-config
 type ListenConfig struct {
 	// original -> gobgp:port
@@ -1530,6 +2506,24 @@ type ListenConfig struct {
 	LocalAddressList []string `mapstructure:"local-address-list"`
 }
 
+func (lhs *ListenConfig) Equal(rhs *ListenConfig) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.Port != rhs.Port {
+		return false
+	}
+	if len(lhs.LocalAddressList) != len(rhs.LocalAddressList) {
+		return false
+	}
+	for idx, l := range lhs.LocalAddressList {
+		if l != rhs.LocalAddressList[idx] {
+			return false
+		}
+	}
+	return true
+}
+
 //struct for container gobgp:mpls-label-range
 type MplsLabelRange struct {
 	// original -> gobgp:min-label
@@ -1538,6 +2532,19 @@ type MplsLabelRange struct {
 	MaxLabel uint32 `mapstructure:"max-label"`
 }
 
+func (lhs *MplsLabelRange) Equal(rhs *MplsLabelRange) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.MinLabel != rhs.MinLabel {
+		return false
+	}
+	if lhs.MaxLabel != rhs.MaxLabel {
+		return false
+	}
+	return true
+}
+
 //struct for container gobgp:zebra
 type Zebra struct {
 	// original -> gobgp:enabled
@@ -1549,6 +2556,27 @@ type Zebra struct {
 	RedistributeRouteTypeList []InstallProtocolType `mapstructure:"redistribute-route-type-list"`
 }
 
+func (lhs *Zebra) Equal(rhs *Zebra) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.Enabled != rhs.Enabled {
+		return false
+	}
+	if lhs.Url != rhs.Url {
+		return false
+	}
+	if len(lhs.RedistributeRouteTypeList) != len(rhs.RedistributeRouteTypeList) {
+		return false
+	}
+	for idx, l := range lhs.RedistributeRouteTypeList {
+		if l != rhs.RedistributeRouteTypeList[idx] {
+			return false
+		}
+	}
+	return true
+}
+
 //struct for container gobgp:collector
 type Collector struct {
 	// original -> gobgp:enabled
@@ -1556,54 +2584,144 @@ type Collector struct {
 	Enabled bool `mapstructure:"enabled"`
 }
 
+func (lhs *Collector) Equal(rhs *Collector) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.Enabled != rhs.Enabled {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp-mp:l2vpn-evpn
 type L2vpnEvpn struct {
 	// original -> bgp-mp:prefix-limit
 	PrefixLimit PrefixLimit `mapstructure:"prefix-limit"`
 }
 
+func (lhs *L2vpnEvpn) Equal(rhs *L2vpnEvpn) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if !lhs.PrefixLimit.Equal(&(rhs.PrefixLimit)) {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp-mp:l2vpn-vpls
 type L2vpnVpls struct {
 	// original -> bgp-mp:prefix-limit
 	PrefixLimit PrefixLimit `mapstructure:"prefix-limit"`
 }
 
+func (lhs *L2vpnVpls) Equal(rhs *L2vpnVpls) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if !lhs.PrefixLimit.Equal(&(rhs.PrefixLimit)) {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp-mp:l3vpn-ipv6-multicast
 type L3vpnIpv6Multicast struct {
 	// original -> bgp-mp:prefix-limit
 	PrefixLimit PrefixLimit `mapstructure:"prefix-limit"`
 }
 
+func (lhs *L3vpnIpv6Multicast) Equal(rhs *L3vpnIpv6Multicast) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if !lhs.PrefixLimit.Equal(&(rhs.PrefixLimit)) {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp-mp:l3vpn-ipv4-multicast
 type L3vpnIpv4Multicast struct {
 	// original -> bgp-mp:prefix-limit
 	PrefixLimit PrefixLimit `mapstructure:"prefix-limit"`
 }
 
+func (lhs *L3vpnIpv4Multicast) Equal(rhs *L3vpnIpv4Multicast) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if !lhs.PrefixLimit.Equal(&(rhs.PrefixLimit)) {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp-mp:l3vpn-ipv6-unicast
 type L3vpnIpv6Unicast struct {
 	// original -> bgp-mp:prefix-limit
 	PrefixLimit PrefixLimit `mapstructure:"prefix-limit"`
 }
 
+func (lhs *L3vpnIpv6Unicast) Equal(rhs *L3vpnIpv6Unicast) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if !lhs.PrefixLimit.Equal(&(rhs.PrefixLimit)) {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp-mp:l3vpn-ipv4-unicast
 type L3vpnIpv4Unicast struct {
 	// original -> bgp-mp:prefix-limit
 	PrefixLimit PrefixLimit `mapstructure:"prefix-limit"`
 }
 
+func (lhs *L3vpnIpv4Unicast) Equal(rhs *L3vpnIpv4Unicast) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if !lhs.PrefixLimit.Equal(&(rhs.PrefixLimit)) {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp-mp:ipv6-labelled-unicast
 type Ipv6LabelledUnicast struct {
 	// original -> bgp-mp:prefix-limit
 	PrefixLimit PrefixLimit `mapstructure:"prefix-limit"`
 }
 
+func (lhs *Ipv6LabelledUnicast) Equal(rhs *Ipv6LabelledUnicast) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if !lhs.PrefixLimit.Equal(&(rhs.PrefixLimit)) {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp-mp:ipv4-labelled-unicast
 type Ipv4LabelledUnicast struct {
 	// original -> bgp-mp:prefix-limit
 	PrefixLimit PrefixLimit `mapstructure:"prefix-limit"`
 }
 
+func (lhs *Ipv4LabelledUnicast) Equal(rhs *Ipv4LabelledUnicast) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if !lhs.PrefixLimit.Equal(&(rhs.PrefixLimit)) {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp-mp:state
 type Ipv6UnicastState struct {
 	// original -> bgp-mp:send-default-route
@@ -1611,6 +2729,16 @@ type Ipv6UnicastState struct {
 	SendDefaultRoute bool `mapstructure:"send-default-route"`
 }
 
+func (lhs *Ipv6UnicastState) Equal(rhs *Ipv6UnicastState) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.SendDefaultRoute != rhs.SendDefaultRoute {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp-mp:config
 type Ipv6UnicastConfig struct {
 	// original -> bgp-mp:send-default-route
@@ -1618,6 +2746,16 @@ type Ipv6UnicastConfig struct {
 	SendDefaultRoute bool `mapstructure:"send-default-route"`
 }
 
+func (lhs *Ipv6UnicastConfig) Equal(rhs *Ipv6UnicastConfig) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.SendDefaultRoute != rhs.SendDefaultRoute {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp-mp:ipv6-unicast
 type Ipv6Unicast struct {
 	// original -> bgp-mp:prefix-limit
@@ -1628,6 +2766,22 @@ type Ipv6Unicast struct {
 	State Ipv6UnicastState `mapstructure:"state"`
 }
 
+func (lhs *Ipv6Unicast) Equal(rhs *Ipv6Unicast) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if !lhs.PrefixLimit.Equal(&(rhs.PrefixLimit)) {
+		return false
+	}
+	if !lhs.Config.Equal(&(rhs.Config)) {
+		return false
+	}
+	if !lhs.State.Equal(&(rhs.State)) {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp-mp:state
 type Ipv4UnicastState struct {
 	// original -> bgp-mp:send-default-route
@@ -1635,6 +2789,16 @@ type Ipv4UnicastState struct {
 	SendDefaultRoute bool `mapstructure:"send-default-route"`
 }
 
+func (lhs *Ipv4UnicastState) Equal(rhs *Ipv4UnicastState) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.SendDefaultRoute != rhs.SendDefaultRoute {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp-mp:config
 type Ipv4UnicastConfig struct {
 	// original -> bgp-mp:send-default-route
@@ -1642,6 +2806,16 @@ type Ipv4UnicastConfig struct {
 	SendDefaultRoute bool `mapstructure:"send-default-route"`
 }
 
+func (lhs *Ipv4UnicastConfig) Equal(rhs *Ipv4UnicastConfig) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.SendDefaultRoute != rhs.SendDefaultRoute {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp-mp:state
 type PrefixLimitState struct {
 	// original -> bgp-mp:max-prefixes
@@ -1653,6 +2827,22 @@ type PrefixLimitState struct {
 	RestartTimer float64 `mapstructure:"restart-timer"`
 }
 
+func (lhs *PrefixLimitState) Equal(rhs *PrefixLimitState) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.MaxPrefixes != rhs.MaxPrefixes {
+		return false
+	}
+	if lhs.ShutdownThresholdPct != rhs.ShutdownThresholdPct {
+		return false
+	}
+	if lhs.RestartTimer != rhs.RestartTimer {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp-mp:config
 type PrefixLimitConfig struct {
 	// original -> bgp-mp:max-prefixes
@@ -1664,6 +2854,22 @@ type PrefixLimitConfig struct {
 	RestartTimer float64 `mapstructure:"restart-timer"`
 }
 
+func (lhs *PrefixLimitConfig) Equal(rhs *PrefixLimitConfig) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.MaxPrefixes != rhs.MaxPrefixes {
+		return false
+	}
+	if lhs.ShutdownThresholdPct != rhs.ShutdownThresholdPct {
+		return false
+	}
+	if lhs.RestartTimer != rhs.RestartTimer {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp-mp:prefix-limit
 type PrefixLimit struct {
 	// original -> bgp-mp:prefix-limit-config
@@ -1672,6 +2878,19 @@ type PrefixLimit struct {
 	State PrefixLimitState `mapstructure:"state"`
 }
 
+func (lhs *PrefixLimit) Equal(rhs *PrefixLimit) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if !lhs.Config.Equal(&(rhs.Config)) {
+		return false
+	}
+	if !lhs.State.Equal(&(rhs.State)) {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp-mp:ipv4-unicast
 type Ipv4Unicast struct {
 	// original -> bgp-mp:prefix-limit
@@ -1682,6 +2901,22 @@ type Ipv4Unicast struct {
 	State Ipv4UnicastState `mapstructure:"state"`
 }
 
+func (lhs *Ipv4Unicast) Equal(rhs *Ipv4Unicast) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if !lhs.PrefixLimit.Equal(&(rhs.PrefixLimit)) {
+		return false
+	}
+	if !lhs.Config.Equal(&(rhs.Config)) {
+		return false
+	}
+	if !lhs.State.Equal(&(rhs.State)) {
+		return false
+	}
+	return true
+}
+
 //struct for container rpol:state
 type ApplyPolicyState struct {
 	// original -> rpol:import-policy
@@ -1698,6 +2933,46 @@ type ApplyPolicyState struct {
 	DefaultInPolicy DefaultPolicyType `mapstructure:"default-in-policy"`
 }
 
+func (lhs *ApplyPolicyState) Equal(rhs *ApplyPolicyState) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if len(lhs.ImportPolicyList) != len(rhs.ImportPolicyList) {
+		return false
+	}
+	for idx, l := range lhs.ImportPolicyList {
+		if l != rhs.ImportPolicyList[idx] {
+			return false
+		}
+	}
+	if lhs.DefaultImportPolicy != rhs.DefaultImportPolicy {
+		return false
+	}
+	if len(lhs.ExportPolicyList) != len(rhs.ExportPolicyList) {
+		return false
+	}
+	for idx, l := range lhs.ExportPolicyList {
+		if l != rhs.ExportPolicyList[idx] {
+			return false
+		}
+	}
+	if lhs.DefaultExportPolicy != rhs.DefaultExportPolicy {
+		return false
+	}
+	if len(lhs.InPolicyList) != len(rhs.InPolicyList) {
+		return false
+	}
+	for idx, l := range lhs.InPolicyList {
+		if l != rhs.InPolicyList[idx] {
+			return false
+		}
+	}
+	if lhs.DefaultInPolicy != rhs.DefaultInPolicy {
+		return false
+	}
+	return true
+}
+
 //struct for container rpol:config
 type ApplyPolicyConfig struct {
 	// original -> rpol:import-policy
@@ -1714,6 +2989,46 @@ type ApplyPolicyConfig struct {
 	DefaultInPolicy DefaultPolicyType `mapstructure:"default-in-policy"`
 }
 
+func (lhs *ApplyPolicyConfig) Equal(rhs *ApplyPolicyConfig) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if len(lhs.ImportPolicyList) != len(rhs.ImportPolicyList) {
+		return false
+	}
+	for idx, l := range lhs.ImportPolicyList {
+		if l != rhs.ImportPolicyList[idx] {
+			return false
+		}
+	}
+	if lhs.DefaultImportPolicy != rhs.DefaultImportPolicy {
+		return false
+	}
+	if len(lhs.ExportPolicyList) != len(rhs.ExportPolicyList) {
+		return false
+	}
+	for idx, l := range lhs.ExportPolicyList {
+		if l != rhs.ExportPolicyList[idx] {
+			return false
+		}
+	}
+	if lhs.DefaultExportPolicy != rhs.DefaultExportPolicy {
+		return false
+	}
+	if len(lhs.InPolicyList) != len(rhs.InPolicyList) {
+		return false
+	}
+	for idx, l := range lhs.InPolicyList {
+		if l != rhs.InPolicyList[idx] {
+			return false
+		}
+	}
+	if lhs.DefaultInPolicy != rhs.DefaultInPolicy {
+		return false
+	}
+	return true
+}
+
 //struct for container rpol:apply-policy
 type ApplyPolicy struct {
 	// original -> rpol:apply-policy-config
@@ -1722,6 +3037,19 @@ type ApplyPolicy struct {
 	State ApplyPolicyState `mapstructure:"state"`
 }
 
+func (lhs *ApplyPolicy) Equal(rhs *ApplyPolicy) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if !lhs.Config.Equal(&(rhs.Config)) {
+		return false
+	}
+	if !lhs.State.Equal(&(rhs.State)) {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp-mp:state
 type AfiSafiState struct {
 	// original -> bgp-mp:afi-safi-name
@@ -1735,6 +3063,25 @@ type AfiSafiState struct {
 	TotalPrefixes uint32 `mapstructure:"total-prefixes"`
 }
 
+func (lhs *AfiSafiState) Equal(rhs *AfiSafiState) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.AfiSafiName != rhs.AfiSafiName {
+		return false
+	}
+	if lhs.Enabled != rhs.Enabled {
+		return false
+	}
+	if lhs.TotalPaths != rhs.TotalPaths {
+		return false
+	}
+	if lhs.TotalPrefixes != rhs.TotalPrefixes {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp-mp:config
 type AfiSafiConfig struct {
 	// original -> bgp-mp:afi-safi-name
@@ -1744,6 +3091,19 @@ type AfiSafiConfig struct {
 	Enabled bool `mapstructure:"enabled"`
 }
 
+func (lhs *AfiSafiConfig) Equal(rhs *AfiSafiConfig) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.AfiSafiName != rhs.AfiSafiName {
+		return false
+	}
+	if lhs.Enabled != rhs.Enabled {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp-mp:state
 type MpGracefulRestartState struct {
 	// original -> bgp-mp:enabled
@@ -1763,6 +3123,28 @@ type MpGracefulRestartState struct {
 	EndOfRibSent bool `mapstructure:"end-of-rib-sent"`
 }
 
+func (lhs *MpGracefulRestartState) Equal(rhs *MpGracefulRestartState) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.Enabled != rhs.Enabled {
+		return false
+	}
+	if lhs.Received != rhs.Received {
+		return false
+	}
+	if lhs.Advertised != rhs.Advertised {
+		return false
+	}
+	if lhs.EndOfRibReceived != rhs.EndOfRibReceived {
+		return false
+	}
+	if lhs.EndOfRibSent != rhs.EndOfRibSent {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp-mp:config
 type MpGracefulRestartConfig struct {
 	// original -> bgp-mp:enabled
@@ -1770,6 +3152,16 @@ type MpGracefulRestartConfig struct {
 	Enabled bool `mapstructure:"enabled"`
 }
 
+func (lhs *MpGracefulRestartConfig) Equal(rhs *MpGracefulRestartConfig) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.Enabled != rhs.Enabled {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp-mp:graceful-restart
 type MpGracefulRestart struct {
 	// original -> bgp-mp:mp-graceful-restart-config
@@ -1778,6 +3170,19 @@ type MpGracefulRestart struct {
 	State MpGracefulRestartState `mapstructure:"state"`
 }
 
+func (lhs *MpGracefulRestart) Equal(rhs *MpGracefulRestart) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if !lhs.Config.Equal(&(rhs.Config)) {
+		return false
+	}
+	if !lhs.State.Equal(&(rhs.State)) {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp-mp:afi-safi
 type AfiSafi struct {
 	// original -> bgp-mp:afi-safi-name
@@ -1818,6 +3223,67 @@ type AfiSafi struct {
 	PrefixLimit PrefixLimit `mapstructure:"prefix-limit"`
 }
 
+func (lhs *AfiSafi) Equal(rhs *AfiSafi) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.AfiSafiName != rhs.AfiSafiName {
+		return false
+	}
+	if !lhs.MpGracefulRestart.Equal(&(rhs.MpGracefulRestart)) {
+		return false
+	}
+	if !lhs.Config.Equal(&(rhs.Config)) {
+		return false
+	}
+	if !lhs.State.Equal(&(rhs.State)) {
+		return false
+	}
+	if !lhs.ApplyPolicy.Equal(&(rhs.ApplyPolicy)) {
+		return false
+	}
+	if !lhs.Ipv4Unicast.Equal(&(rhs.Ipv4Unicast)) {
+		return false
+	}
+	if !lhs.Ipv6Unicast.Equal(&(rhs.Ipv6Unicast)) {
+		return false
+	}
+	if !lhs.Ipv4LabelledUnicast.Equal(&(rhs.Ipv4LabelledUnicast)) {
+		return false
+	}
+	if !lhs.Ipv6LabelledUnicast.Equal(&(rhs.Ipv6LabelledUnicast)) {
+		return false
+	}
+	if !lhs.L3vpnIpv4Unicast.Equal(&(rhs.L3vpnIpv4Unicast)) {
+		return false
+	}
+	if !lhs.L3vpnIpv6Unicast.Equal(&(rhs.L3vpnIpv6Unicast)) {
+		return false
+	}
+	if !lhs.L3vpnIpv4Multicast.Equal(&(rhs.L3vpnIpv4Multicast)) {
+		return false
+	}
+	if !lhs.L3vpnIpv6Multicast.Equal(&(rhs.L3vpnIpv6Multicast)) {
+		return false
+	}
+	if !lhs.L2vpnVpls.Equal(&(rhs.L2vpnVpls)) {
+		return false
+	}
+	if !lhs.L2vpnEvpn.Equal(&(rhs.L2vpnEvpn)) {
+		return false
+	}
+	if !lhs.RouteSelectionOptions.Equal(&(rhs.RouteSelectionOptions)) {
+		return false
+	}
+	if !lhs.UseMultiplePaths.Equal(&(rhs.UseMultiplePaths)) {
+		return false
+	}
+	if !lhs.PrefixLimit.Equal(&(rhs.PrefixLimit)) {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp:state
 type GracefulRestartState struct {
 	// original -> bgp:enabled
@@ -1845,6 +3311,40 @@ type GracefulRestartState struct {
 	DeferralTime uint16 `mapstructure:"deferral-time"`
 }
 
+func (lhs *GracefulRestartState) Equal(rhs *GracefulRestartState) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.Enabled != rhs.Enabled {
+		return false
+	}
+	if lhs.RestartTime != rhs.RestartTime {
+		return false
+	}
+	if lhs.StaleRoutesTime != rhs.StaleRoutesTime {
+		return false
+	}
+	if lhs.HelperOnly != rhs.HelperOnly {
+		return false
+	}
+	if lhs.PeerRestartTime != rhs.PeerRestartTime {
+		return false
+	}
+	if lhs.PeerRestarting != rhs.PeerRestarting {
+		return false
+	}
+	if lhs.LocalRestarting != rhs.LocalRestarting {
+		return false
+	}
+	if lhs.Mode != rhs.Mode {
+		return false
+	}
+	if lhs.DeferralTime != rhs.DeferralTime {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp:config
 type GracefulRestartConfig struct {
 	// original -> bgp:enabled
@@ -1862,6 +3362,28 @@ type GracefulRestartConfig struct {
 	DeferralTime uint16 `mapstructure:"deferral-time"`
 }
 
+func (lhs *GracefulRestartConfig) Equal(rhs *GracefulRestartConfig) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.Enabled != rhs.Enabled {
+		return false
+	}
+	if lhs.RestartTime != rhs.RestartTime {
+		return false
+	}
+	if lhs.StaleRoutesTime != rhs.StaleRoutesTime {
+		return false
+	}
+	if lhs.HelperOnly != rhs.HelperOnly {
+		return false
+	}
+	if lhs.DeferralTime != rhs.DeferralTime {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp:graceful-restart
 type GracefulRestart struct {
 	// original -> bgp:graceful-restart-config
@@ -1870,18 +3392,51 @@ type GracefulRestart struct {
 	State GracefulRestartState `mapstructure:"state"`
 }
 
+func (lhs *GracefulRestart) Equal(rhs *GracefulRestart) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if !lhs.Config.Equal(&(rhs.Config)) {
+		return false
+	}
+	if !lhs.State.Equal(&(rhs.State)) {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp-mp:state
 type IbgpState struct {
 	// original -> bgp-mp:maximum-paths
 	MaximumPaths uint32 `mapstructure:"maximum-paths"`
 }
 
+func (lhs *IbgpState) Equal(rhs *IbgpState) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.MaximumPaths != rhs.MaximumPaths {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp-mp:config
 type IbgpConfig struct {
 	// original -> bgp-mp:maximum-paths
 	MaximumPaths uint32 `mapstructure:"maximum-paths"`
 }
 
+func (lhs *IbgpConfig) Equal(rhs *IbgpConfig) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.MaximumPaths != rhs.MaximumPaths {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp-mp:ibgp
 type Ibgp struct {
 	// original -> bgp-mp:ibgp-config
@@ -1890,6 +3445,19 @@ type Ibgp struct {
 	State IbgpState `mapstructure:"state"`
 }
 
+func (lhs *Ibgp) Equal(rhs *Ibgp) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if !lhs.Config.Equal(&(rhs.Config)) {
+		return false
+	}
+	if !lhs.State.Equal(&(rhs.State)) {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp-mp:state
 type EbgpState struct {
 	// original -> bgp-mp:allow-multiple-as
@@ -1899,6 +3467,19 @@ type EbgpState struct {
 	MaximumPaths uint32 `mapstructure:"maximum-paths"`
 }
 
+func (lhs *EbgpState) Equal(rhs *EbgpState) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.AllowMultipleAs != rhs.AllowMultipleAs {
+		return false
+	}
+	if lhs.MaximumPaths != rhs.MaximumPaths {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp-mp:config
 type EbgpConfig struct {
 	// original -> bgp-mp:allow-multiple-as
@@ -1908,6 +3489,19 @@ type EbgpConfig struct {
 	MaximumPaths uint32 `mapstructure:"maximum-paths"`
 }
 
+func (lhs *EbgpConfig) Equal(rhs *EbgpConfig) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.AllowMultipleAs != rhs.AllowMultipleAs {
+		return false
+	}
+	if lhs.MaximumPaths != rhs.MaximumPaths {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp-mp:ebgp
 type Ebgp struct {
 	// original -> bgp-mp:ebgp-config
@@ -1916,6 +3510,19 @@ type Ebgp struct {
 	State EbgpState `mapstructure:"state"`
 }
 
+func (lhs *Ebgp) Equal(rhs *Ebgp) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if !lhs.Config.Equal(&(rhs.Config)) {
+		return false
+	}
+	if !lhs.State.Equal(&(rhs.State)) {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp-mp:state
 type UseMultiplePathsState struct {
 	// original -> bgp-mp:enabled
@@ -1923,6 +3530,16 @@ type UseMultiplePathsState struct {
 	Enabled bool `mapstructure:"enabled"`
 }
 
+func (lhs *UseMultiplePathsState) Equal(rhs *UseMultiplePathsState) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.Enabled != rhs.Enabled {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp-mp:config
 type UseMultiplePathsConfig struct {
 	// original -> bgp-mp:enabled
@@ -1930,6 +3547,16 @@ type UseMultiplePathsConfig struct {
 	Enabled bool `mapstructure:"enabled"`
 }
 
+func (lhs *UseMultiplePathsConfig) Equal(rhs *UseMultiplePathsConfig) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.Enabled != rhs.Enabled {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp-mp:use-multiple-paths
 type UseMultiplePaths struct {
 	// original -> bgp-mp:use-multiple-paths-config
@@ -1942,6 +3569,25 @@ type UseMultiplePaths struct {
 	Ibgp Ibgp `mapstructure:"ibgp"`
 }
 
+func (lhs *UseMultiplePaths) Equal(rhs *UseMultiplePaths) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if !lhs.Config.Equal(&(rhs.Config)) {
+		return false
+	}
+	if !lhs.State.Equal(&(rhs.State)) {
+		return false
+	}
+	if !lhs.Ebgp.Equal(&(rhs.Ebgp)) {
+		return false
+	}
+	if !lhs.Ibgp.Equal(&(rhs.Ibgp)) {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp:state
 type ConfederationState struct {
 	// original -> bgp:enabled
@@ -1955,6 +3601,27 @@ type ConfederationState struct {
 	MemberAsList []uint32 `mapstructure:"member-as-list"`
 }
 
+func (lhs *ConfederationState) Equal(rhs *ConfederationState) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.Enabled != rhs.Enabled {
+		return false
+	}
+	if lhs.Identifier != rhs.Identifier {
+		return false
+	}
+	if len(lhs.MemberAsList) != len(rhs.MemberAsList) {
+		return false
+	}
+	for idx, l := range lhs.MemberAsList {
+		if l != rhs.MemberAsList[idx] {
+			return false
+		}
+	}
+	return true
+}
+
 //struct for container bgp:config
 type ConfederationConfig struct {
 	// original -> bgp:enabled
@@ -1968,6 +3635,27 @@ type ConfederationConfig struct {
 	MemberAsList []uint32 `mapstructure:"member-as-list"`
 }
 
+func (lhs *ConfederationConfig) Equal(rhs *ConfederationConfig) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.Enabled != rhs.Enabled {
+		return false
+	}
+	if lhs.Identifier != rhs.Identifier {
+		return false
+	}
+	if len(lhs.MemberAsList) != len(rhs.MemberAsList) {
+		return false
+	}
+	for idx, l := range lhs.MemberAsList {
+		if l != rhs.MemberAsList[idx] {
+			return false
+		}
+	}
+	return true
+}
+
 //struct for container bgp:confederation
 type Confederation struct {
 	// original -> bgp:confederation-config
@@ -1976,6 +3664,19 @@ type Confederation struct {
 	State ConfederationState `mapstructure:"state"`
 }
 
+func (lhs *Confederation) Equal(rhs *Confederation) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if !lhs.Config.Equal(&(rhs.Config)) {
+		return false
+	}
+	if !lhs.State.Equal(&(rhs.State)) {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp:state
 type DefaultRouteDistanceState struct {
 	// original -> bgp:external-route-distance
@@ -1984,6 +3685,19 @@ type DefaultRouteDistanceState struct {
 	InternalRouteDistance uint8 `mapstructure:"internal-route-distance"`
 }
 
+func (lhs *DefaultRouteDistanceState) Equal(rhs *DefaultRouteDistanceState) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.ExternalRouteDistance != rhs.ExternalRouteDistance {
+		return false
+	}
+	if lhs.InternalRouteDistance != rhs.InternalRouteDistance {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp:config
 type DefaultRouteDistanceConfig struct {
 	// original -> bgp:external-route-distance
@@ -1992,6 +3706,19 @@ type DefaultRouteDistanceConfig struct {
 	InternalRouteDistance uint8 `mapstructure:"internal-route-distance"`
 }
 
+func (lhs *DefaultRouteDistanceConfig) Equal(rhs *DefaultRouteDistanceConfig) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.ExternalRouteDistance != rhs.ExternalRouteDistance {
+		return false
+	}
+	if lhs.InternalRouteDistance != rhs.InternalRouteDistance {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp:default-route-distance
 type DefaultRouteDistance struct {
 	// original -> bgp:default-route-distance-config
@@ -2000,6 +3727,19 @@ type DefaultRouteDistance struct {
 	State DefaultRouteDistanceState `mapstructure:"state"`
 }
 
+func (lhs *DefaultRouteDistance) Equal(rhs *DefaultRouteDistance) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if !lhs.Config.Equal(&(rhs.Config)) {
+		return false
+	}
+	if !lhs.State.Equal(&(rhs.State)) {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp-mp:state
 type RouteSelectionOptionsState struct {
 	// original -> bgp-mp:always-compare-med
@@ -2022,6 +3762,31 @@ type RouteSelectionOptionsState struct {
 	IgnoreNextHopIgpMetric bool `mapstructure:"ignore-next-hop-igp-metric"`
 }
 
+func (lhs *RouteSelectionOptionsState) Equal(rhs *RouteSelectionOptionsState) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.AlwaysCompareMed != rhs.AlwaysCompareMed {
+		return false
+	}
+	if lhs.IgnoreAsPathLength != rhs.IgnoreAsPathLength {
+		return false
+	}
+	if lhs.ExternalCompareRouterId != rhs.ExternalCompareRouterId {
+		return false
+	}
+	if lhs.AdvertiseInactiveRoutes != rhs.AdvertiseInactiveRoutes {
+		return false
+	}
+	if lhs.EnableAigp != rhs.EnableAigp {
+		return false
+	}
+	if lhs.IgnoreNextHopIgpMetric != rhs.IgnoreNextHopIgpMetric {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp-mp:config
 type RouteSelectionOptionsConfig struct {
 	// original -> bgp-mp:always-compare-med
@@ -2044,6 +3809,31 @@ type RouteSelectionOptionsConfig struct {
 	IgnoreNextHopIgpMetric bool `mapstructure:"ignore-next-hop-igp-metric"`
 }
 
+func (lhs *RouteSelectionOptionsConfig) Equal(rhs *RouteSelectionOptionsConfig) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.AlwaysCompareMed != rhs.AlwaysCompareMed {
+		return false
+	}
+	if lhs.IgnoreAsPathLength != rhs.IgnoreAsPathLength {
+		return false
+	}
+	if lhs.ExternalCompareRouterId != rhs.ExternalCompareRouterId {
+		return false
+	}
+	if lhs.AdvertiseInactiveRoutes != rhs.AdvertiseInactiveRoutes {
+		return false
+	}
+	if lhs.EnableAigp != rhs.EnableAigp {
+		return false
+	}
+	if lhs.IgnoreNextHopIgpMetric != rhs.IgnoreNextHopIgpMetric {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp-mp:route-selection-options
 type RouteSelectionOptions struct {
 	// original -> bgp-mp:route-selection-options-config
@@ -2052,6 +3842,19 @@ type RouteSelectionOptions struct {
 	State RouteSelectionOptionsState `mapstructure:"state"`
 }
 
+func (lhs *RouteSelectionOptions) Equal(rhs *RouteSelectionOptions) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if !lhs.Config.Equal(&(rhs.Config)) {
+		return false
+	}
+	if !lhs.State.Equal(&(rhs.State)) {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp:state
 type GlobalState struct {
 	// original -> bgp:as
@@ -2066,6 +3869,25 @@ type GlobalState struct {
 	TotalPrefixes uint32 `mapstructure:"total-prefixes"`
 }
 
+func (lhs *GlobalState) Equal(rhs *GlobalState) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.As != rhs.As {
+		return false
+	}
+	if lhs.RouterId != rhs.RouterId {
+		return false
+	}
+	if lhs.TotalPaths != rhs.TotalPaths {
+		return false
+	}
+	if lhs.TotalPrefixes != rhs.TotalPrefixes {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp:config
 type GlobalConfig struct {
 	// original -> bgp:as
@@ -2076,6 +3898,19 @@ type GlobalConfig struct {
 	RouterId string `mapstructure:"router-id"`
 }
 
+func (lhs *GlobalConfig) Equal(rhs *GlobalConfig) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.As != rhs.As {
+		return false
+	}
+	if lhs.RouterId != rhs.RouterId {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp:global
 type Global struct {
 	// original -> bgp:global-config
@@ -2106,6 +3941,65 @@ type Global struct {
 	ListenConfig ListenConfig `mapstructure:"listen-config"`
 }
 
+func (lhs *Global) Equal(rhs *Global) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if !lhs.Config.Equal(&(rhs.Config)) {
+		return false
+	}
+	if !lhs.State.Equal(&(rhs.State)) {
+		return false
+	}
+	if !lhs.RouteSelectionOptions.Equal(&(rhs.RouteSelectionOptions)) {
+		return false
+	}
+	if !lhs.DefaultRouteDistance.Equal(&(rhs.DefaultRouteDistance)) {
+		return false
+	}
+	if !lhs.Confederation.Equal(&(rhs.Confederation)) {
+		return false
+	}
+	if !lhs.UseMultiplePaths.Equal(&(rhs.UseMultiplePaths)) {
+		return false
+	}
+	if !lhs.GracefulRestart.Equal(&(rhs.GracefulRestart)) {
+		return false
+	}
+	if len(lhs.AfiSafis) != len(rhs.AfiSafis) {
+		return false
+	}
+	{
+		lmap := make(map[string]*AfiSafi)
+		for _, l := range lhs.AfiSafis {
+			lmap[string(l.AfiSafiName)] = &l
+		}
+		for _, r := range rhs.AfiSafis {
+			if l, y := lmap[string(r.AfiSafiName)]; !y {
+				return false
+			} else if !r.Equal(l) {
+				return false
+			}
+		}
+	}
+	if !lhs.ApplyPolicy.Equal(&(rhs.ApplyPolicy)) {
+		return false
+	}
+	if !lhs.Collector.Equal(&(rhs.Collector)) {
+		return false
+	}
+	if !lhs.Zebra.Equal(&(rhs.Zebra)) {
+		return false
+	}
+	if !lhs.MplsLabelRange.Equal(&(rhs.MplsLabelRange)) {
+		return false
+	}
+	if !lhs.ListenConfig.Equal(&(rhs.ListenConfig)) {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp:bgp
 type Bgp struct {
 	// original -> bgp:global
@@ -2122,6 +4016,96 @@ type Bgp struct {
 	MrtDump []Mrt `mapstructure:"mrt-dump"`
 }
 
+func (lhs *Bgp) Equal(rhs *Bgp) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if !lhs.Global.Equal(&(rhs.Global)) {
+		return false
+	}
+	if len(lhs.Neighbors) != len(rhs.Neighbors) {
+		return false
+	}
+	{
+		lmap := make(map[string]*Neighbor)
+		for _, l := range lhs.Neighbors {
+			lmap[string(l.NeighborAddress)] = &l
+		}
+		for _, r := range rhs.Neighbors {
+			if l, y := lmap[string(r.NeighborAddress)]; !y {
+				return false
+			} else if !r.Equal(l) {
+				return false
+			}
+		}
+	}
+	if len(lhs.PeerGroups) != len(rhs.PeerGroups) {
+		return false
+	}
+	{
+		lmap := make(map[string]*PeerGroup)
+		for _, l := range lhs.PeerGroups {
+			lmap[string(l.PeerGroupName)] = &l
+		}
+		for _, r := range rhs.PeerGroups {
+			if l, y := lmap[string(r.PeerGroupName)]; !y {
+				return false
+			} else if !r.Equal(l) {
+				return false
+			}
+		}
+	}
+	if len(lhs.RpkiServers) != len(rhs.RpkiServers) {
+		return false
+	}
+	{
+		lmap := make(map[string]*RpkiServer)
+		for _, l := range lhs.RpkiServers {
+			lmap[string(l.Address)] = &l
+		}
+		for _, r := range rhs.RpkiServers {
+			if l, y := lmap[string(r.Address)]; !y {
+				return false
+			} else if !r.Equal(l) {
+				return false
+			}
+		}
+	}
+	if len(lhs.BmpServers) != len(rhs.BmpServers) {
+		return false
+	}
+	{
+		lmap := make(map[string]*BmpServer)
+		for _, l := range lhs.BmpServers {
+			lmap[string(l.Address)] = &l
+		}
+		for _, r := range rhs.BmpServers {
+			if l, y := lmap[string(r.Address)]; !y {
+				return false
+			} else if !r.Equal(l) {
+				return false
+			}
+		}
+	}
+	if len(lhs.MrtDump) != len(rhs.MrtDump) {
+		return false
+	}
+	{
+		lmap := make(map[string]*Mrt)
+		for _, l := range lhs.MrtDump {
+			lmap[string(l.FileName)] = &l
+		}
+		for _, r := range rhs.MrtDump {
+			if l, y := lmap[string(r.FileName)]; !y {
+				return false
+			} else if !r.Equal(l) {
+				return false
+			}
+		}
+	}
+	return true
+}
+
 //struct for container bgp-pol:set-ext-community-method
 type SetExtCommunityMethod struct {
 	// original -> bgp-pol:communities
@@ -2131,6 +4115,24 @@ type SetExtCommunityMethod struct {
 	ExtCommunitySetRef string `mapstructure:"ext-community-set-ref"`
 }
 
+func (lhs *SetExtCommunityMethod) Equal(rhs *SetExtCommunityMethod) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if len(lhs.CommunitiesList) != len(rhs.CommunitiesList) {
+		return false
+	}
+	for idx, l := range lhs.CommunitiesList {
+		if l != rhs.CommunitiesList[idx] {
+			return false
+		}
+	}
+	if lhs.ExtCommunitySetRef != rhs.ExtCommunitySetRef {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp-pol:set-ext-community
 type SetExtCommunity struct {
 	// original -> bgp-pol:set-ext-community-method
@@ -2140,6 +4142,19 @@ type SetExtCommunity struct {
 	Options string `mapstructure:"options"`
 }
 
+func (lhs *SetExtCommunity) Equal(rhs *SetExtCommunity) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if !lhs.SetExtCommunityMethod.Equal(&(rhs.SetExtCommunityMethod)) {
+		return false
+	}
+	if lhs.Options != rhs.Options {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp-pol:set-community-method
 type SetCommunityMethod struct {
 	// original -> bgp-pol:communities
@@ -2149,6 +4164,24 @@ type SetCommunityMethod struct {
 	CommunitySetRef string `mapstructure:"community-set-ref"`
 }
 
+func (lhs *SetCommunityMethod) Equal(rhs *SetCommunityMethod) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if len(lhs.CommunitiesList) != len(rhs.CommunitiesList) {
+		return false
+	}
+	for idx, l := range lhs.CommunitiesList {
+		if l != rhs.CommunitiesList[idx] {
+			return false
+		}
+	}
+	if lhs.CommunitySetRef != rhs.CommunitySetRef {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp-pol:set-community
 type SetCommunity struct {
 	// original -> bgp-pol:set-community-method
@@ -2158,6 +4191,19 @@ type SetCommunity struct {
 	Options string `mapstructure:"options"`
 }
 
+func (lhs *SetCommunity) Equal(rhs *SetCommunity) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if !lhs.SetCommunityMethod.Equal(&(rhs.SetCommunityMethod)) {
+		return false
+	}
+	if lhs.Options != rhs.Options {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp-pol:set-as-path-prepend
 type SetAsPathPrepend struct {
 	// original -> bgp-pol:repeat-n
@@ -2167,6 +4213,19 @@ type SetAsPathPrepend struct {
 	As string `mapstructure:"as"`
 }
 
+func (lhs *SetAsPathPrepend) Equal(rhs *SetAsPathPrepend) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.RepeatN != rhs.RepeatN {
+		return false
+	}
+	if lhs.As != rhs.As {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp-pol:bgp-actions
 type BgpActions struct {
 	// original -> bgp-pol:set-as-path-prepend
@@ -2185,12 +4244,50 @@ type BgpActions struct {
 	SetMed BgpSetMedType `mapstructure:"set-med"`
 }
 
+func (lhs *BgpActions) Equal(rhs *BgpActions) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if !lhs.SetAsPathPrepend.Equal(&(rhs.SetAsPathPrepend)) {
+		return false
+	}
+	if !lhs.SetCommunity.Equal(&(rhs.SetCommunity)) {
+		return false
+	}
+	if !lhs.SetExtCommunity.Equal(&(rhs.SetExtCommunity)) {
+		return false
+	}
+	if lhs.SetRouteOrigin != rhs.SetRouteOrigin {
+		return false
+	}
+	if lhs.SetLocalPref != rhs.SetLocalPref {
+		return false
+	}
+	if lhs.SetNextHop != rhs.SetNextHop {
+		return false
+	}
+	if lhs.SetMed != rhs.SetMed {
+		return false
+	}
+	return true
+}
+
 //struct for container rpol:igp-actions
 type IgpActions struct {
 	// original -> rpol:set-tag
 	SetTag TagType `mapstructure:"set-tag"`
 }
 
+func (lhs *IgpActions) Equal(rhs *IgpActions) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.SetTag != rhs.SetTag {
+		return false
+	}
+	return true
+}
+
 //struct for container rpol:route-disposition
 type RouteDisposition struct {
 	// original -> rpol:accept-route
@@ -2201,6 +4298,19 @@ type RouteDisposition struct {
 	RejectRoute bool `mapstructure:"reject-route"`
 }
 
+func (lhs *RouteDisposition) Equal(rhs *RouteDisposition) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.AcceptRoute != rhs.AcceptRoute {
+		return false
+	}
+	if lhs.RejectRoute != rhs.RejectRoute {
+		return false
+	}
+	return true
+}
+
 //struct for container rpol:actions
 type Actions struct {
 	// original -> rpol:route-disposition
@@ -2211,6 +4321,22 @@ type Actions struct {
 	BgpActions BgpActions `mapstructure:"bgp-actions"`
 }
 
+func (lhs *Actions) Equal(rhs *Actions) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if !lhs.RouteDisposition.Equal(&(rhs.RouteDisposition)) {
+		return false
+	}
+	if !lhs.IgpActions.Equal(&(rhs.IgpActions)) {
+		return false
+	}
+	if !lhs.BgpActions.Equal(&(rhs.BgpActions)) {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp-pol:as-path-length
 type AsPathLength struct {
 	// original -> ptypes:operator
@@ -2219,6 +4345,19 @@ type AsPathLength struct {
 	Value uint32 `mapstructure:"value"`
 }
 
+func (lhs *AsPathLength) Equal(rhs *AsPathLength) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.Operator != rhs.Operator {
+		return false
+	}
+	if lhs.Value != rhs.Value {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp-pol:community-count
 type CommunityCount struct {
 	// original -> ptypes:operator
@@ -2227,6 +4366,19 @@ type CommunityCount struct {
 	Value uint32 `mapstructure:"value"`
 }
 
+func (lhs *CommunityCount) Equal(rhs *CommunityCount) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.Operator != rhs.Operator {
+		return false
+	}
+	if lhs.Value != rhs.Value {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp-pol:match-as-path-set
 type MatchAsPathSet struct {
 	// original -> bgp-pol:as-path-set
@@ -2235,6 +4387,19 @@ type MatchAsPathSet struct {
 	MatchSetOptions MatchSetOptionsType `mapstructure:"match-set-options"`
 }
 
+func (lhs *MatchAsPathSet) Equal(rhs *MatchAsPathSet) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.AsPathSet != rhs.AsPathSet {
+		return false
+	}
+	if lhs.MatchSetOptions != rhs.MatchSetOptions {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp-pol:match-ext-community-set
 type MatchExtCommunitySet struct {
 	// original -> bgp-pol:ext-community-set
@@ -2243,6 +4408,19 @@ type MatchExtCommunitySet struct {
 	MatchSetOptions MatchSetOptionsType `mapstructure:"match-set-options"`
 }
 
+func (lhs *MatchExtCommunitySet) Equal(rhs *MatchExtCommunitySet) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.ExtCommunitySet != rhs.ExtCommunitySet {
+		return false
+	}
+	if lhs.MatchSetOptions != rhs.MatchSetOptions {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp-pol:match-community-set
 type MatchCommunitySet struct {
 	// original -> bgp-pol:community-set
@@ -2251,6 +4429,19 @@ type MatchCommunitySet struct {
 	MatchSetOptions MatchSetOptionsType `mapstructure:"match-set-options"`
 }
 
+func (lhs *MatchCommunitySet) Equal(rhs *MatchCommunitySet) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.CommunitySet != rhs.CommunitySet {
+		return false
+	}
+	if lhs.MatchSetOptions != rhs.MatchSetOptions {
+		return false
+	}
+	return true
+}
+
 //struct for container bgp-pol:bgp-conditions
 type BgpConditions struct {
 	// original -> bgp-pol:match-community-set
@@ -2280,10 +4471,70 @@ type BgpConditions struct {
 	RpkiValidationResult RpkiValidationResultType `mapstructure:"rpki-validation-result"`
 }
 
+func (lhs *BgpConditions) Equal(rhs *BgpConditions) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if !lhs.MatchCommunitySet.Equal(&(rhs.MatchCommunitySet)) {
+		return false
+	}
+	if !lhs.MatchExtCommunitySet.Equal(&(rhs.MatchExtCommunitySet)) {
+		return false
+	}
+	if !lhs.MatchAsPathSet.Equal(&(rhs.MatchAsPathSet)) {
+		return false
+	}
+	if lhs.MedEq != rhs.MedEq {
+		return false
+	}
+	if lhs.OriginEq != rhs.OriginEq {
+		return false
+	}
+	if len(lhs.NextHopInList) != len(rhs.NextHopInList) {
+		return false
+	}
+	for idx, l := range lhs.NextHopInList {
+		if l != rhs.NextHopInList[idx] {
+			return false
+		}
+	}
+	if len(lhs.AfiSafiInList) != len(rhs.AfiSafiInList) {
+		return false
+	}
+	for idx, l := range lhs.AfiSafiInList {
+		if l != rhs.AfiSafiInList[idx] {
+			return false
+		}
+	}
+	if lhs.LocalPrefEq != rhs.LocalPrefEq {
+		return false
+	}
+	if !lhs.CommunityCount.Equal(&(rhs.CommunityCount)) {
+		return false
+	}
+	if !lhs.AsPathLength.Equal(&(rhs.AsPathLength)) {
+		return false
+	}
+	if lhs.RouteType != rhs.RouteType {
+		return false
+	}
+	if lhs.RpkiValidationResult != rhs.RpkiValidationResult {
+		return false
+	}
+	return true
+}
+
 //struct for container rpol:igp-conditions
 type IgpConditions struct {
 }
 
+func (lhs *IgpConditions) Equal(rhs *IgpConditions) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	return true
+}
+
 //struct for container rpol:match-tag-set
 type MatchTagSet struct {
 	// original -> rpol:tag-set
@@ -2292,6 +4543,19 @@ type MatchTagSet struct {
 	MatchSetOptions MatchSetOptionsRestrictedType `mapstructure:"match-set-options"`
 }
 
+func (lhs *MatchTagSet) Equal(rhs *MatchTagSet) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.TagSet != rhs.TagSet {
+		return false
+	}
+	if lhs.MatchSetOptions != rhs.MatchSetOptions {
+		return false
+	}
+	return true
+}
+
 //struct for container rpol:match-neighbor-set
 type MatchNeighborSet struct {
 	// original -> rpol:neighbor-set
@@ -2300,6 +4564,19 @@ type MatchNeighborSet struct {
 	MatchSetOptions MatchSetOptionsRestrictedType `mapstructure:"match-set-options"`
 }
 
+func (lhs *MatchNeighborSet) Equal(rhs *MatchNeighborSet) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.NeighborSet != rhs.NeighborSet {
+		return false
+	}
+	if lhs.MatchSetOptions != rhs.MatchSetOptions {
+		return false
+	}
+	return true
+}
+
 //struct for container rpol:match-prefix-set
 type MatchPrefixSet struct {
 	// original -> rpol:prefix-set
@@ -2308,6 +4585,19 @@ type MatchPrefixSet struct {
 	MatchSetOptions MatchSetOptionsRestrictedType `mapstructure:"match-set-options"`
 }
 
+func (lhs *MatchPrefixSet) Equal(rhs *MatchPrefixSet) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.PrefixSet != rhs.PrefixSet {
+		return false
+	}
+	if lhs.MatchSetOptions != rhs.MatchSetOptions {
+		return false
+	}
+	return true
+}
+
 //struct for container rpol:conditions
 type Conditions struct {
 	// original -> rpol:call-policy
@@ -2326,6 +4616,34 @@ type Conditions struct {
 	BgpConditions BgpConditions `mapstructure:"bgp-conditions"`
 }
 
+func (lhs *Conditions) Equal(rhs *Conditions) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.CallPolicy != rhs.CallPolicy {
+		return false
+	}
+	if !lhs.MatchPrefixSet.Equal(&(rhs.MatchPrefixSet)) {
+		return false
+	}
+	if !lhs.MatchNeighborSet.Equal(&(rhs.MatchNeighborSet)) {
+		return false
+	}
+	if !lhs.MatchTagSet.Equal(&(rhs.MatchTagSet)) {
+		return false
+	}
+	if lhs.InstallProtocolEq != rhs.InstallProtocolEq {
+		return false
+	}
+	if !lhs.IgpConditions.Equal(&(rhs.IgpConditions)) {
+		return false
+	}
+	if !lhs.BgpConditions.Equal(&(rhs.BgpConditions)) {
+		return false
+	}
+	return true
+}
+
 //struct for container rpol:statement
 type Statement struct {
 	// original -> rpol:name
@@ -2336,6 +4654,22 @@ type Statement struct {
 	Actions Actions `mapstructure:"actions"`
 }
 
+func (lhs *Statement) Equal(rhs *Statement) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.Name != rhs.Name {
+		return false
+	}
+	if !lhs.Conditions.Equal(&(rhs.Conditions)) {
+		return false
+	}
+	if !lhs.Actions.Equal(&(rhs.Actions)) {
+		return false
+	}
+	return true
+}
+
 //struct for container rpol:policy-definition
 type PolicyDefinition struct {
 	// original -> rpol:name
@@ -2344,6 +4678,32 @@ type PolicyDefinition struct {
 	Statements []Statement `mapstructure:"statements"`
 }
 
+func (lhs *PolicyDefinition) Equal(rhs *PolicyDefinition) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.Name != rhs.Name {
+		return false
+	}
+	if len(lhs.Statements) != len(rhs.Statements) {
+		return false
+	}
+	{
+		lmap := make(map[string]*Statement)
+		for _, l := range lhs.Statements {
+			lmap[string(l.Name)] = &l
+		}
+		for _, r := range rhs.Statements {
+			if l, y := lmap[string(r.Name)]; !y {
+				return false
+			} else if !r.Equal(l) {
+				return false
+			}
+		}
+	}
+	return true
+}
+
 //struct for container bgp-pol:as-path-set
 type AsPathSet struct {
 	// original -> bgp-pol:as-path-set-name
@@ -2352,6 +4712,24 @@ type AsPathSet struct {
 	AsPathList []string `mapstructure:"as-path-list"`
 }
 
+func (lhs *AsPathSet) Equal(rhs *AsPathSet) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.AsPathSetName != rhs.AsPathSetName {
+		return false
+	}
+	if len(lhs.AsPathList) != len(rhs.AsPathList) {
+		return false
+	}
+	for idx, l := range lhs.AsPathList {
+		if l != rhs.AsPathList[idx] {
+			return false
+		}
+	}
+	return true
+}
+
 //struct for container bgp-pol:ext-community-set
 type ExtCommunitySet struct {
 	// original -> bgp-pol:ext-community-set-name
@@ -2360,6 +4738,24 @@ type ExtCommunitySet struct {
 	ExtCommunityList []string `mapstructure:"ext-community-list"`
 }
 
+func (lhs *ExtCommunitySet) Equal(rhs *ExtCommunitySet) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.ExtCommunitySetName != rhs.ExtCommunitySetName {
+		return false
+	}
+	if len(lhs.ExtCommunityList) != len(rhs.ExtCommunityList) {
+		return false
+	}
+	for idx, l := range lhs.ExtCommunityList {
+		if l != rhs.ExtCommunityList[idx] {
+			return false
+		}
+	}
+	return true
+}
+
 //struct for container bgp-pol:community-set
 type CommunitySet struct {
 	// original -> bgp-pol:community-set-name
@@ -2368,6 +4764,24 @@ type CommunitySet struct {
 	CommunityList []string `mapstructure:"community-list"`
 }
 
+func (lhs *CommunitySet) Equal(rhs *CommunitySet) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.CommunitySetName != rhs.CommunitySetName {
+		return false
+	}
+	if len(lhs.CommunityList) != len(rhs.CommunityList) {
+		return false
+	}
+	for idx, l := range lhs.CommunityList {
+		if l != rhs.CommunityList[idx] {
+			return false
+		}
+	}
+	return true
+}
+
 //struct for container bgp-pol:bgp-defined-sets
 type BgpDefinedSets struct {
 	// original -> bgp-pol:community-sets
@@ -2378,12 +4792,77 @@ type BgpDefinedSets struct {
 	AsPathSets []AsPathSet `mapstructure:"as-path-sets"`
 }
 
+func (lhs *BgpDefinedSets) Equal(rhs *BgpDefinedSets) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if len(lhs.CommunitySets) != len(rhs.CommunitySets) {
+		return false
+	}
+	{
+		lmap := make(map[string]*CommunitySet)
+		for _, l := range lhs.CommunitySets {
+			lmap[string(l.CommunitySetName)] = &l
+		}
+		for _, r := range rhs.CommunitySets {
+			if l, y := lmap[string(r.CommunitySetName)]; !y {
+				return false
+			} else if !r.Equal(l) {
+				return false
+			}
+		}
+	}
+	if len(lhs.ExtCommunitySets) != len(rhs.ExtCommunitySets) {
+		return false
+	}
+	{
+		lmap := make(map[string]*ExtCommunitySet)
+		for _, l := range lhs.ExtCommunitySets {
+			lmap[string(l.ExtCommunitySetName)] = &l
+		}
+		for _, r := range rhs.ExtCommunitySets {
+			if l, y := lmap[string(r.ExtCommunitySetName)]; !y {
+				return false
+			} else if !r.Equal(l) {
+				return false
+			}
+		}
+	}
+	if len(lhs.AsPathSets) != len(rhs.AsPathSets) {
+		return false
+	}
+	{
+		lmap := make(map[string]*AsPathSet)
+		for _, l := range lhs.AsPathSets {
+			lmap[string(l.AsPathSetName)] = &l
+		}
+		for _, r := range rhs.AsPathSets {
+			if l, y := lmap[string(r.AsPathSetName)]; !y {
+				return false
+			} else if !r.Equal(l) {
+				return false
+			}
+		}
+	}
+	return true
+}
+
 //struct for container rpol:tag
 type Tag struct {
 	// original -> rpol:value
 	Value TagType `mapstructure:"value"`
 }
 
+func (lhs *Tag) Equal(rhs *Tag) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.Value != rhs.Value {
+		return false
+	}
+	return true
+}
+
 //struct for container rpol:tag-set
 type TagSet struct {
 	// original -> rpol:tag-set-name
@@ -2392,6 +4871,32 @@ type TagSet struct {
 	TagList []Tag `mapstructure:"tag-list"`
 }
 
+func (lhs *TagSet) Equal(rhs *TagSet) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.TagSetName != rhs.TagSetName {
+		return false
+	}
+	if len(lhs.TagList) != len(rhs.TagList) {
+		return false
+	}
+	{
+		lmap := make(map[string]*Tag)
+		for _, l := range lhs.TagList {
+			lmap[string(l.Value)] = &l
+		}
+		for _, r := range rhs.TagList {
+			if l, y := lmap[string(r.Value)]; !y {
+				return false
+			} else if !r.Equal(l) {
+				return false
+			}
+		}
+	}
+	return true
+}
+
 //struct for container rpol:neighbor-set
 type NeighborSet struct {
 	// original -> rpol:neighbor-set-name
@@ -2401,6 +4906,24 @@ type NeighborSet struct {
 	NeighborInfoList []string `mapstructure:"neighbor-info-list"`
 }
 
+func (lhs *NeighborSet) Equal(rhs *NeighborSet) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.NeighborSetName != rhs.NeighborSetName {
+		return false
+	}
+	if len(lhs.NeighborInfoList) != len(rhs.NeighborInfoList) {
+		return false
+	}
+	for idx, l := range lhs.NeighborInfoList {
+		if l != rhs.NeighborInfoList[idx] {
+			return false
+		}
+	}
+	return true
+}
+
 //struct for container rpol:prefix
 type Prefix struct {
 	// original -> rpol:ip-prefix
@@ -2410,6 +4933,19 @@ type Prefix struct {
 	MasklengthRange string `mapstructure:"masklength-range"`
 }
 
+func (lhs *Prefix) Equal(rhs *Prefix) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.IpPrefix != rhs.IpPrefix {
+		return false
+	}
+	if lhs.MasklengthRange != rhs.MasklengthRange {
+		return false
+	}
+	return true
+}
+
 //struct for container rpol:prefix-set
 type PrefixSet struct {
 	// original -> rpol:prefix-set-name
@@ -2418,6 +4954,32 @@ type PrefixSet struct {
 	PrefixList []Prefix `mapstructure:"prefix-list"`
 }
 
+func (lhs *PrefixSet) Equal(rhs *PrefixSet) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if lhs.PrefixSetName != rhs.PrefixSetName {
+		return false
+	}
+	if len(lhs.PrefixList) != len(rhs.PrefixList) {
+		return false
+	}
+	{
+		lmap := make(map[string]*Prefix)
+		for _, l := range lhs.PrefixList {
+			lmap[string(l.IpPrefix+l.MasklengthRange)] = &l
+		}
+		for _, r := range rhs.PrefixList {
+			if l, y := lmap[string(r.IpPrefix+r.MasklengthRange)]; !y {
+				return false
+			} else if !r.Equal(l) {
+				return false
+			}
+		}
+	}
+	return true
+}
+
 //struct for container rpol:defined-sets
 type DefinedSets struct {
 	// original -> rpol:prefix-sets
@@ -2430,6 +4992,64 @@ type DefinedSets struct {
 	BgpDefinedSets BgpDefinedSets `mapstructure:"bgp-defined-sets"`
 }
 
+func (lhs *DefinedSets) Equal(rhs *DefinedSets) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if len(lhs.PrefixSets) != len(rhs.PrefixSets) {
+		return false
+	}
+	{
+		lmap := make(map[string]*PrefixSet)
+		for _, l := range lhs.PrefixSets {
+			lmap[string(l.PrefixSetName)] = &l
+		}
+		for _, r := range rhs.PrefixSets {
+			if l, y := lmap[string(r.PrefixSetName)]; !y {
+				return false
+			} else if !r.Equal(l) {
+				return false
+			}
+		}
+	}
+	if len(lhs.NeighborSets) != len(rhs.NeighborSets) {
+		return false
+	}
+	{
+		lmap := make(map[string]*NeighborSet)
+		for _, l := range lhs.NeighborSets {
+			lmap[string(l.NeighborSetName)] = &l
+		}
+		for _, r := range rhs.NeighborSets {
+			if l, y := lmap[string(r.NeighborSetName)]; !y {
+				return false
+			} else if !r.Equal(l) {
+				return false
+			}
+		}
+	}
+	if len(lhs.TagSets) != len(rhs.TagSets) {
+		return false
+	}
+	{
+		lmap := make(map[string]*TagSet)
+		for _, l := range lhs.TagSets {
+			lmap[string(l.TagSetName)] = &l
+		}
+		for _, r := range rhs.TagSets {
+			if l, y := lmap[string(r.TagSetName)]; !y {
+				return false
+			} else if !r.Equal(l) {
+				return false
+			}
+		}
+	}
+	if !lhs.BgpDefinedSets.Equal(&(rhs.BgpDefinedSets)) {
+		return false
+	}
+	return true
+}
+
 //struct for container rpol:routing-policy
 type RoutingPolicy struct {
 	// original -> rpol:defined-sets
@@ -2437,3 +5057,29 @@ type RoutingPolicy struct {
 	// original -> rpol:policy-definitions
 	PolicyDefinitions []PolicyDefinition `mapstructure:"policy-definitions"`
 }
+
+func (lhs *RoutingPolicy) Equal(rhs *RoutingPolicy) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	if !lhs.DefinedSets.Equal(&(rhs.DefinedSets)) {
+		return false
+	}
+	if len(lhs.PolicyDefinitions) != len(rhs.PolicyDefinitions) {
+		return false
+	}
+	{
+		lmap := make(map[string]*PolicyDefinition)
+		for _, l := range lhs.PolicyDefinitions {
+			lmap[string(l.Name)] = &l
+		}
+		for _, r := range rhs.PolicyDefinitions {
+			if l, y := lmap[string(r.Name)]; !y {
+				return false
+			} else if !r.Equal(l) {
+				return false
+			}
+		}
+	}
+	return true
+}