No OneTemporary
Actions

Size

424 KB

Referenced Files

None

Subscribers

None

View Options

This file is larger than 256 KB, so syntax highlighting was skipped.

	diff --git a/changelogs/fragments/T8609_rm_templates_regex_backtracking.yml b/changelogs/fragments/T8609_rm_templates_regex_backtracking.yml
	new file mode 100644
	index 00000000..b02dbf19
	--- /dev/null
	+++ b/changelogs/fragments/T8609_rm_templates_regex_backtracking.yml
	@@ -0,0 +1,12 @@
	+---
	+bugfixes:
	+ - bgp_address_family.py - Fix slow parse() to stop regex backtracking on prefix-sharing inputs.
	+ - bgp_address_family_14.py - Fix slow parse() to stop regex backtracking on prefix-sharing inputs.
	+ - bgp_global.py - Fix slow parse() to stop regex backtracking on prefix-sharing inputs.
	+ - bgp_global_14.py - Fix slow parse() to stop regex backtracking on prefix-sharing inputs.
	+ - ospf_interfaces.py - Fix slow parse() to stop regex backtracking on prefix-sharing inputs.
	+ - ospf_interfaces_14.py - Fix slow parse() to stop regex backtracking on prefix-sharing inputs.
	+ - route_maps.py - Fix slow parse() to stop regex backtracking on prefix-sharing inputs.
	+ - route_maps_14.py - Fix slow parse() to stop regex backtracking on prefix-sharing inputs.
	+ - snmp_server.py - Fix slow parse() to stop regex backtracking on prefix-sharing inputs.
	+ - test_rm_templates_perf.py - Add unit test for the bugfixes
	diff --git a/plugins/module_utils/network/vyos/rm_templates/bgp_address_family.py b/plugins/module_utils/network/vyos/rm_templates/bgp_address_family.py
	index f8f86cd2..fccfc9c2 100644
	--- a/plugins/module_utils/network/vyos/rm_templates/bgp_address_family.py
	+++ b/plugins/module_utils/network/vyos/rm_templates/bgp_address_family.py
	@@ -1,1450 +1,1435 @@
	# -- coding: utf-8 --
	# Copyright 2021 Red Hat
	# GNU General Public License v3.0+
	# (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)

	from __future__ import absolute_import, division, print_function


	__metaclass__ = type

	"""
	The Bgp_address_family parser templates file. This contains
	a list of parser definitions and associated functions that
	facilitates both facts gathering and native command generation for
	the given network resource.
	"""

	import re

	from ansible_collections.ansible.netcommon.plugins.module_utils.network.common.rm_base.network_template import (
	NetworkTemplate,
	)


	def _tmplt_bgp_af_aggregate_address(config_data):
	afi = config_data["address_family"]["afi"] + "-unicast"
	command = "protocols bgp {as_number} address-family ".format(**config_data)
	config_data = config_data["address_family"]
	if config_data["aggregate_address"].get("as_set"):
	command += afi + " aggregate-address {prefix} as-set".format(
	**config_data["aggregate_address"],
	)
	if config_data["aggregate_address"].get("summary_only"):
	command += afi + " aggregate-address {prefix} summary-only".format(
	**config_data["aggregate_address"],
	)
	return command


	def _tmplt_bgp_af_redistribute(config_data):
	afi = config_data["address_family"]["afi"] + "-unicast"
	command = "protocols bgp {as_number} address-family ".format(**config_data)
	config_data = config_data["address_family"]["redistribute"]
	command += afi + " redistribute {protocol}".format(**config_data)
	if config_data.get("metric"):
	command += " metric {metric}".format(**config_data)
	elif config_data.get("route_map"):
	command += " route-map {route_map}".format(**config_data)
	elif config_data.get("table"):
	command += " table {table}".format(**config_data)
	return command


	def _tmplt_bgp_af_redistribute_delete(config_data):
	afi = config_data["address_family"]["afi"] + "-unicast"
	command = "protocols bgp {as_number} address-family ".format(**config_data)
	config_data = config_data["address_family"]["redistribute"]
	command += afi + " redistribute {protocol}".format(**config_data)
	if config_data.get("metric"):
	command += " metric"
	elif config_data.get("route_map"):
	command += " route-map"
	elif config_data.get("table"):
	command += " table"
	return command


	def _tmplt_bgp_af_neighbor_distribute_list(config_data):
	command = []
	afi = config_data["neighbors"]["address_family"]["afi"] + "-unicast"
	cmd = "protocols bgp {as_number} neighbor ".format(**config_data)
	cmd += "{neighbor_address} address-family ".format(**config_data["neighbors"])
	config_data = config_data["neighbors"]["address_family"]
	for list_el in config_data["distribute_list"]:
	command.append(
	cmd + afi + " distribute-list " + list_el["action"] + " " + str(list_el["acl"]),
	)
	return command


	def _tmplt_bgp_af_neighbor_route_map(config_data):
	command = []
	afi = config_data["neighbors"]["address_family"]["afi"] + "-unicast"
	cmd = "protocols bgp {as_number} neighbor ".format(**config_data)
	cmd += "{neighbor_address} address-family ".format(**config_data["neighbors"])
	config_data = config_data["neighbors"]["address_family"]
	for list_el in config_data["route_map"]:
	command.append(
	cmd + afi + " route-map " + list_el["action"] + " " + str(list_el["route_map"]),
	)
	return command


	def _tmplt_bgp_af_neighbor_prefix_list(config_data):
	command = []
	afi = config_data["neighbors"]["address_family"]["afi"] + "-unicast"
	cmd = "protocols bgp {as_number} neighbor ".format(**config_data)
	cmd += "{neighbor_address} address-family ".format(**config_data["neighbors"])
	config_data = config_data["neighbors"]["address_family"]
	for list_el in config_data["prefix_list"]:
	command.append(
	cmd + afi + " prefix-list " + list_el["action"] + " " + str(list_el["prefix_list"]),
	)
	return command


	def _tmplt_bgp_af_neighbor_filter_list(config_data):
	command = []
	afi = config_data["neighbors"]["address_family"]["afi"] + "-unicast"
	cmd = "protocols bgp {as_number} neighbor ".format(**config_data)
	cmd += "{neighbor_address} address-family ".format(**config_data["neighbors"])
	config_data = config_data["neighbors"]["address_family"]
	for list_el in config_data["filter_list"]:
	command.append(
	cmd + afi + " filter-list " + list_el["action"] + " " + str(list_el["path_list"]),
	)
	return command


	def _tmplt_bgp_af_neighbor_attribute(config_data):
	command = []
	afi = config_data["neighbors"]["address_family"]["afi"] + "-unicast"
	cmd = "protocols bgp {as_number} neighbor ".format(**config_data)
	cmd += "{neighbor_address} address-family ".format(**config_data["neighbors"])
	config_data = config_data["neighbors"]["address_family"]
	for k in config_data["attribute_unchanged"].keys():
	if config_data["attribute_unchanged"][k]:
	k = re.sub("_", "-", k)
	c = cmd + afi + " attribute-unchanged " + k
	command.append(c)
	return command


	def _tmplt_bgp_af_neighbor_delete(config_data):
	afi = config_data["neighbors"]["address_family"]["afi"] + "-unicast"
	command = "protocols bgp {as_number} ".format(**config_data)
	command += (
	"neighbor {neighbor_address} address-family ".format(**config_data["neighbors"]) + afi
	)
	config_data = config_data["neighbors"]["address_family"]
	if config_data.get("allowas_in"):
	command += " allowas-in"
	elif config_data.get("as_override"):
	command += " as-override"
	elif config_data.get("attribute_unchanged"):
	command += " attribute-unchanged"
	elif config_data.get("capability"):
	command += " capability"
	elif config_data.get("default_originate"):
	command += " default-originate"
	elif config_data.get("maximum_prefix"):
	command += " maximum-prefix"
	elif config_data.get("nexthop_local"):
	command += " nexthop-local"
	elif config_data.get("nexthop_self"):
	command += " nexthop-self"
	elif config_data.get("peer_group"):
	command += " peer-group"
	elif config_data.get("remote_private_as"):
	command += " remote-private-as"
	elif config_data.get("route_reflector_client"):
	command += " route-reflector-client"
	elif config_data.get("route_server_client"):
	command += " route-server-client"
	elif config_data.get("soft_reconfiguration"):
	command += " soft-reconfiguration"
	elif config_data.get("unsuppress_map"):
	command += " unsuppress-map"
	elif config_data.get("weight"):
	command += " weight"
	elif config_data.get("filter_list"):
	command += " filter-list"
	elif config_data.get("prefix_list"):
	command += " prefix-list"
	elif config_data.get("distribute_list"):
	command += " distribute-list"
	elif config_data.get("route_map"):
	command += " route-map"
	return command


	def _tmplt_bgp_af_neighbor(config_data):
	afi = config_data["neighbors"]["address_family"]["afi"] + "-unicast"
	command = "protocols bgp {as_number} ".format(**config_data)
	command += (
	"neighbor {neighbor_address} address-family ".format(**config_data["neighbors"]) + afi
	)
	config_data = config_data["neighbors"]["address_family"]
	if config_data.get("allowas_in"):
	command += " allowas-in number {allowas_in}".format(**config_data)
	elif config_data.get("as_override"):
	command += " as-override"
	elif config_data.get("capability"):
	command += " capability "
	if config_data["capability"].get("dynamic"):
	command += "dynamic"
	elif config_data["capability"].get("orf"):
	command += " prefix-list {orf}".format(**config_data["capability"])
	elif config_data.get("default_originate"):
	command += " default-originate route-map {default_originate}".format(**config_data)
	elif config_data.get("maximum_prefix"):
	command += " maximum-prefix {maximum_prefix}".format(**config_data)
	elif config_data.get("nexthop_local"):
	command += " nexthop-local"
	elif config_data.get("nexthop_self"):
	command += " nexthop-self"
	elif config_data.get("peer_group"):
	command += " peer-group {peer_group}".format(**config_data)
	elif config_data.get("remote_private_as"):
	command += " remote-private-as"
	elif config_data.get("route_reflector_client"):
	command += " route-reflector-client"
	elif config_data.get("route_server_client"):
	command += " route-server-client"
	elif config_data.get("soft_reconfiguration"):
	command += " soft-reconfiguration inbound"
	elif config_data.get("unsuppress_map"):
	command += " unsuppress-map {unsuppress_map}".format(**config_data)
	elif config_data.get("weight"):
	command += " weight {weight}".format(**config_data)
	return command


	def _tmplt_bgp_af_network(config_data):
	afi = config_data["address_family"]["afi"] + "-unicast"
	command = "protocols bgp {as_number} address-family ".format(**config_data)
	config_data = config_data["address_family"]["networks"]
	command += afi + " network {prefix}".format(**config_data)
	if config_data.get("backdoor"):
	command += " backdoor"
	elif config_data.get("route_map"):
	command += " route-map {route_map}".format(**config_data)
	return command


	def _tmplt_bgp_af_network_delete(config_data):
	afi = config_data["address_family"]["afi"] + "-unicast"
	command = "protocols bgp {as_number} address-family ".format(**config_data)
	config_data = config_data["address_family"]["networks"]
	command += afi + " network {prefix}".format(**config_data)
	if config_data.get("backdoor"):
	command += " backdoor"
	elif config_data.get("route_map"):
	command += " route_map"
	return command


	class Bgp_address_familyTemplate(NetworkTemplate):
	def __init__(self, lines=None, module=None):
	prefix = {"set": "set", "remove": "delete"}
	super(Bgp_address_familyTemplate, self).__init__(
	lines=lines,
	tmplt=self,
	prefix=prefix,
	module=module,
	)

	# fmt: off
	PARSERS = [
	{
	"name": "address_family",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+address-family
	\s+(?P<afi>\S+)-unicast
	*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp {{ as_number }} address-family {{ address_family.afi }}-unicast",
	"compval": "as_number",
	"result": {
	"as_number": "{{ as_num }}",
	"address_family": {
	"{{ afi }}": {
	"afi": "{{ afi }}",
	},
	},
	},
	},
	{
	"name": "aggregate_address",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+address-family
	\s+(?P<afi>\S+)-unicast
	\s+aggregate-address
	\s+(?P<address>\S+)
	- \s(?P<as_set>as-set)
	- \s(?P<summary_only>summary-only)
	+ \s*(?P<as_set>as-set)?
	+ \s*(?P<summary_only>summary-only)?
	$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_af_aggregate_address,
	"remval": "protocols bgp {{ as_number }} address-family {{ address_family.afi }}-unicast aggregate-address" +
	" {{ address_family.aggregate_address.prefix }}",
	"compval": "address_family.aggregate_address",
	"result": {
	"as_number": "{{ as_num }}",
	"address_family": {
	"{{ afi }}": {
	"afi": "{{ afi }}",
	"aggregate_address": [
	{
	"prefix": "{{ address }}",
	"as_set": "{{ True if as_set is defined }}",
	"summary_only": "{{ True if summary_only is defined }}",
	},
	],
	},
	},
	},
	},
	{
	"name": "network",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+address-family
	\s+(?P<afi>\S+)-unicast
	\s+network
	\s+(?P<address>\S+)
	$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_af_network,
	"remval": "protocols bgp {{ as_number }} address-family {{ address_family.afi }}-unicast network {{ address_family.networks.prefix }}",
	"compval": "address_family.networks.prefix",
	"result": {
	"as_number": "{{ as_num }}",
	"address_family": {
	"{{ afi }}": {
	"afi": "{{ afi }}",
	"networks": [
	{
	"prefix": "{{ address }}",
	},
	],
	},
	},
	},
	},
	{
	"name": "network.backdoor",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+address-family
	\s+(?P<afi>\S+)-unicast
	\s+network
	\s+(?P<address>\S+)
	\s+backdoor
	*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_af_network,
	"remval": _tmplt_bgp_af_network_delete,
	"compval": "address_family.networks.backdoor",
	"result": {
	"as_number": "{{ as_num }}",
	"address_family": {
	"{{ afi }}": {
	"afi": "{{ afi }}",
	"networks": [
	{
	"prefix": "{{ address }}",
	"backdoor": "{{ True }}",
	},
	],
	},
	},
	},
	},
	{
	"name": "network.path_limit",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+address-family
	\s+(?P<afi>\S+)-unicast
	\s+network
	\s+(?P<address>\S+)
	\s+path-limit
	- \s+(?P<limit>\S+)
	- *$""",
	+ \s+(?P<limit>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_af_network,
	"remval": _tmplt_bgp_af_network_delete,
	"compval": "address_family.networks.path_limit",
	"result": {
	"as_number": "{{ as_num }}",
	"address_family": {
	"{{ afi }}": {
	"afi": "{{ afi }}",
	"networks": [
	{
	"prefix": "{{ address }}",
	"path_limit": "{{ limit\|int }}",
	},
	],
	},
	},
	},
	},
	{
	"name": "network.route_map",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+address-family
	\s+(?P<afi>\S+)-unicast
	\s+network
	\s+(?P<address>\S+)
	\s+route-map
	- \s+(?P<map>\S+)
	- *$""",
	+ \s+(?P<map>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_af_network,
	"remval": _tmplt_bgp_af_network_delete,
	"compval": "address_family.networks.route_map",
	"result": {
	"as_number": "{{ as_num }}",
	"address_family": {
	"{{ afi }}": {
	"afi": "{{ afi }}",
	"networks": [
	{
	"prefix": "{{ address }}",
	"route_map": "{{ map }}",
	},
	],
	},
	},
	},
	},
	{
	"name": "redistribute",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+address-family
	\s+(?P<afi>\S+)-unicast
	\s+redistribute
	\s+(?P<proto>\S+)
	$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_af_redistribute,
	"remval": "protocols bgp {{ as_number }} address-family {{ address_family.afi }}-unicast redistribute {{ address_family.redistribute.protocol }}",
	"compval": "address_family.redistribute.protocol",
	"result": {
	"as_number": "{{ as_num }}",
	"address_family": {
	"{{ afi }}": {
	"afi": "{{ afi }}",
	"redistribute": [
	{
	"protocol": "{{ proto }}",
	},
	],
	},
	},
	},
	},
	{
	"name": "redistribute.metric",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+address-family
	\s+(?P<afi>\S+)-unicast
	\s+redistribute
	\s+(?P<proto>\S+)
	\s+metric
	- \s+(?P<val>\S+)
	- *$""",
	+ \s+(?P<val>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_af_redistribute,
	"remval": _tmplt_bgp_af_redistribute_delete,
	"compval": "address_family.redistribute.metric",
	"result": {
	"as_number": "{{ as_num }}",
	"address_family": {
	"{{ afi }}": {
	"afi": "{{ afi }}",
	"redistribute": [
	{
	"protocol": "{{ proto }}",
	"metric": "{{ val\|int }}",
	},
	],
	},
	},
	},
	},
	{
	"name": "redistribute.route_map",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+address-family
	\s+(?P<afi>\S+)-unicast
	\s+redistribute
	\s+(?P<proto>\S+)
	\s+route-map
	- \s+(?P<map>\S+)
	- *$""",
	+ \s+(?P<map>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_af_redistribute,
	"remval": _tmplt_bgp_af_redistribute_delete,
	"compval": "address_family.redistribute.route_map",
	"result": {
	"as_number": "{{ as_num }}",
	"address_family": {
	"{{ afi }}": {
	"afi": "{{ afi }}",
	"redistribute": [
	{
	"protocol": "{{ proto }}",
	"route_map": "{{ map }}",
	},
	],
	},
	},
	},
	},
	{
	"name": "redistribute.table",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+address-family
	\s+(?P<afi>\S+)-unicast
	\s+redistribute
	\s+table
	- \s+(?P<tab>\S+)
	- *$""",
	+ \s+(?P<tab>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_af_redistribute,
	"remval": _tmplt_bgp_af_redistribute_delete,
	"compval": "address_family.redistribute.table",
	"result": {
	"as_number": "{{ as_num }}",
	"address_family": {
	"{{ afi }}": {
	"afi": "{{ afi }}",
	"redistribute": [
	{
	"table": "{{ tab }}",
	},
	],
	},
	},
	},
	},
	{
	"name": "neighbors",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+neighbor
	\s+(?P<address>\S+)
	\s+address-family
	*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp {{ as_number }} neighbor {{ neighbors.neighbor_address }} address-family",
	"compval": "neighbors",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbors": {
	"{{ address }}": {
	"neighbor_address": "{{ address }}",
	},
	},
	},
	},
	{
	"name": "neighbors.address_family",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+neighbor
	\s+(?P<address>\S+)
	\s+address-family
	\s+(?P<afi>\S+)-unicast
	*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp {{ as_number }} neighbor {{ neighbors.neighbor_address }} address-family {{ neighbors.address_family.afi }}-unicast",
	"compval": "neighbors",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbors": {
	"{{ address }}": {
	"neighbor_address": "{{ address }}",
	"address_family": {
	"{{ afi }}": {
	"afi": "{{ afi }}",
	},
	},
	},
	},
	},
	},
	{
	"name": "neighbors.allowas_in",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+neighbor
	\s+(?P<address>\S+)
	\s+address-family
	\s+(?P<afi>\S+)-unicast
	\s+allowas-in
	\s+number
	- \s+(?P<num>\S+)
	- *$""",
	+ \s+(?P<num>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_af_neighbor,
	"remval": _tmplt_bgp_af_neighbor_delete,
	"compval": "neighbors.address_family.allowas_in",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbors": {
	"{{ address }}": {
	"neighbor_address": "{{ address }}",
	"address_family": {
	"{{ afi }}": {
	"afi": "{{ afi }}",
	"allowas_in": "{{ num }}",
	},
	},
	},
	},
	},
	},
	{
	"name": "neighbors.as_override",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+neighbor
	\s+(?P<address>\S+)
	\s+address-family
	\s+(?P<afi>\S+)-unicast
	\s+as-override
	*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_af_neighbor,
	"remval": _tmplt_bgp_af_neighbor_delete,
	"compval": "neighbors.address_family.as_override",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbors": {
	"{{ address }}": {
	"neighbor_address": "{{ address }}",
	"address_family": {
	"{{ afi }}": {
	"afi": "{{ afi }}",
	"as_override": "{{ True }}",
	},
	},
	},
	},
	},
	},
	{
	"name": "neighbors.attribute_unchanged.as_path",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+neighbor
	\s+(?P<address>\S+)
	\s+address-family
	\s+(?P<afi>\S+)-unicast
	\s+attribute-unchanged
	\s+(?P<val>as-path)
	*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_af_neighbor_attribute,
	"remval": _tmplt_bgp_af_neighbor_delete,
	"compval": "neighbors.address_family.attribute_unchanged.as_path",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbors": {
	"{{ address }}": {
	"neighbor_address": "{{ address }}",
	"address_family": {
	"{{ afi }}": {
	"afi": "{{ afi }}",
	"attribute_unchanged": {
	"as_path": "{{ True }}",
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "neighbors.attribute_unchanged.med",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+neighbor
	\s+(?P<address>\S+)
	\s+address-family
	\s+(?P<afi>\S+)-unicast
	\s+attribute-unchanged
	\s+(?P<val>med)
	*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_af_neighbor_attribute,
	"remval": _tmplt_bgp_af_neighbor_delete,
	"compval": "neighbors.address_family.attribute_unchanged.med",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbors": {
	"{{ address }}": {
	"neighbor_address": "{{ address }}",
	"address_family": {
	"{{ afi }}": {
	"afi": "{{ afi }}",
	"attribute_unchanged": {
	"med": "{{ True }}",
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "neighbors.attribute_unchanged.next_hop",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+neighbor
	\s+(?P<address>\S+)
	\s+address-family
	\s+(?P<afi>\S+)-unicast
	\s+attribute-unchanged
	\s+(?P<val>next-hop)
	*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_af_neighbor_attribute,
	"remval": _tmplt_bgp_af_neighbor_delete,
	"compval": "neighbors.address_family.attribute_unchanged.next_hop",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbors": {
	"{{ address }}": {
	"neighbor_address": "{{ address }}",
	"address_family": {
	"{{ afi }}": {
	"afi": "{{ afi }}",
	"attribute_unchanged": {
	"next_hop": "{{ True }}",
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "neighbors.capability_dynamic",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+neighbor
	\s+(?P<address>\S+)
	\s+address-family
	\s+(?P<afi>\S+)-unicast
	\s+capability
	\s+dynamic
	*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_af_neighbor,
	"remval": _tmplt_bgp_af_neighbor_delete,
	"compval": "neighbors.address_family.capability.dynamic",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbors": {
	"{{ address }}": {
	"neighbor_address": "{{ address }}",
	"address_family": {
	"{{ afi }}": {
	"afi": "{{ afi }}",
	"capability": {
	"dynamic": "{{ true }}",
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "neighbors.capability_orf",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+neighbor
	\s+(?P<address>\S+)
	\s+address-family
	\s+(?P<afi>\S+)-unicast
	\s+capability
	\s+prefix-list
	- \s+(?P<orf>\S+)
	- *$""",
	+ \s+(?P<orf>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_af_neighbor,
	"remval": _tmplt_bgp_af_neighbor_delete,
	"compval": "neighbors.address_family.capability.orf",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbors": {
	"{{ address }}": {
	"neighbor_address": "{{ address }}",
	"address_family": {
	"{{ afi }}": {
	"afi": "{{ afi }}",
	"capability": {
	"orf": "{{ orf }}",
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "neighbors.default_originate",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+neighbor
	\s+(?P<address>\S+)
	\s+address-family
	\s+(?P<afi>\S+)-unicast
	\s+default-originate
	\s+route-map
	- \s+(?P<map>\S+)
	- *$""",
	+ \s+(?P<map>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_af_neighbor,
	"remval": _tmplt_bgp_af_neighbor_delete,
	"compval": "neighbors.address_family.default_originate",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbors": {
	"{{ address }}": {
	"neighbor_address": "{{ address }}",
	"address_family": {
	"{{ afi }}": {
	"afi": "{{ afi }}",
	"default_originate": "{{ map }}",
	},
	},
	},
	},
	},
	},
	{
	"name": "neighbors.distribute_list",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+neighbor
	\s+(?P<address>\S+)
	\s+address-family
	\s+(?P<afi>\S+)-unicast
	\s+distribute-list
	\s+(?P<action>export\|import)
	\s+(?P<list>\d+)
	*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_af_neighbor_distribute_list,
	"remval": _tmplt_bgp_af_neighbor_delete,
	"compval": "neighbors.address_family.distribute_list",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbors": {
	"{{ address }}": {
	"neighbor_address": "{{ address }}",
	"address_family": {
	"{{ afi }}": {
	"afi": "{{ afi }}",
	"distribute_list": [
	{
	"action": "{{ action }}",
	"acl": "{{ list }}",
	},
	],
	},
	},
	},
	},
	},
	},
	{
	"name": "neighbors.prefix_list",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+neighbor
	\s+(?P<address>\S+)
	\s+address-family
	\s+(?P<afi>\S+)-unicast
	\s+prefix-list
	\s+(?P<action>export\|import)
	- \s+(?P<list>\S+)
	- *$""",
	+ \s+(?P<list>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_af_neighbor_prefix_list,
	"remval": _tmplt_bgp_af_neighbor_delete,
	"compval": "neighbors.address_family.prefix_list",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbors": {
	"{{ address }}": {
	"neighbor_address": "{{ address }}",
	"address_family": {
	"{{ afi }}": {
	"afi": "{{ afi }}",
	"prefix_list": [
	{
	"action": "{{ action }}",
	"prefix_list": "{{ list }}",
	},
	],
	},
	},
	},
	},
	},
	},
	{
	"name": "neighbors.filter_list",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+neighbor
	\s+(?P<address>\S+)
	\s+address-family
	\s+(?P<afi>\S+)-unicast
	\s+filter-list
	\s+(?P<action>export\|import)
	- \s+(?P<list>\S+)
	- *$""",
	+ \s+(?P<list>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_af_neighbor_filter_list,
	"remval": _tmplt_bgp_af_neighbor_delete,
	"compval": "neighbors.address_family.filter_list",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbors": {
	"{{ address }}": {
	"neighbor_address": "{{ address }}",
	"address_family": {
	"{{ afi }}": {
	"afi": "{{ afi }}",
	"filter_list": [
	{
	"action": "{{ action }}",
	"path_list": "{{ list }}",
	},
	],
	},
	},
	},
	},
	},
	},
	{
	"name": "neighbors.maximum_prefix",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+neighbor
	\s+(?P<address>\S+)
	\s+address-family
	\s+(?P<afi>\S+)-unicast
	\s+maximum-prefix
	- \s+(?P<num>\S+)
	- *$""",
	+ \s+(?P<num>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_af_neighbor,
	"remval": _tmplt_bgp_af_neighbor_delete,
	"compval": "neighbors.address_family.maximum_prefix",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbors": {
	"{{ address }}": {
	"neighbor_address": "{{ address }}",
	"address_family": {
	"{{ afi }}": {
	"afi": "{{ afi }}",
	"maximum_prefix": "{{ num }}",
	},
	},
	},
	},
	},
	},
	{
	"name": "neighbors.nexthop_local",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+neighbor
	\s+(?P<address>\S+)
	\s+address-family
	\s+(?P<afi>\S+)-unicast
	\s+nexthop-local
	*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_af_neighbor,
	"remval": _tmplt_bgp_af_neighbor_delete,
	"compval": "neighbors.address_family.nexthop_local",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbors": {
	"{{ address }}": {
	"neighbor_address": "{{ address }}",
	"address_family": {
	"{{ afi }}": {
	"afi": "{{ afi }}",
	"nexthop_local": "{{ True }}",
	},
	},
	},
	},
	},
	},
	{
	"name": "neighbors.nexthop_self",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+neighbor
	\s+(?P<address>\S+)
	\s+address-family
	\s+(?P<afi>\S+)-unicast
	\s+nexthop-self
	*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_af_neighbor,
	"remval": _tmplt_bgp_af_neighbor_delete,
	"compval": "neighbors.address_family.nexthop_self",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbors": {
	"{{ address }}": {
	"neighbor_address": "{{ address }}",
	"address_family": {
	"{{ afi }}": {
	"afi": "{{ afi }}",
	"nexthop_self": "{{ True }}",
	},
	},
	},
	},
	},
	},
	{
	"name": "neighbors.peer_group",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+neighbor
	\s+(?P<address>\S+)
	\s+address-family
	\s+(?P<afi>\S+)-unicast
	\s+peer-group
	- \s+(?P<name>\S+)
	- *$""",
	+ \s+(?P<name>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_af_neighbor,
	"remval": _tmplt_bgp_af_neighbor_delete,
	"compval": "neighbors.address_family.peer_group",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbors": {
	"{{ address }}": {
	"neighbor_address": "{{ address }}",
	"address_family": {
	"{{ afi }}": {
	"afi": "{{ afi }}",
	"peer_group": "{{ name }}",
	},
	},
	},
	},
	},
	},
	{
	"name": "neighbors.remove_private_as",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+neighbor
	\s+(?P<address>\S+)
	\s+address-family
	\s+(?P<afi>\S+)-unicast
	\s+remove-private-as
	*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_af_neighbor,
	"remval": _tmplt_bgp_af_neighbor_delete,
	"compval": "neighbors.address_family.remove_private_as",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbors": {
	"{{ address }}": {
	"neighbor_address": "{{ address }}",
	"address_family": {
	"{{ afi }}": {
	"afi": "{{ afi }}",
	"remove_private_as": "{{ True }}",
	},
	},
	},
	},
	},
	},
	{
	"name": "neighbors.route_map",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+neighbor
	\s+(?P<address>\S+)
	\s+address-family
	\s+(?P<afi>\S+)-unicast
	\s+route-map
	\s+(?P<action>export\|import)
	- \s+(?P<map>\S+)
	- *$""",
	+ \s+(?P<map>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_af_neighbor_route_map,
	"remval": _tmplt_bgp_af_neighbor_delete,
	"compval": "neighbors.address_family.route_map",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbors": {
	"{{ address }}": {
	"neighbor_address": "{{ address }}",
	"address_family": {
	"{{ afi }}": {
	"afi": "{{ afi }}",
	"route_map": [
	{
	"action": "{{ action }}",
	"route_map": "{{ map }}",
	},
	],
	},
	},
	},
	},
	},
	},
	{
	"name": "neighbors.route_reflector_client",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+neighbor
	\s+(?P<address>\S+)
	\s+address-family
	\s+(?P<afi>\S+)-unicast
	\s+route-reflector-client
	*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_af_neighbor,
	"remval": _tmplt_bgp_af_neighbor_delete,
	"compval": "neighbors.address_family.route_reflector_client",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbors": {
	"{{ address }}": {
	"neighbor_address": "{{ address }}",
	"address_family": {
	"{{ afi }}": {
	"afi": "{{ afi }}",
	"route_reflector_client": "{{ True }}",
	},
	},
	},
	},
	},
	},
	{
	"name": "neighbors.route_server_client",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+neighbor
	\s+(?P<address>\S+)
	\s+address-family
	\s+(?P<afi>\S+)-unicast
	\s+route-server-client
	*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_af_neighbor,
	"remval": _tmplt_bgp_af_neighbor_delete,
	"compval": "neighbors.address_family.route_server_client",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbors": {
	"{{ address }}": {
	"neighbor_address": "{{ address }}",
	"address_family": {
	"{{ afi }}": {
	"afi": "{{ afi }}",
	"route_server_client": "{{ True }}",
	},
	},
	},
	},
	},
	},
	{
	"name": "neighbors.soft_reconfiguration",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+neighbor
	\s+(?P<address>\S+)
	\s+address-family
	\s+(?P<afi>\S+)-unicast
	\s+soft-reconfiguration
	\s+inbound
	*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_af_neighbor,
	"remval": _tmplt_bgp_af_neighbor_delete,
	"compval": "neighbors.address_family.soft_reconfiguration",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbors": {
	"{{ address }}": {
	"neighbor_address": "{{ address }}",
	"address_family": {
	"{{ afi }}": {
	"afi": "{{ afi }}",
	"soft_reconfiguration": "{{ True }}",
	},
	},
	},
	},
	},
	},
	{
	"name": "neighbors.unsuppress_map",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+neighbor
	\s+(?P<address>\S+)
	\s+address-family
	\s+(?P<afi>\S+)-unicast
	\s+unsuppress-map
	- \s+(?P<map>\S+)
	- *$""",
	+ \s+(?P<map>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_af_neighbor,
	"remval": _tmplt_bgp_af_neighbor_delete,
	"compval": "neighbors.address_family.unsuppress_map",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbors": {
	"{{ address }}": {
	"neighbor_address": "{{ address }}",
	"address_family": {
	"{{ afi }}": {
	"afi": "{{ afi }}",
	"unsuppress_map": "{{ map }}",
	},
	},
	},
	},
	},
	},
	{
	"name": "neighbors.weight",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+neighbor
	\s+(?P<address>\S+)
	\s+address-family
	\s+(?P<afi>\S+)-unicast
	\s+weight
	- \s+(?P<num>\S+)
	- *$""",
	+ \s+(?P<num>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_af_neighbor,
	"remval": _tmplt_bgp_af_neighbor_delete,
	"compval": "neighbors.address_family.weight",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbors": {
	"{{ address }}": {
	"neighbor_address": "{{ address }}",
	"address_family": {
	"{{ afi }}": {
	"afi": "{{ afi }}",
	"weight": "{{ num }}",
	},
	},
	},
	},
	},
	},
	]
	# fmt: on
	diff --git a/plugins/module_utils/network/vyos/rm_templates/bgp_address_family_14.py b/plugins/module_utils/network/vyos/rm_templates/bgp_address_family_14.py
	index fd4c9de9..09cd41a7 100644
	--- a/plugins/module_utils/network/vyos/rm_templates/bgp_address_family_14.py
	+++ b/plugins/module_utils/network/vyos/rm_templates/bgp_address_family_14.py
	@@ -1,1433 +1,1418 @@
	# -- coding: utf-8 --
	# Copyright 2021 Red Hat
	# GNU General Public License v3.0+
	# (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)

	from __future__ import absolute_import, division, print_function


	__metaclass__ = type

	"""
	The Bgp_address_family parser templates file. This contains
	a list of parser definitions and associated functions that
	facilitates both facts gathering and native command generation for
	the given network resource.
	"""

	import re

	from ansible_collections.ansible.netcommon.plugins.module_utils.network.common.rm_base.network_template import (
	NetworkTemplate,
	)


	def _tmplt_bgp_af_aggregate_address(config_data):
	afi = config_data["address_family"]["afi"] + "-unicast"
	command = "protocols bgp address-family ".format(**config_data)
	config_data = config_data["address_family"]
	if config_data["aggregate_address"].get("as_set"):
	command += afi + " aggregate-address {prefix} as-set".format(
	**config_data["aggregate_address"],
	)
	if config_data["aggregate_address"].get("summary_only"):
	command += afi + " aggregate-address {prefix} summary-only".format(
	**config_data["aggregate_address"],
	)
	return command


	def _tmplt_bgp_af_redistribute(config_data):
	afi = config_data["address_family"]["afi"] + "-unicast"
	command = "protocols bgp address-family ".format(**config_data)
	config_data = config_data["address_family"]["redistribute"]
	command += afi + " redistribute {protocol}".format(**config_data)
	if config_data.get("metric"):
	command += " metric {metric}".format(**config_data)
	elif config_data.get("route_map"):
	command += " route-map {route_map}".format(**config_data)
	elif config_data.get("table"):
	command += " table {table}".format(**config_data)
	return command


	def _tmplt_bgp_af_redistribute_delete(config_data):
	afi = config_data["address_family"]["afi"] + "-unicast"
	command = "protocols bgp address-family ".format(**config_data)
	config_data = config_data["address_family"]["redistribute"]
	command += afi + " redistribute {protocol}".format(**config_data)
	if config_data.get("metric"):
	command += " metric"
	elif config_data.get("route_map"):
	command += " route-map"
	elif config_data.get("table"):
	command += " table"
	return command


	def _tmplt_bgp_af_neighbor_distribute_list(config_data):
	command = []
	afi = config_data["neighbors"]["address_family"]["afi"] + "-unicast"
	cmd = "protocols bgp neighbor ".format(**config_data)
	cmd += "{neighbor_address} address-family ".format(**config_data["neighbors"])
	config_data = config_data["neighbors"]["address_family"]
	for list_el in config_data["distribute_list"]:
	command.append(
	cmd + afi + " distribute-list " + list_el["action"] + " " + str(list_el["acl"]),
	)
	return command


	def _tmplt_bgp_af_neighbor_route_map(config_data):
	command = []
	afi = config_data["neighbors"]["address_family"]["afi"] + "-unicast"
	cmd = "protocols bgp neighbor ".format(**config_data)
	cmd += "{neighbor_address} address-family ".format(**config_data["neighbors"])
	config_data = config_data["neighbors"]["address_family"]
	for list_el in config_data["route_map"]:
	command.append(
	cmd + afi + " route-map " + list_el["action"] + " " + str(list_el["route_map"]),
	)
	return command


	def _tmplt_bgp_af_neighbor_prefix_list(config_data):
	command = []
	afi = config_data["neighbors"]["address_family"]["afi"] + "-unicast"
	cmd = "protocols bgp neighbor ".format(**config_data)
	cmd += "{neighbor_address} address-family ".format(**config_data["neighbors"])
	config_data = config_data["neighbors"]["address_family"]
	for list_el in config_data["prefix_list"]:
	command.append(
	cmd + afi + " prefix-list " + list_el["action"] + " " + str(list_el["prefix_list"]),
	)
	return command


	def _tmplt_bgp_af_neighbor_filter_list(config_data):
	command = []
	afi = config_data["neighbors"]["address_family"]["afi"] + "-unicast"
	cmd = "protocols bgp neighbor ".format(**config_data)
	cmd += "{neighbor_address} address-family ".format(**config_data["neighbors"])
	config_data = config_data["neighbors"]["address_family"]
	for list_el in config_data["filter_list"]:
	command.append(
	cmd + afi + " filter-list " + list_el["action"] + " " + str(list_el["path_list"]),
	)
	return command


	def _tmplt_bgp_af_neighbor_attribute(config_data):
	command = []
	afi = config_data["neighbors"]["address_family"]["afi"] + "-unicast"
	cmd = "protocols bgp neighbor ".format(**config_data)
	cmd += "{neighbor_address} address-family ".format(**config_data["neighbors"])
	config_data = config_data["neighbors"]["address_family"]
	for k in config_data["attribute_unchanged"].keys():
	if config_data["attribute_unchanged"][k]:
	k = re.sub("_", "-", k)
	c = cmd + afi + " attribute-unchanged " + k
	command.append(c)
	return command


	def _tmplt_bgp_af_neighbor_delete(config_data):
	afi = config_data["neighbors"]["address_family"]["afi"] + "-unicast"
	command = "protocols bgp ".format(**config_data)
	command += (
	"neighbor {neighbor_address} address-family ".format(**config_data["neighbors"]) + afi
	)
	config_data = config_data["neighbors"]["address_family"]
	if config_data.get("allowas_in"):
	command += " allowas-in"
	elif config_data.get("as_override"):
	command += " as-override"
	elif config_data.get("attribute_unchanged"):
	command += " attribute-unchanged"
	elif config_data.get("capability"):
	command += " capability"
	elif config_data.get("default_originate"):
	command += " default-originate"
	elif config_data.get("maximum_prefix"):
	command += " maximum-prefix"
	elif config_data.get("nexthop_local"):
	command += " nexthop-local"
	elif config_data.get("nexthop_self"):
	command += " nexthop-self"
	elif config_data.get("peer_group"):
	command += " peer-group"
	elif config_data.get("remote_private_as"):
	command += " remote-private-as"
	elif config_data.get("route_reflector_client"):
	command += " route-reflector-client"
	elif config_data.get("route_server_client"):
	command += " route-server-client"
	elif config_data.get("soft_reconfiguration"):
	command += " soft-reconfiguration"
	elif config_data.get("unsuppress_map"):
	command += " unsuppress-map"
	elif config_data.get("weight"):
	command += " weight"
	elif config_data.get("filter_list"):
	command += " filter-list"
	elif config_data.get("prefix_list"):
	command += " prefix-list"
	elif config_data.get("distribute_list"):
	command += " distribute-list"
	elif config_data.get("route_map"):
	command += " route-map"
	return command


	def _tmplt_bgp_af_neighbor(config_data):
	afi = config_data["neighbors"]["address_family"]["afi"] + "-unicast"
	command = "protocols bgp ".format(**config_data)
	command += (
	"neighbor {neighbor_address} address-family ".format(**config_data["neighbors"]) + afi
	)
	config_data = config_data["neighbors"]["address_family"]
	if config_data.get("allowas_in"):
	command += " allowas-in number {allowas_in}".format(**config_data)
	elif config_data.get("as_override"):
	command += " as-override"
	elif config_data.get("capability"):
	command += " capability "
	if config_data["capability"].get("dynamic"):
	command += "dynamic"
	elif config_data["capability"].get("orf"):
	command += " prefix-list {orf}".format(**config_data["capability"])
	elif config_data.get("default_originate"):
	command += " default-originate route-map {default_originate}".format(**config_data)
	elif config_data.get("maximum_prefix"):
	command += " maximum-prefix {maximum_prefix}".format(**config_data)
	elif config_data.get("nexthop_local"):
	command += " nexthop-local"
	elif config_data.get("nexthop_self"):
	command += " nexthop-self"
	elif config_data.get("peer_group"):
	command += " peer-group {peer_group}".format(**config_data)
	elif config_data.get("remote_private_as"):
	command += " remote-private-as"
	elif config_data.get("route_reflector_client"):
	command += " route-reflector-client"
	elif config_data.get("route_server_client"):
	command += " route-server-client"
	elif config_data.get("soft_reconfiguration"):
	command += " soft-reconfiguration inbound"
	elif config_data.get("unsuppress_map"):
	command += " unsuppress-map {unsuppress_map}".format(**config_data)
	elif config_data.get("weight"):
	command += " weight {weight}".format(**config_data)
	return command


	def _tmplt_bgp_af_network(config_data):
	afi = config_data["address_family"]["afi"] + "-unicast"
	command = "protocols bgp address-family ".format(**config_data)
	config_data = config_data["address_family"]["networks"]
	command += afi + " network {prefix}".format(**config_data)
	if config_data.get("backdoor"):
	command += " backdoor"
	elif config_data.get("route_map"):
	command += " route-map {route_map}".format(**config_data)
	return command


	def _tmplt_bgp_af_network_delete(config_data):
	afi = config_data["address_family"]["afi"] + "-unicast"
	command = "protocols bgp address-family ".format(**config_data)
	config_data = config_data["address_family"]["networks"]
	command += afi + " network {prefix}".format(**config_data)
	if config_data.get("backdoor"):
	command += " backdoor"
	elif config_data.get("route_map"):
	command += " route_map"
	return command


	class Bgp_address_familyTemplate14(NetworkTemplate):
	def __init__(self, lines=None, module=None):
	prefix = {"set": "set", "remove": "delete"}
	super(Bgp_address_familyTemplate14, self).__init__(
	lines=lines,
	tmplt=self,
	prefix=prefix,
	module=module,
	)

	# fmt: off
	PARSERS = [
	{
	"name": "system_as",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+system-as
	\s+(?P<as_num>\d+)
	*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp system-as {{ as_number }}",
	"compval": "as_number",
	"result": {
	"as_number": "{{ as_num }}",
	},
	},
	{
	"name": "address_family",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+address-family
	\s+(?P<afi>\S+)-unicast
	*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp address-family {{ address_family.afi }}-unicast",
	"compval": "as_number",
	"result": {
	"as_number": "{{ as_num }}",
	"address_family": {
	"{{ afi }}": {
	"afi": "{{ afi }}",
	},
	},
	},
	},
	{
	"name": "aggregate_address",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+address-family
	\s+(?P<afi>\S+)-unicast
	\s+aggregate-address
	\s+(?P<address>\S+)
	- \s(?P<as_set>as-set)
	- \s(?P<summary_only>summary-only)
	+ \s*(?P<as_set>as-set)?
	+ \s*(?P<summary_only>summary-only)?
	$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_af_aggregate_address,
	"remval": "protocols bgp address-family {{ address_family.afi }}-unicast aggregate-address" +
	" {{ address_family.aggregate_address.prefix }}",
	"compval": "address_family.aggregate_address",
	"result": {
	"as_number": "{{ as_num }}",
	"address_family": {
	"{{ afi }}": {
	"afi": "{{ afi }}",
	"aggregate_address": [
	{
	"prefix": "{{ address }}",
	"as_set": "{{ True if as_set is defined }}",
	"summary_only": "{{ True if summary_only is defined }}",
	},
	],
	},
	},
	},
	},
	{
	"name": "network",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+address-family
	\s+(?P<afi>\S+)-unicast
	\s+network
	\s+(?P<address>\S+)
	$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_af_network,
	"remval": "protocols bgp address-family {{ address_family.afi }}-unicast network {{ address_family.networks.prefix }}",
	"compval": "address_family.networks.prefix",
	"result": {
	"as_number": "{{ as_num }}",
	"address_family": {
	"{{ afi }}": {
	"afi": "{{ afi }}",
	"networks": [
	{
	"prefix": "{{ address }}",
	},
	],
	},
	},
	},
	},
	{
	"name": "network.backdoor",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+address-family
	\s+(?P<afi>\S+)-unicast
	\s+network
	\s+(?P<address>\S+)
	\s+backdoor
	*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_af_network,
	"remval": _tmplt_bgp_af_network_delete,
	"compval": "address_family.networks.backdoor",
	"result": {
	"as_number": "{{ as_num }}",
	"address_family": {
	"{{ afi }}": {
	"afi": "{{ afi }}",
	"networks": [
	{
	"prefix": "{{ address }}",
	"backdoor": "{{ True }}",
	},
	],
	},
	},
	},
	},
	{
	"name": "network.path_limit",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+address-family
	\s+(?P<afi>\S+)-unicast
	\s+network
	\s+(?P<address>\S+)
	\s+path-limit
	- \s+(?P<limit>\S+)
	- *$""",
	+ \s+(?P<limit>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_af_network,
	"remval": _tmplt_bgp_af_network_delete,
	"compval": "address_family.networks.path_limit",
	"result": {
	"as_number": "{{ as_num }}",
	"address_family": {
	"{{ afi }}": {
	"afi": "{{ afi }}",
	"networks": [
	{
	"prefix": "{{ address }}",
	"path_limit": "{{ limit\|int }}",
	},
	],
	},
	},
	},
	},
	{
	"name": "network.route_map",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+address-family
	\s+(?P<afi>\S+)-unicast
	\s+network
	\s+(?P<address>\S+)
	\s+route-map
	- \s+(?P<map>\S+)
	- *$""",
	+ \s+(?P<map>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_af_network,
	"remval": _tmplt_bgp_af_network_delete,
	"compval": "address_family.networks.route_map",
	"result": {
	"as_number": "{{ as_num }}",
	"address_family": {
	"{{ afi }}": {
	"afi": "{{ afi }}",
	"networks": [
	{
	"prefix": "{{ address }}",
	"route_map": "{{ map }}",
	},
	],
	},
	},
	},
	},
	{
	"name": "redistribute",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+address-family
	\s+(?P<afi>\S+)-unicast
	\s+redistribute
	\s+(?P<proto>\S+)
	$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_af_redistribute,
	"remval": "protocols bgp address-family {{ address_family.afi }}-unicast redistribute {{ address_family.redistribute.protocol }}",
	"compval": "address_family.redistribute.protocol",
	"result": {
	"as_number": "{{ as_num }}",
	"address_family": {
	"{{ afi }}": {
	"afi": "{{ afi }}",
	"redistribute": [
	{
	"protocol": "{{ proto }}",
	},
	],
	},
	},
	},
	},
	{
	"name": "redistribute.metric",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+address-family
	\s+(?P<afi>\S+)-unicast
	\s+redistribute
	\s+(?P<proto>\S+)
	- \s+metric\s+(?P<val>\S+)
	- *$""",
	+ \s+metric\s+(?P<val>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_af_redistribute,
	"remval": _tmplt_bgp_af_redistribute_delete,
	"compval": "address_family.redistribute.metric",
	"result": {
	"as_number": "{{ as_num }}",
	"address_family": {
	"{{ afi }}": {
	"afi": "{{ afi }}",
	"redistribute": [
	{
	"protocol": "{{ proto }}",
	"metric": "{{ val }}",
	},
	],
	},
	},
	},
	},
	{
	"name": "redistribute.route_map",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+address-family
	\s+(?P<afi>\S+)-unicast
	\s+redistribute
	\s+(?P<proto>\S+)
	\s+route-map
	- \s+(?P<map>\S+)
	- *$""",
	+ \s+(?P<map>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_af_redistribute,
	"remval": _tmplt_bgp_af_redistribute_delete,
	"compval": "address_family.redistribute.route_map",
	"result": {
	"as_number": "{{ as_num }}",
	"address_family": {
	"{{ afi }}": {
	"afi": "{{ afi }}",
	"redistribute": [
	{
	"protocol": "{{ proto }}",
	"route_map": "{{ map }}",
	},
	],
	},
	},
	},
	},
	{
	"name": "redistribute.table",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+address-family
	\s+(?P<afi>\S+)-unicast
	\s+redistribute
	\s+table
	- \s+(?P<tab>\S+)
	- *$""",
	+ \s+(?P<tab>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_af_redistribute,
	"remval": _tmplt_bgp_af_redistribute_delete,
	"compval": "address_family.redistribute.table",
	"result": {
	"as_number": "{{ as_num }}",
	"address_family": {
	"{{ afi }}": {
	"afi": "{{ afi }}",
	"redistribute": [
	{
	"table": "{{ tab }}",
	},
	],
	},
	},
	},
	},
	{
	"name": "neighbors",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+neighbor
	\s+(?P<address>\S+)
	\s+address-family
	*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp neighbor {{ neighbors.neighbor_address }} address-family",
	"compval": "neighbors",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbors": {
	"{{ address }}": {
	"neighbor_address": "{{ address }}",
	},
	},
	},
	},
	{
	"name": "neighbors.address_family",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+neighbor
	\s+(?P<address>\S+)
	\s+address-family
	\s+(?P<afi>\S+)-unicast
	*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp neighbor {{ neighbors.neighbor_address }} address-family {{ neighbors.address_family.afi }}-unicast",
	"compval": "neighbors",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbors": {
	"{{ address }}": {
	"neighbor_address": "{{ address }}",
	"address_family": {
	"{{ afi }}": {
	"afi": "{{ afi }}",
	},
	},
	},
	},
	},
	},
	{
	"name": "neighbors.allowas_in",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+neighbor
	\s+(?P<address>\S+)
	\s+address-family
	\s+(?P<afi>\S+)-unicast
	\s+allowas-in
	\s+number
	- \s+(?P<num>\S+)
	- *$""",
	+ \s+(?P<num>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_af_neighbor,
	"remval": _tmplt_bgp_af_neighbor_delete,
	"compval": "neighbors.address_family.allowas_in",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbors": {
	"{{ address }}": {
	"neighbor_address": "{{ address }}",
	"address_family": {
	"{{ afi }}": {
	"afi": "{{ afi }}",
	"allowas_in": "{{ num }}",
	},
	},
	},
	},
	},
	},
	{
	"name": "neighbors.as_override",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+neighbor
	\s+(?P<address>\S+)
	\s+address-family
	\s+(?P<afi>\S+)-unicast
	\s+as-override
	*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_af_neighbor,
	"remval": _tmplt_bgp_af_neighbor_delete,
	"compval": "neighbors.address_family.as_override",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbors": {
	"{{ address }}": {
	"neighbor_address": "{{ address }}",
	"address_family": {
	"{{ afi }}": {
	"afi": "{{ afi }}",
	"as_override": "{{ True }}",
	},
	},
	},
	},
	},
	},
	{
	"name": "neighbors.attribute_unchanged.as_path",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+neighbor
	\s+(?P<address>\S+)
	\s+address-family
	\s+(?P<afi>\S+)-unicast
	\s+attribute-unchanged
	\s+(?P<val>as-path)
	*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_af_neighbor_attribute,
	"remval": _tmplt_bgp_af_neighbor_delete,
	"compval": "neighbors.address_family.attribute_unchanged.as_path",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbors": {
	"{{ address }}": {
	"neighbor_address": "{{ address }}",
	"address_family": {
	"{{ afi }}": {
	"afi": "{{ afi }}",
	"attribute_unchanged": {
	"as_path": "{{ True }}",
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "neighbors.attribute_unchanged.med",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+neighbor
	\s+(?P<address>\S+)
	\s+address-family
	\s+(?P<afi>\S+)-unicast
	\s+attribute-unchanged
	\s+(?P<val>med)
	*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_af_neighbor_attribute,
	"remval": _tmplt_bgp_af_neighbor_delete,
	"compval": "neighbors.address_family.attribute_unchanged.med",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbors": {
	"{{ address }}": {
	"neighbor_address": "{{ address }}",
	"address_family": {
	"{{ afi }}": {
	"afi": "{{ afi }}",
	"attribute_unchanged": {
	"med": "{{ True }}",
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "neighbors.attribute_unchanged.next_hop",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+neighbor
	\s+(?P<address>\S+)
	\s+address-family
	\s+(?P<afi>\S+)-unicast
	\s+attribute-unchanged
	\s+(?P<val>next-hop)
	*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_af_neighbor_attribute,
	"remval": _tmplt_bgp_af_neighbor_delete,
	"compval": "neighbors.address_family.attribute_unchanged.next_hop",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbors": {
	"{{ address }}": {
	"neighbor_address": "{{ address }}",
	"address_family": {
	"{{ afi }}": {
	"afi": "{{ afi }}",
	"attribute_unchanged": {
	"next_hop": "{{ True }}",
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "neighbors.capability_dynamic",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+neighbor
	\s+(?P<address>\S+)
	\s+address-family
	\s+(?P<afi>\S+)-unicast
	\s+capability
	\s+dynamic
	*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_af_neighbor,
	"remval": _tmplt_bgp_af_neighbor_delete,
	"compval": "neighbors.address_family.capability.dynamic",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbors": {
	"{{ address }}": {
	"neighbor_address": "{{ address }}",
	"address_family": {
	"{{ afi }}": {
	"afi": "{{ afi }}",
	"capability": {
	"dynamic": "{{ true }}",
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "neighbors.capability_orf",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+neighbor
	\s+(?P<address>\S+)
	\s+address-family
	\s+(?P<afi>\S+)-unicast
	\s+capability
	\s+prefix-list
	- \s+(?P<orf>\S+)
	- *$""",
	+ \s+(?P<orf>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_af_neighbor,
	"remval": _tmplt_bgp_af_neighbor_delete,
	"compval": "neighbors.address_family.capability.orf",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbors": {
	"{{ address }}": {
	"neighbor_address": "{{ address }}",
	"address_family": {
	"{{ afi }}": {
	"afi": "{{ afi }}",
	"capability": {
	"orf": "{{ orf }}",
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "neighbors.default_originate",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+neighbor
	\s+(?P<address>\S+)
	\s+address-family
	\s+(?P<afi>\S+)-unicast
	\s+default-originate
	\s+route-map
	- \s+(?P<map>\S+)
	- *$""",
	+ \s+(?P<map>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_af_neighbor,
	"remval": _tmplt_bgp_af_neighbor_delete,
	"compval": "neighbors.address_family.default_originate",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbors": {
	"{{ address }}": {
	"neighbor_address": "{{ address }}",
	"address_family": {
	"{{ afi }}": {
	"afi": "{{ afi }}",
	"default_originate": "{{ map }}",
	},
	},
	},
	},
	},
	},
	{
	"name": "neighbors.distribute_list",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+neighbor
	\s+(?P<address>\S+)
	\s+address-family
	\s+(?P<afi>\S+)-unicast
	\s+distribute-list
	\s+(?P<action>export\|import)
	\s+(?P<list>\d+)
	*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_af_neighbor_distribute_list,
	"remval": _tmplt_bgp_af_neighbor_delete,
	"compval": "neighbors.address_family.distribute_list",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbors": {
	"{{ address }}": {
	"neighbor_address": "{{ address }}",
	"address_family": {
	"{{ afi }}": {
	"afi": "{{ afi }}",
	"distribute_list": [
	{
	"action": "{{ action }}",
	"acl": "{{ list }}",
	},
	],
	},
	},
	},
	},
	},
	},
	{
	"name": "neighbors.prefix_list",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+neighbor
	\s+(?P<address>\S+)
	\s+address-family
	\s+(?P<afi>\S+)-unicast
	\s+prefix-list
	\s+(?P<action>export\|import)
	- \s+(?P<list>\S+)
	- *$""",
	+ \s+(?P<list>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_af_neighbor_prefix_list,
	"remval": _tmplt_bgp_af_neighbor_delete,
	"compval": "neighbors.address_family.prefix_list",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbors": {
	"{{ address }}": {
	"neighbor_address": "{{ address }}",
	"address_family": {
	"{{ afi }}": {
	"afi": "{{ afi }}",
	"prefix_list": [
	{
	"action": "{{ action }}",
	"prefix_list": "{{ list }}",
	},
	],
	},
	},
	},
	},
	},
	},
	{
	"name": "neighbors.filter_list",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+neighbor
	\s+(?P<address>\S+)
	\s+address-family
	\s+(?P<afi>\S+)-unicast
	\s+filter-list
	\s+(?P<action>export\|import)
	- \s+(?P<list>\S+)
	- *$""",
	+ \s+(?P<list>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_af_neighbor_filter_list,
	"remval": _tmplt_bgp_af_neighbor_delete,
	"compval": "neighbors.address_family.filter_list",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbors": {
	"{{ address }}": {
	"neighbor_address": "{{ address }}",
	"address_family": {
	"{{ afi }}": {
	"afi": "{{ afi }}",
	"filter_list": [
	{
	"action": "{{ action }}",
	"path_list": "{{ list }}",
	},
	],
	},
	},
	},
	},
	},
	},
	{
	"name": "neighbors.maximum_prefix",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+neighbor
	\s+(?P<address>\S+)
	\s+address-family
	\s+(?P<afi>\S+)-unicast
	\s+maximum-prefix
	- \s+(?P<num>\S+)
	- *$""",
	+ \s+(?P<num>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_af_neighbor,
	"remval": _tmplt_bgp_af_neighbor_delete,
	"compval": "neighbors.address_family.maximum_prefix",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbors": {
	"{{ address }}": {
	"neighbor_address": "{{ address }}",
	"address_family": {
	"{{ afi }}": {
	"afi": "{{ afi }}",
	"maximum_prefix": "{{ num }}",
	},
	},
	},
	},
	},
	},
	{
	"name": "neighbors.nexthop_local",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+neighbor
	\s+(?P<address>\S+)
	\s+address-family
	\s+(?P<afi>\S+)-unicast
	\s+nexthop-local
	*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_af_neighbor,
	"remval": _tmplt_bgp_af_neighbor_delete,
	"compval": "neighbors.address_family.nexthop_local",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbors": {
	"{{ address }}": {
	"neighbor_address": "{{ address }}",
	"address_family": {
	"{{ afi }}": {
	"afi": "{{ afi }}",
	"nexthop_local": "{{ True }}",
	},
	},
	},
	},
	},
	},
	{
	"name": "neighbors.nexthop_self",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+neighbor
	\s+(?P<address>\S+)
	\s+address-family
	\s+(?P<afi>\S+)-unicast
	\s+nexthop-self
	*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_af_neighbor,
	"remval": _tmplt_bgp_af_neighbor_delete,
	"compval": "neighbors.address_family.nexthop_self",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbors": {
	"{{ address }}": {
	"neighbor_address": "{{ address }}",
	"address_family": {
	"{{ afi }}": {
	"afi": "{{ afi }}",
	"nexthop_self": "{{ True }}",
	},
	},
	},
	},
	},
	},
	{
	"name": "neighbors.peer_group",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+neighbor
	\s+(?P<address>\S+)
	\s+address-family
	\s+(?P<afi>\S+)-unicast
	\s+peer-group
	- \s+(?P<name>\S+)
	- *$""",
	+ \s+(?P<name>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_af_neighbor,
	"remval": _tmplt_bgp_af_neighbor_delete,
	"compval": "neighbors.address_family.peer_group",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbors": {
	"{{ address }}": {
	"neighbor_address": "{{ address }}",
	"address_family": {
	"{{ afi }}": {
	"afi": "{{ afi }}",
	"peer_group": "{{ name }}",
	},
	},
	},
	},
	},
	},
	{
	"name": "neighbors.remove_private_as",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+neighbor
	\s+(?P<address>\S+)
	\s+address-family
	\s+(?P<afi>\S+)-unicast
	\s+remove-private-as
	*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_af_neighbor,
	"remval": _tmplt_bgp_af_neighbor_delete,
	"compval": "neighbors.address_family.remove_private_as",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbors": {
	"{{ address }}": {
	"neighbor_address": "{{ address }}",
	"address_family": {
	"{{ afi }}": {
	"afi": "{{ afi }}",
	"remove_private_as": "{{ True }}",
	},
	},
	},
	},
	},
	},
	{
	"name": "neighbors.route_map",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+neighbor
	\s+(?P<address>\S+)
	\s+address-family
	\s+(?P<afi>\S+)-unicast
	\s+route-map
	\s+(?P<action>export\|import)
	- \s+(?P<map>\S+)
	- *$""",
	+ \s+(?P<map>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_af_neighbor_route_map,
	"remval": _tmplt_bgp_af_neighbor_delete,
	"compval": "neighbors.address_family.route_map",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbors": {
	"{{ address }}": {
	"neighbor_address": "{{ address }}",
	"address_family": {
	"{{ afi }}": {
	"afi": "{{ afi }}",
	"route_map": [
	{
	"action": "{{ action }}",
	"route_map": "{{ map }}",
	},
	],
	},
	},
	},
	},
	},
	},
	{
	"name": "neighbors.route_reflector_client",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+neighbor
	\s+(?P<address>\S+)
	\s+address-family
	\s+(?P<afi>\S+)-unicast
	\s+route-reflector-client
	*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_af_neighbor,
	"remval": _tmplt_bgp_af_neighbor_delete,
	"compval": "neighbors.address_family.route_reflector_client",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbors": {
	"{{ address }}": {
	"neighbor_address": "{{ address }}",
	"address_family": {
	"{{ afi }}": {
	"afi": "{{ afi }}",
	"route_reflector_client": "{{ True }}",
	},
	},
	},
	},
	},
	},
	{
	"name": "neighbors.route_server_client",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+neighbor
	\s+(?P<address>\S+)
	\s+address-family
	\s+(?P<afi>\S+)-unicast
	\s+route-server-client
	*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_af_neighbor,
	"remval": _tmplt_bgp_af_neighbor_delete,
	"compval": "neighbors.address_family.route_server_client",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbors": {
	"{{ address }}": {
	"neighbor_address": "{{ address }}",
	"address_family": {
	"{{ afi }}": {
	"afi": "{{ afi }}",
	"route_server_client": "{{ True }}",
	},
	},
	},
	},
	},
	},
	{
	"name": "neighbors.soft_reconfiguration",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+neighbor
	\s+(?P<address>\S+)
	\s+address-family
	\s+(?P<afi>\S+)-unicast
	\s+soft-reconfiguration
	\s+inbound
	*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_af_neighbor,
	"remval": _tmplt_bgp_af_neighbor_delete,
	"compval": "neighbors.address_family.soft_reconfiguration",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbors": {
	"{{ address }}": {
	"neighbor_address": "{{ address }}",
	"address_family": {
	"{{ afi }}": {
	"afi": "{{ afi }}",
	"soft_reconfiguration": "{{ True }}",
	},
	},
	},
	},
	},
	},
	{
	"name": "neighbors.unsuppress_map",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+neighbor
	\s+(?P<address>\S+)
	\s+address-family
	\s+(?P<afi>\S+)-unicast
	\s+unsuppress-map
	- \s+(?P<map>\S+)
	- *$""",
	+ \s+(?P<map>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_af_neighbor,
	"remval": _tmplt_bgp_af_neighbor_delete,
	"compval": "neighbors.address_family.unsuppress_map",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbors": {
	"{{ address }}": {
	"neighbor_address": "{{ address }}",
	"address_family": {
	"{{ afi }}": {
	"afi": "{{ afi }}",
	"unsuppress_map": "{{ map }}",
	},
	},
	},
	},
	},
	},
	{
	"name": "neighbors.weight",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+neighbor
	\s+(?P<address>\S+)
	\s+address-family
	\s+(?P<afi>\S+)-unicast
	\s+weight
	- \s+(?P<num>\S+)
	- *$""",
	+ \s+(?P<num>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_af_neighbor,
	"remval": _tmplt_bgp_af_neighbor_delete,
	"compval": "neighbors.address_family.weight",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbors": {
	"{{ address }}": {
	"neighbor_address": "{{ address }}",
	"address_family": {
	"{{ afi }}": {
	"afi": "{{ afi }}",
	"weight": "{{ num }}",
	},
	},
	},
	},
	},
	},
	]
	# fmt: on
	diff --git a/plugins/module_utils/network/vyos/rm_templates/bgp_global.py b/plugins/module_utils/network/vyos/rm_templates/bgp_global.py
	index 8c2e2f55..03f6265b 100644
	--- a/plugins/module_utils/network/vyos/rm_templates/bgp_global.py
	+++ b/plugins/module_utils/network/vyos/rm_templates/bgp_global.py
	@@ -1,1859 +1,1828 @@
	# -- coding: utf-8 --
	# Copyright 2021 Red Hat
	# GNU General Public License v3.0+
	# (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)

	from __future__ import absolute_import, division, print_function


	__metaclass__ = type

	"""
	The Bgp_global parser templates file. This contains
	a list of parser definitions and associated functions that
	facilitates both facts gathering and native command generation for
	the given network resource.
	"""

	import re

	from ansible_collections.ansible.netcommon.plugins.module_utils.network.common.rm_base.network_template import (
	NetworkTemplate,
	)


	def _tmplt_bgp_params_confederation(config_data):
	command = []
	for list_el in config_data["bgp_params"]["confederation"]:
	for k, v in list_el.items():
	command.append(
	"protocols bgp {as_number} parameters confederation ".format(**config_data)
	+ k
	+ " "
	+ str(v),
	)

	return command


	def _tmplt_bgp_maximum_paths(config_data):
	command = []
	for list_el in config_data["maximum_paths"]:
	command.append(
	"protocols bgp {as_number} maximum-paths ".format(**config_data)
	+ list_el["path"]
	+ " "
	+ str(list_el["count"]),
	)
	return command


	def _tmplt_delete_bgp_maximum_paths(config_data):
	command = "protocols bgp {as_number} maximum-paths".format(**config_data)
	return command


	def _tmplt_bgp_params_default(config_data):
	command = "protocols bgp {as_number} parameters default".format(**config_data)
	if config_data["bgp_params"]["default"].get("no_ipv4_unicast"):
	command += " no-ipv4-unicast"
	if config_data["bgp_params"]["default"].get("local_pref"):
	command += " local-pref {local_pref}".format(**config_data["bgp_params"]["default"])
	return command


	def _tmplt_bgp_neighbor_timers(config_data):
	command = []
	for k, v in config_data["neighbor"]["timers"].items():
	command.append(
	"protocols bgp {as_number} neighbor ".format(**config_data)
	+ config_data["neighbor"]["address"]
	+ " timers "
	+ k
	+ " "
	+ str(v),
	)

	return command


	def _tmplt_bgp_timers(config_data):
	command = []
	for k, v in config_data["timers"].items():
	command.append(
	"protocols bgp {as_number} ".format(**config_data) + "timers " + k + " " + str(v),
	)

	return command


	def _tmplt_bgp_neighbor_attribute_unchanged_as_path(config_data):
	command = "protocols bgp {as_number} ".format(
	**config_data,
	) + "neighbor {address} attribute-unchanged as-path".format(**config_data["neighbor"])
	return command


	def _tmplt_bgp_neighbor_attribute_unchanged_med(config_data):
	command = "protocols bgp {as_number} ".format(
	**config_data,
	) + "neighbor {address} attribute-unchanged med".format(**config_data["neighbor"])
	return command


	def _tmplt_bgp_neighbor_attribute_unchanged_next_hop(config_data):
	command = "protocols bgp {as_number} ".format(
	**config_data,
	) + "neighbor {address} attribute-unchanged next-hop".format(**config_data["neighbor"])
	return command


	def _tmplt_bgp_neighbor_distribute_list(config_data):
	command = []
	for list_el in config_data["neighbor"]["distribute_list"]:
	command.append(
	"protocols bgp {as_number} ".format(**config_data)
	+ "neighbor {address} distribute-list ".format(**config_data["neighbor"])
	+ list_el["action"]
	+ " "
	+ str(list_el["acl"]),
	)
	return command


	def _tmplt_bgp_neighbor_route_map(config_data):
	command = []
	for list_el in config_data["neighbor"]["route_map"]:
	command.append(
	"protocols bgp {as_number} ".format(**config_data)
	+ "neighbor {address} route-map ".format(**config_data["neighbor"])
	+ list_el["action"]
	+ " "
	+ str(list_el["route_map"]),
	)
	return command


	def _tmplt_bgp_neighbor_prefix_list(config_data):
	command = []
	for list_el in config_data["neighbor"]["prefix_list"]:
	command.append(
	"protocols bgp {as_number} ".format(**config_data)
	+ "neighbor {address} prefix-list ".format(**config_data["neighbor"])
	+ list_el["action"]
	+ " "
	+ str(list_el["prefix_list"]),
	)
	return command


	def _tmplt_bgp_neighbor_filter_list(config_data):
	command = []
	for list_el in config_data["neighbor"]["filter_list"]:
	command.append(
	"protocols bgp {as_number} ".format(**config_data)
	+ "neighbor {address} filter-list ".format(**config_data["neighbor"])
	+ list_el["action"]
	+ " "
	+ str(list_el["path_list"]),
	)
	return command


	def _tmplt_bgp_params_distance(config_data):
	command = (
	"protocols bgp {as_number} parameters distance global ".format(**config_data)
	+ config_data["bgp_params"]["distance"]["type"]
	+ " "
	+ str(config_data["bgp_params"]["distance"]["value"])
	)
	return command


	class Bgp_globalTemplate(NetworkTemplate):
	def __init__(self, lines=None, module=None):
	prefix = {"set": "set", "remove": "delete"}
	super(Bgp_globalTemplate, self).__init__(
	lines=lines,
	tmplt=self,
	prefix=prefix,
	module=module,
	)

	# fmt: off
	PARSERS = [
	{
	"name": "router",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp {{ as_number }}",
	"compval": "as_number",
	"result": {
	"as_number": "{{ as_num }}",
	},
	},
	{
	"name": "maximum_paths",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+maximum-paths
	\s+(?P<path>ebgp\|ibgp)
	\s+(?P<count>\d+)
	*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_maximum_paths,
	"remval": _tmplt_delete_bgp_maximum_paths,
	"compval": "maximum_paths",
	"result": {
	"as_number": "{{ as_num }}",
	"maximum_paths": [
	{
	"path": "{{ path }}",
	"count": "{{ count }}",
	},
	],
	},
	},
	{
	"name": "neighbor.advertisement_interval",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+neighbor
	\s+(?P<address>\S+)
	\s+advertisement-interval
	- \s+(?P<interval>\S+)
	- *$""",
	+ \s+(?P<interval>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp {{ as_number }} neighbor {{ neighbor.address }} advertisement-interval {{ neighbor.advertisement_interval }}",
	"remval": "protocols bgp {{ as_number }} neighbor {{ neighbor.address }} advertisement-interval",
	"compval": "neighbor.advertisement_interval",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"advertisement_interval": "{{ interval }}",
	},
	},
	},
	},
	{
	"name": "neighbor.allowas_in",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+neighbor
	\s+(?P<address>\S+)
	\s+allowas-in
	\s+number
	\s+(?P<num>\'\d+\')
	*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp {{ as_number }} neighbor {{ neighbor.address }} allowas-in number {{ neighbor.allowas_in }}",
	"compval": "neighbor.allowas_in",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"allowas_in": "{{ count }}",
	},
	},
	},
	},
	{
	"name": "neighbor.as_override",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+neighbor
	\s+(?P<address>\S+)
	\s+as-override
	*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp {{ as_number }} neighbor {{ neighbor.address }} as-override",
	"compval": "neighbor.as_override",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"as_override": "{{ True }}",
	},
	},
	},
	},
	{
	"name": "neighbor.attribute_unchanged.as_path",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+neighbor
	\s+(?P<address>\S+)
	\s+attribute-unchanged
	\s+(?P<val>as-path)
	*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_neighbor_attribute_unchanged_as_path,
	"compval": "neighbor.attribute_unchanged",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"attribute_unchanged": {
	"{{ 'as_path' }}": "{{ True }}",
	},
	},
	},
	},
	},
	{
	"name": "neighbor.attribute_unchanged.med",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+neighbor
	\s+(?P<address>\S+)
	\s+attribute-unchanged
	\s+(?P<val>med)
	*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_neighbor_attribute_unchanged_med,
	"compval": "neighbor.attribute_unchanged",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"attribute_unchanged": {
	"{{ 'med' }}": "{{ True }}",
	},
	},
	},
	},
	},
	{
	"name": "neighbor.attribute_unchanged.next_hop",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+neighbor
	\s+(?P<address>\S+)
	\s+attribute-unchanged
	\s+(?P<val>next-hop)
	*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_neighbor_attribute_unchanged_next_hop,
	"compval": "neighbor.attribute_unchanged",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"attribute_unchanged": {
	"{{ 'next_hop' }}": "{{ True }}",
	},
	},
	},
	},
	},
	{
	"name": "neighbor.capability_dynamic",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+neighbor
	\s+(?P<address>\S+)
	\s+capability
	\s+(?P<dynamic>dynamic)
	*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp {{ as_number }} neighbor {{ neighbor.address }} capability dynamic",
	"compval": "neighbor.capability.dynamic",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"capability": {
	"dynamic": "{{ True if dynamic is defined}}",
	},
	},
	},
	},
	},
	{
	"name": "neighbor.capability_orf",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+neighbor
	\s+(?P<address>\S+)
	\s+capability
	\s+orf
	\s+prefix-list
	- \s+(?P<orf>\S+)
	- *$""",
	+ \s+(?P<orf>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp {{ as_number }} neighbor {{ neighbor.address }} capability orf prefix-list {{ neighbor.capability.orf }}",
	"compval": "neighbor.capability.orf",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"capability": {
	"orf": "{{ orf }}",
	},
	},
	},
	},
	},
	{
	"name": "neighbor.default_originate",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+neighbor
	\s+(?P<address>\S+)
	\s+default-originate
	\s+route-map
	- \s+(?P<map>\S+)
	- *$""",
	+ \s+(?P<map>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp {{ as_number }} neighbor {{ neighbor.address }} default-originate route-map {{ neighbor.default_originate }}",
	"compval": "neighbor.advertisement_interval",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"default_originate": "{{ map }}",
	},
	},
	},
	},
	{
	"name": "neighbor.description",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+neighbor
	\s+(?P<address>\S+)
	\s+description
	- \s+(?P<desc>\S+)
	- *$""",
	+ \s+(?P<desc>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp {{ as_number }} neighbor {{ neighbor.address }} description {{ neighbor.description }}",
	"compval": "neighbor.description",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"description": "{{ desc }}",
	},
	},
	},
	},
	{
	"name": "neighbor.disable_capability_negotiation",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+neighbor
	\s+(?P<address>\S+)
	\s+disable-capability-negotiation
	*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp {{ as_number }} neighbor {{ neighbor.address }} disable-capability-negotiation",
	"compval": "neighbor.disable_capability_negotiation",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"disable_capability_negotiation": "{{ True }}",
	},
	},
	},
	},
	{
	"name": "neighbor.disable_connected_check",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+neighbor
	\s+(?P<address>\S+)
	\s+disable-connected-check
	*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp {{ as_number }} neighbor {{ neighbor.address }} disable-connected-check",
	"compval": "neighbor.disable_connected_check",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"disable_connected_check": "{{ True }}",
	},
	},
	},
	},
	{
	"name": "neighbor.disable_send_community",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+neighbor
	\s+(?P<address>\S+)
	\s+disable-send-community
	- \s+(?P<comm>\S+)
	- *$""",
	+ \s+(?P<comm>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp {{ as_number }} neighbor {{ neighbor.address }} disable-send-community {{ neighbor.disable_send_community }}",
	"compval": "neighbor.disable_send_community",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"disable_send_community": "{{ comm }}",
	},
	},
	},
	},
	{
	"name": "neighbor.distribute_list",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+neighbor
	\s+(?P<address>\S+)
	\s+distribute-list
	\s+(?P<action>export\|import)
	\s+(?P<list>\d+)
	*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_neighbor_distribute_list,
	"compval": "neighbor.distribute_list",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"distribute_list": [
	{
	"action": "{{ action }}",
	"acl": "{{ list }}",
	},
	],
	},
	},
	},
	},
	{
	"name": "neighbor.ebgp_multihop",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+neighbor
	\s+(?P<address>\S+)
	\s+ebgp-multihop
	- \s+(?P<hop>\S+)
	- *$""",
	+ \s+(?P<hop>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp {{ as_number }} neighbor {{ neighbor.address }} ebgp-multihop {{ neighbor.ebgp_multihop }}",
	"compval": "neighbor.ebgp_multihop",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"ebgp_multihop": "{{ hop\|int }}",
	},
	},
	},
	},
	{
	"name": "neighbor.filter_list",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+neighbor
	\s+(?P<address>\S+)
	\s+filter-list
	\s+(?P<action>export\|import)
	- \s+(?P<list>\S+)
	- *$""",
	+ \s+(?P<list>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_neighbor_filter_list,
	"compval": "neighbor.filter_list",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"filter_list": [
	{
	"action": "{{ action }}",
	"path_list": "{{ list }}",
	},
	],
	},
	},
	},
	},
	{
	"name": "neighbor.local_as",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+neighbor
	\s+(?P<address>\S+)
	\s+local-as
	\s+(?P<as>\S+)
	\s+no-prepend
	*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp {{ as_number }} neighbor {{ neighbor.address }} local-as {{ neighbor.local_as }} no-prepend",
	"compval": "neighbor.local_as",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"local_as": "{{ as }}",
	},
	},
	},
	},
	{
	"name": "neighbor.maximum_prefix",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+neighbor
	\s+(?P<address>\S+)
	\s+maximum-prefix
	- \s+(?P<num>\S+)
	- *$""",
	+ \s+(?P<num>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp {{ as_number }} neighbor {{ neighbor.address }} maximum-prefix {{ neighbor.maximum_prefix }}",
	"compval": "neighbor.maximum_prefix",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"maximum_prefix": "{{ num }}",
	},
	},
	},
	},
	{
	"name": "neighbor.nexthop_self",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+neighbor
	\s+(?P<address>\S+)
	\s+nexthop-self
	*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp {{ as_number }} neighbor {{ neighbor.address }} nexthop-self",
	"compval": "neighbor.nexthop_self",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"nexthop_self": "{{ True }}",
	},
	},
	},
	},
	{
	"name": "neighbor.override_capability",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+neighbor
	\s+(?P<address>\S+)
	\s+override-capability
	*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp {{ as_number }} neighbor {{ neighbor.address }} override-capability",
	"compval": "neighbor.override_capability",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"override_capability": "{{ True }}",
	},
	},
	},
	},
	{
	"name": "neighbor.passive",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+neighbor
	\s+(?P<address>\S+)
	\s+passive
	*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp {{ as_number }} neighbor {{ neighbor.address }} passive",
	"compval": "neighbor.passive",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"passive": "{{ True }}",
	},
	},
	},
	},
	{
	"name": "neighbor.password",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+neighbor
	\s+(?P<address>\S+)
	\s+password
	- \s+(?P<pwd>\S+)
	- *$""",
	+ \s+(?P<pwd>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp {{ as_number }} neighbor {{ neighbor.address }} password {{ neighbor.password }}",
	"compval": "neighbor.password",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"password": "{{ pwd }}",
	},
	},
	},
	},
	{
	"name": "neighbor.peer_group_name",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+neighbor
	\s+(?P<address>\S+)
	\s+peer-group
	- \s+(?P<name>\S+)
	- *$""",
	+ \s+(?P<name>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp {{ as_number }} neighbor {{ neighbor.address }} peer-group {{ neighbor.peer_group_name }}",
	"compval": "neighbor.peer_group_name",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"peer_group_name": "{{ name }}",
	},
	},
	},
	},
	{
	"name": "neighbor.port",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+neighbor
	\s+(?P<address>\S+)
	\s+port
	- \s+(?P<num>\S+)
	- *$""",
	+ \s+(?P<num>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp {{ as_number }} neighbor {{ neighbor.address }} port {{ neighbor.port }}",
	"compval": "neighbor.port",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"port": "{{ num\|int }}",
	},
	},
	},
	},
	{
	"name": "neighbor.prefix_list",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+neighbor
	\s+(?P<address>\S+)
	\s+prefix-list
	\s+(?P<action>export\|import)
	- \s+(?P<list>\S+)
	- *$""",
	+ \s+(?P<list>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_neighbor_prefix_list,
	"compval": "neighbor.prefix_list",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"prefix_list": [
	{
	"action": "{{ action }}",
	"prefix_list": "{{ list }}",
	},
	],
	},
	},
	},
	},
	{
	"name": "neighbor.remote_as",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+neighbor
	\s+(?P<address>\S+)
	\s+remote-as
	- \s+(?P<num>\S+)
	- *$""",
	+ \s+(?P<num>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp {{ as_number }} neighbor {{ neighbor.address }} remote-as {{ neighbor.remote_as }}",
	"compval": "neighbor.remote_as",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"remote_as": "{{ num\|int }}",
	},
	},
	},
	},
	{
	"name": "neighbor.remove_private_as",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+neighbor
	\s+(?P<address>\S+)
	\s+remote-private-as
	*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp {{ as_number }} neighbor {{ neighbor.address }} remote-private-as",
	"compval": "neighbor.remove_private_as",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"remove_private_as": "{{ True }}",
	},
	},
	},
	},
	{
	"name": "neighbor.route_map",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+neighbor
	\s+(?P<address>\S+)
	\s+route-map
	\s+(?P<action>export\|import)
	- \s+(?P<map>\S+)
	- *$""",
	+ \s+(?P<map>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_neighbor_route_map,
	"compval": "neighbor.route_map",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"route_map": [
	{
	"action": "{{ action }}",
	"route_map": "{{ map }}",
	},
	],
	},
	},
	},
	},
	{
	"name": "neighbor.route_reflector_client",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+neighbor
	\s+(?P<address>\S+)
	\s+route-reflector-client
	*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp {{ as_number }} neighbor {{ neighbor.address }} router-reflector-client",
	"compval": "neighbor.route_reflector_client",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"route_reflector_client": "{{ True }}",
	},
	},
	},
	},
	{
	"name": "neighbor.route_server_client",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+neighbor
	\s+(?P<address>\S+)
	\s+route-server-client
	*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp {{ as_number }} neighbor {{ neighbor.address }} route-server-client",
	"compval": "neighbor.route_server_client",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"route_server_client": "{{ True }}",
	},
	},
	},
	},
	{
	"name": "neighbor.shutdown",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+neighbor
	\s+(?P<address>\S+)
	\s+shutdown
	*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp {{ as_number }} neighbor {{ neighbor.address }} shutdown",
	"compval": "neighbor.shutdown",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"shutdown": "{{ True }}",
	},
	},
	},
	},
	{
	"name": "neighbor.soft_reconfiguration",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+neighbor
	\s+(?P<address>\S+)
	\s+soft-reconfiguration
	\s+inbound
	*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp {{ as_number }} neighbor {{ neighbor.address }} soft-reconfiguration",
	"compval": "neighbor.soft_reconfiguration",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"soft_reconfiguration": "{{ True }}",
	},
	},
	},
	},
	{
	"name": "neighbor.strict_capability_match",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+neighbor
	\s+(?P<address>\S+)
	\s+strict-capability-match
	*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp {{ as_number }} neighbor {{ neighbor.address }} strict-capability-match",
	"compval": "neighbor.strict_capability_match",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"strict_capability_match": "{{ True }}",
	},
	},
	},
	},
	{
	"name": "neighbor.unsuppress_map",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+neighbor
	\s+(?P<address>\S+)
	\s+unsuppress-map
	- \s+(?P<map>\S+)
	- *$""",
	+ \s+(?P<map>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp {{ as_number }} neighbor {{ neighbor.address }} unsuppress-map {{ neighbor.unsuppress_map }}",
	"compval": "neighbor.unsuppress_map",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"unsuppress_map": "{{ map }}",
	},
	},
	},
	},
	{
	"name": "neighbor.update_source",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+neighbor
	\s+(?P<address>\S+)
	\s+update-source
	- \s+(?P<src>\S+)
	- *$""",
	+ \s+(?P<src>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp {{ as_number }} neighbor {{ neighbor.address }} update-source {{ neighbor.update_source }}",
	"compval": "neighbor.update_source",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"update_source": "{{ src }}",
	},
	},
	},
	},
	{
	"name": "neighbor.weight",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+neighbor
	\s+(?P<address>\S+)
	\s+weight
	- \s+(?P<num>\S+)
	- *$""",
	+ \s+(?P<num>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp {{ as_number }} neighbor {{ neighbor.address }} weight {{ neighbor.weight }}",
	"compval": "neighbor.weight",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"weight": "{{ num }}",
	},
	},
	},
	},
	{
	"name": "neighbor.ttl_security",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+neighbor
	\s+(?P<address>\S+)
	\s+ttl-security
	- \s+(?P<ttl>\S+)
	- *$""",
	+ \s+(?P<ttl>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp {{ as_number }} neighbor {{ neighbor.address }} ttl-security {{ neighbor.ttl_security }}",
	"compval": "neighbor.ttl_security",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"ttl_security": "{{ ttl\|int }}",
	},
	},
	},
	},
	{
	"name": "neighbor.timers",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+neighbor
	\s+(?P<address>\S+)
	\s+timers
	\s+(?P<type>connect\|holdtime\|keepalive)
	- \s+(?P<sec>\S+)
	- *$""",
	+ \s+(?P<sec>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_neighbor_timers,
	"remval": "protocols bgp {{ as_number }} neighbor {{ neighbor.address }} timers",
	"compval": "neighbor.timers",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"timers": {
	"{{ type }}": "{{ sec }}",
	},
	},
	},
	},
	},
	{
	"name": "timers",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+timers
	\s+(?P<type>\S+)
	- \s+(?P<val>\S+)
	- *$""",
	+ \s+(?P<val>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_timers,
	"remval": "protocols bgp {{ as_number }} timers",
	"compval": "timers",
	"result": {
	"as_number": "{{ as_num }}",
	"timers": {
	"{{ type }}": "{{ val }}",
	},
	},
	},
	{
	"name": "bgp_params.always_compare_med",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+parameters
	\s+always-compare-med
	*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp {{ as_number }} parameters always-compare-med",
	"compval": "bgp_params.always_compare_med",
	"result": {
	"as_number": "{{ as_num }}",
	"bgp_params": {
	"always_compare_med": "{{ True }}",
	},
	},
	},
	{
	"name": "bgp_params.bestpath.as_path",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+parameters
	\s+bestpath
	\s+as-path
	\s+(?P<path>confed\|ignore)
	*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp {{ as_number }} parameters bestpath as-path {{ bgp_params.bestpath.as_path }}",
	"compval": "bgp_params.bestpath.as_path",
	"result": {
	"as_number": "{{ as_num }}",
	"bgp_params": {
	"bestpath": {
	"as_path": "{{ path }}",
	},
	},
	},
	},
	{
	"name": "bgp_params.bestpath.compare_routerid",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+parameters
	\s+bestpath
	\s+compare-routerid
	*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp {{ as_number }} parameters bestpath compare-routerid",
	"compval": "bgp_params.bestpath.compare_routerid",
	"result": {
	"as_number": "{{ as_num }}",
	"bgp_params": {
	"bestpath": {
	"compare_routerid": "{{ True }}",
	},
	},
	},
	},
	{
	"name": "bgp_params.bestpath.med",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+parameters
	\s+bestpath
	\s+med
	\s+(?P<path>confed\|missing-as-worst)
	*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp {{ as_number }} parameters bestpath med {{ bestpath.med }}",
	"compval": "bgp_params.bestpath.med",
	"result": {
	"as_number": "{{ as_num }}",
	"bgp_params": {
	"bestpath": {
	"med": "{{ path }}",
	},
	},
	},
	},
	{
	"name": "bgp_params.cluster_id",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+parameters
	\s+cluster-id
	- \s+(?P<id>\S+)
	- *$""",
	+ \s+(?P<id>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp {{ as_number }} parameters cluster-id {{ bgp_params.cluster_id }}",
	"compval": "bgp_params.cluster_id",
	"result": {
	"as_number": "{{ as_num }}",
	"bgp_params": {
	"cluster_id": "{{ id }}",
	},
	},
	},
	{
	"name": "bgp_params.confederation",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+parameters
	\s+confederation
	\s+(?P<type>identifier\|peers)
	- \s+(?P<val>\S+)
	- *$""",
	+ \s+(?P<val>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_params_confederation,
	"compval": "bgp_params.always_compare_med",
	"result": {
	"as_number": "{{ as_num }}",
	"bgp_params": {
	"confederation": [
	{
	"peers": "{{ val if type == 'peers' }}",
	"identifier": "{{ val if type == 'identifier' }}",
	},
	],
	},
	},
	},
	{
	"name": "bgp_params.dampening_half_life",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+parameters
	\s+dampening
	\s+half-life
	- \s+(?P<val>\S+)
	- *$""",
	+ \s+(?P<val>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp {{ as_number }} parameters dampening half-life {{ bgp_params.dampening.half_life}}",
	"compval": "bgp_params.dampening.half_life",
	"result": {
	"as_number": "{{ as_num }}",
	"bgp_params": {
	"dampening": {
	"half_life": "{{ val }}",
	},
	},
	},
	},
	{
	"name": "bgp_params.dampening_max_suppress_time",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+parameters
	\s+dampening
	\s+max-suppress-time
	- \s+(?P<val>\S+)
	- *$""",
	+ \s+(?P<val>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp {{ as_number }} parameters dampening max-suppress-time {{ bgp_params.dampening.max_suppress_time}}",
	"compval": "bgp_params.dampening.max_suppress_time",
	"result": {
	"as_number": "{{ as_num }}",
	"bgp_params": {
	"dampening": {
	"max_suppress_time": "{{ val }}",
	},
	},
	},
	},
	{
	"name": "bgp_params.dampening_re_use",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+parameters
	\s+dampening
	\s+re-use
	- \s+(?P<val>\S+)
	- *$""",
	+ \s+(?P<val>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp {{ as_number }} parameters dampening re-use {{ bgp_params.dampening.re_use}}",
	"compval": "bgp_params.dampening.re_use",
	"result": {
	"as_number": "{{ as_num }}",
	"bgp_params": {
	"dampening": {
	"re_use": "{{ val }}",
	},
	},
	},
	},
	{
	"name": "bgp_params.dampening_start_suppress_time",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+parameters
	\s+dampening
	\s+start-suppress-time
	- \s+(?P<val>\S+)
	- *$""",
	+ \s+(?P<val>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp {{ as_number }} parameters dampening start-suppress-time {{ bgp_params.dampening.start_suppress_time}}",
	"compval": "bgp_params.dampening.start_suppress_time",
	"result": {
	"as_number": "{{ as_num }}",
	"bgp_params": {
	"dampening": {
	"start_suppress_time": "{{ val }}",
	},
	},
	},
	},
	{
	"name": "bgp_params.default",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+parameters
	\s+default
	- \s(?P<no_ipv4_unicast>no-ipv4-unicast)
	- \s*(?P<local_pref>local-pref\s\S+)
	- *$""",
	+ \s*(?P<no_ipv4_unicast>no-ipv4-unicast)?
	+ \s(?P<local_pref>local-pref\s\S+)?\s$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_params_default,
	"remval": "protocols bgp {{ as_number }} parameters default",
	"compval": "bgp_params.default",
	"result": {
	"as_number": "{{ as_num }}",
	"bgp_params": {
	"default": {
	"no_ipv4_unicast": "{{ True if no_ipv4_unicast is defined }}",
	"local_pref": "{{ local_pref.split(" " )[1] if local_pref is defined }}",
	},
	},
	},
	},
	{
	"name": "bgp_params.deterministic_med",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+parameters
	\s+deterministic-med
	*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp {{ as_number }} parameters deterministic-med",
	"compval": "bgp_params.deterministic_med",
	"result": {
	"as_number": "{{ as_num }}",
	"bgp_params": {
	"deterministic_med": "{{ True }}",
	},
	},
	},
	{
	"name": "bgp_params.disbale_network_import_check",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+parameters
	\s+disable-network-import-check
	*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp {{ as_number }} parameters disable-network-import-check",
	"compval": "bgp_params.disable_network_import_check",
	"result": {
	"as_number": "{{ as_num }}",
	"bgp_params": {
	"disable_network_import_check": "{{ True }}",
	},
	},
	},
	{
	"name": "bgp_params.distance.prefix",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+parameters
	\s+distance\sprefix
	\s+(?P<prefix>\S+)
	\s+distance
	- \s+(?P<val>\S+)
	- *$""",
	+ \s+(?P<val>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp {{ as_number }} parameters distance prefix {{ bgp_params.distance.prefix }} distance {{ bgp_params.distance.value }}",
	"compval": "bgp_params.distance.prefix",
	"remval": "protocols bgp {{ as_number }} parameters distance prefix",
	"result": {
	"as_number": "{{ as_num }}",
	"bgp_params": {
	"distance": [
	{
	"prefix": "{{ prefix }}",
	"value": "{{ val }}",
	},
	],
	},
	},
	},
	{
	"name": "bgp_params.distance.global",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+parameters
	\s+distance\sglobal
	\s+(?P<type>\S+)
	- \s+(?P<val>\S+)
	- *$""",
	+ \s+(?P<val>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_params_distance,
	"remval": "protocols bgp {{ as_number }} parameters distance global",
	"compval": "bgp_params.distance",
	"result": {
	"as_number": "{{ as_num }}",
	"bgp_params": {
	"distance": [
	{
	"type": "{{ type }}",
	"value": "{{ val }}",
	},
	],
	},
	},
	},
	{
	"name": "bgp_params.enforce_first_as",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+parameters
	\s+enforce-first-as
	*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp {{ as_number }} parameters enforce-first-as",
	"compval": "bgp_params.enforce_first_as",
	"result": {
	"as_number": "{{ as_num }}",
	"bgp_params": {
	"enforce_first_as": "{{ True }}",
	},
	},
	},
	{
	"name": "bgp_params.graceful_restart",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+parameters
	\s+graceful-restart\s+stalepath-time
	- \s+(?P<val>\S+)
	- *$""",
	+ \s+(?P<val>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp {{ as_number }} parameters graceful-restart stalepath-time {{ bgp_params.graceful_restart }}",
	"compval": "bgp_params.graceful_restart",
	"result": {
	"as_number": "{{ as_num }}",
	"bgp_params": {
	"graceful_restart": "{{ val }}",
	},
	},
	},
	{
	"name": "bgp_params.log_neighbor_changes",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+parameters
	\s+log-neighbor-changes
	*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp {{ as_number }} parameters log-neighbor-changes",
	"compval": "bgp_params.log_neighbor_changes",
	"result": {
	"as_number": "{{ as_num }}",
	"bgp_params": {
	"log_neighbor_changes": "{{ True }}",
	},
	},
	},
	{
	"name": "bgp_params.no_client_to_client_reflection",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+parameters
	\s+no-client-to-client-reflection
	*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp {{ as_number }} parameters no-client-to-client-reflection",
	"compval": "bgp_params.log_neighbor_changes",
	"result": {
	"as_number": "{{ as_num }}",
	"bgp_params": {
	"no_client_to_client_reflection": "{{ True }}",
	},
	},
	},
	{
	"name": "bgp_params.no_fast_external_failover",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+parameters
	\s+no-fast-external-failover
	*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp {{ as_number }} parameters no-fast-external-failover",
	"compval": "bgp_params.no_fast_external_failover",
	"result": {
	"as_number": "{{ as_num }}",
	"bgp_params": {
	"no_fast_external_failover": "{{ True }}",
	},
	},
	},
	{
	"name": "bgp_params.routerid",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+parameters
	\s+router-id
	- \s+(?P<id>\S+)
	- *$""",
	+ \s+(?P<id>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp {{ as_number }} parameters router-id {{ bgp_params.router_id }}",
	"compval": "bgp_params.router_id",
	"result": {
	"as_number": "{{ as_num }}",
	"bgp_params": {
	"router_id": "{{ id }}",
	},
	},
	},
	{
	"name": "bgp_params.scan_time",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+(?P<as_num>\d+)
	\s+parameters
	\s+scan-time
	\s+(?P<sec>\d+)
	*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp {{ as_number }} parameters scan-time {{ bgp_params.scan_time }}",
	"compval": "bgp_params.scan_time",
	"result": {
	"as_number": "{{ as_num }}",
	"bgp_params": {
	"scan_time": "{{ val }}",
	},
	},
	},

	]
	# fmt: on
	diff --git a/plugins/module_utils/network/vyos/rm_templates/bgp_global_14.py b/plugins/module_utils/network/vyos/rm_templates/bgp_global_14.py
	index 39855c1c..cbe21e3a 100644
	--- a/plugins/module_utils/network/vyos/rm_templates/bgp_global_14.py
	+++ b/plugins/module_utils/network/vyos/rm_templates/bgp_global_14.py
	@@ -1,1795 +1,1764 @@
	# -- coding: utf-8 --
	# Copyright 2021 Red Hat
	# GNU General Public License v3.0+
	# (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)

	from __future__ import absolute_import, division, print_function


	__metaclass__ = type

	"""
	The Bgp_global parser templates file. This contains
	a list of parser definitions and associated functions that
	facilitates both facts gathering and native command generation for
	the given network resource.
	"""

	import re

	from ansible_collections.ansible.netcommon.plugins.module_utils.network.common.rm_base.network_template import (
	NetworkTemplate,
	)


	def _tmplt_bgp_params_confederation(config_data):
	command = []
	for list_el in config_data["bgp_params"]["confederation"]:
	for k, v in list_el.items():
	command.append(
	"protocols bgp parameters confederation ".format(**config_data) + k + " " + str(v),
	)

	return command


	def _tmplt_bgp_maximum_paths(config_data):
	command = []
	for list_el in config_data["maximum_paths"]:
	command.append(
	"protocols bgp maximum-paths ".format(**config_data)
	+ list_el["path"]
	+ " "
	+ str(list_el["count"]),
	)
	return command


	def _tmplt_delete_bgp_maximum_paths(config_data):
	command = "protocols bgp maximum-paths".format(**config_data)
	return command


	def _tmplt_bgp_params_default(config_data):
	command = "protocols bgp parameters default".format(**config_data)
	if config_data["bgp_params"]["default"].get("no_ipv4_unicast"):
	command += " no-ipv4-unicast"
	if config_data["bgp_params"]["default"].get("local_pref"):
	command += " local-pref {local_pref}".format(**config_data["bgp_params"]["default"])
	return command


	def _tmplt_bgp_neighbor_timers(config_data):
	command = []
	for k, v in config_data["neighbor"]["timers"].items():
	command.append(
	"protocols bgp neighbor ".format(**config_data)
	+ config_data["neighbor"]["address"]
	+ " timers "
	+ k
	+ " "
	+ str(v),
	)

	return command


	def _tmplt_bgp_timers(config_data):
	command = []
	for k, v in config_data["timers"].items():
	command.append(
	"protocols bgp ".format(**config_data) + "timers " + k + " " + str(v),
	)

	return command


	def _tmplt_bgp_neighbor_attribute_unchanged_as_path(config_data):
	command = "protocols bgp ".format(
	**config_data,
	) + "neighbor {address} attribute-unchanged as-path".format(**config_data["neighbor"])
	return command


	def _tmplt_bgp_neighbor_attribute_unchanged_med(config_data):
	command = "protocols bgp ".format(
	**config_data,
	) + "neighbor {address} attribute-unchanged med".format(**config_data["neighbor"])
	return command


	def _tmplt_bgp_neighbor_attribute_unchanged_next_hop(config_data):
	command = "protocols bgp ".format(
	**config_data,
	) + "neighbor {address} attribute-unchanged next-hop".format(**config_data["neighbor"])
	return command


	def _tmplt_bgp_neighbor_distribute_list(config_data):
	command = []
	for list_el in config_data["neighbor"]["distribute_list"]:
	command.append(
	"protocols bgp ".format(**config_data)
	+ "neighbor {address} distribute-list ".format(**config_data["neighbor"])
	+ list_el["action"]
	+ " "
	+ str(list_el["acl"]),
	)
	return command


	def _tmplt_bgp_neighbor_route_map(config_data):
	command = []
	for list_el in config_data["neighbor"]["route_map"]:
	command.append(
	"protocols bgp ".format(**config_data)
	+ "neighbor {address} route-map ".format(**config_data["neighbor"])
	+ list_el["action"]
	+ " "
	+ str(list_el["route_map"]),
	)
	return command


	def _tmplt_bgp_neighbor_prefix_list(config_data):
	command = []
	for list_el in config_data["neighbor"]["prefix_list"]:
	command.append(
	"protocols bgp ".format(**config_data)
	+ "neighbor {address} prefix-list ".format(**config_data["neighbor"])
	+ list_el["action"]
	+ " "
	+ str(list_el["prefix_list"]),
	)
	return command


	def _tmplt_bgp_neighbor_filter_list(config_data):
	command = []
	for list_el in config_data["neighbor"]["filter_list"]:
	command.append(
	"protocols bgp ".format(**config_data)
	+ "neighbor {address} filter-list ".format(**config_data["neighbor"])
	+ list_el["action"]
	+ " "
	+ str(list_el["path_list"]),
	)
	return command


	def _tmplt_bgp_params_distance(config_data):
	command = (
	"protocols bgp parameters distance global ".format(**config_data)
	+ config_data["bgp_params"]["distance"]["type"]
	+ " "
	+ str(config_data["bgp_params"]["distance"]["value"])
	)
	return command


	class Bgp_globalTemplate14(NetworkTemplate):
	def __init__(self, lines=None, module=None):
	prefix = {"set": "set", "remove": "delete"}
	super(Bgp_globalTemplate14, self).__init__(
	lines=lines,
	tmplt=self,
	prefix=prefix,
	module=module,
	)

	# fmt: off
	PARSERS = [
	{
	"name": "router",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s*system-as
	\s+(?P<as_num>\d+)
	*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp system-as {{ as_number }}",
	"remval": "protocols bgp",
	"compval": "as_number",
	"result": {
	"as_number": "{{ as_num }}",
	},
	},
	{
	"name": "maximum_paths",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+maximum-paths
	\s+(?P<path>ebgp\|ibgp)
	\s+(?P<count>\d+)
	*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_maximum_paths,
	"remval": _tmplt_delete_bgp_maximum_paths,
	"compval": "maximum_paths",
	"result": {
	"as_number": "{{ as_num }}",
	"maximum_paths": [
	{
	"path": "{{ path }}",
	"count": "{{ count }}",
	},
	],
	},
	},
	{
	"name": "neighbor.advertisement_interval",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+neighbor
	\s+(?P<address>\S+)
	\s+advertisement-interval
	- \s+(?P<interval>\S+)
	- *$""",
	+ \s+(?P<interval>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp neighbor {{ neighbor.address }} advertisement-interval {{ neighbor.advertisement_interval }}",
	"remval": "protocols bgp neighbor {{ neighbor.address }} advertisement-interval",
	"compval": "neighbor.advertisement_interval",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"advertisement_interval": "{{ interval }}",
	},
	},
	},
	},
	{
	"name": "neighbor.allowas_in",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+neighbor
	\s+(?P<address>\S+)
	\s+allowas-in
	\s+number
	\s+(?P<num>\'\d+\')
	*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp neighbor {{ neighbor.address }} allowas-in number {{ neighbor.allowas_in }}",
	"compval": "neighbor.allowas_in",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"allowas_in": "{{ count }}",
	},
	},
	},
	},
	{
	"name": "neighbor.as_override",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+neighbor
	\s+(?P<address>\S+)
	\s+as-override
	*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp neighbor {{ neighbor.address }} as-override",
	"compval": "neighbor.as_override",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"as_override": "{{ True }}",
	},
	},
	},
	},
	{
	"name": "neighbor.attribute_unchanged.as_path",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+neighbor
	\s+(?P<address>\S+)
	\s+attribute-unchanged
	\s+(?P<val>as-path)
	*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_neighbor_attribute_unchanged_as_path,
	"compval": "neighbor.attribute_unchanged",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"attribute_unchanged": {
	"{{ 'as_path' }}": "{{ True }}",
	},
	},
	},
	},
	},
	{
	"name": "neighbor.attribute_unchanged.med",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+neighbor
	\s+(?P<address>\S+)
	\s+attribute-unchanged
	\s+(?P<val>med)
	*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_neighbor_attribute_unchanged_med,
	"compval": "neighbor.attribute_unchanged",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"attribute_unchanged": {
	"{{ 'med' }}": "{{ True }}",
	},
	},
	},
	},
	},
	{
	"name": "neighbor.attribute_unchanged.next_hop",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+neighbor
	\s+(?P<address>\S+)
	\s+attribute-unchanged
	\s+(?P<val>next-hop)
	*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_neighbor_attribute_unchanged_next_hop,
	"compval": "neighbor.attribute_unchanged",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"attribute_unchanged": {
	"{{ 'next_hop' }}": "{{ True }}",
	},
	},
	},
	},
	},
	{
	"name": "neighbor.capability_dynamic",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+neighbor
	\s+(?P<address>\S+)
	\s+capability
	\s+(?P<dynamic>dynamic)
	*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp neighbor {{ neighbor.address }} capability dynamic",
	"compval": "neighbor.capability.dynamic",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"capability": {
	"dynamic": "{{ True if dynamic is defined}}",
	},
	},
	},
	},
	},
	{
	"name": "neighbor.capability_orf",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+neighbor
	\s+(?P<address>\S+)
	\s+capability
	\s+orf
	\s+prefix-list
	- \s+(?P<orf>\S+)
	- *$""",
	+ \s+(?P<orf>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp neighbor {{ neighbor.address }} capability orf prefix-list {{ neighbor.capability.orf }}",
	"compval": "neighbor.capability.orf",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"capability": {
	"orf": "{{ orf }}",
	},
	},
	},
	},
	},
	{
	"name": "neighbor.default_originate",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+neighbor
	\s+(?P<address>\S+)
	\s+default-originate
	\s+route-map
	- \s+(?P<map>\S+)
	- *$""",
	+ \s+(?P<map>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp neighbor {{ neighbor.address }} default-originate route-map {{ neighbor.default_originate }}",
	"compval": "neighbor.advertisement_interval",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"default_originate": "{{ map }}",
	},
	},
	},
	},
	{
	"name": "neighbor.description",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+neighbor
	\s+(?P<address>\S+)
	\s+description
	- \s+(?P<desc>\S+)
	- *$""",
	+ \s+(?P<desc>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp neighbor {{ neighbor.address }} description {{ neighbor.description }}",
	"compval": "neighbor.description",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"description": "{{ desc }}",
	},
	},
	},
	},
	{
	"name": "neighbor.disable_capability_negotiation",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+neighbor
	\s+(?P<address>\S+)
	\s+disable-capability-negotiation
	*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp neighbor {{ neighbor.address }} disable-capability-negotiation",
	"compval": "neighbor.disable_capability_negotiation",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"disable_capability_negotiation": "{{ True }}",
	},
	},
	},
	},
	{
	"name": "neighbor.disable_connected_check",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+neighbor
	\s+(?P<address>\S+)
	\s+disable-connected-check
	*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp neighbor {{ neighbor.address }} disable-connected-check",
	"compval": "neighbor.disable_connected_check",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"disable_connected_check": "{{ True }}",
	},
	},
	},
	},
	{
	"name": "neighbor.disable_send_community",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+neighbor
	\s+(?P<address>\S+)
	\s+disable-send-community
	- \s+(?P<comm>\S+)
	- *$""",
	+ \s+(?P<comm>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp neighbor {{ neighbor.address }} disable-send-community {{ neighbor.disable_send_community }}",
	"compval": "neighbor.disable_send_community",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"disable_send_community": "{{ comm }}",
	},
	},
	},
	},
	{
	"name": "neighbor.distribute_list",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+neighbor
	\s+(?P<address>\S+)
	\s+distribute-list
	\s+(?P<action>export\|import)
	\s+(?P<list>\d+)
	*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_neighbor_distribute_list,
	"compval": "neighbor.distribute_list",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"distribute_list": [
	{
	"action": "{{ action }}",
	"acl": "{{ list }}",
	},
	],
	},
	},
	},
	},
	{
	"name": "neighbor.ebgp_multihop",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+neighbor
	\s+(?P<address>\S+)
	\s+ebgp-multihop
	- \s+(?P<hop>\S+)
	- *$""",
	+ \s+(?P<hop>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp neighbor {{ neighbor.address }} ebgp-multihop {{ neighbor.ebgp_multihop }}",
	"compval": "neighbor.ebgp_multihop",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"ebgp_multihop": "{{ hop\|int }}",
	},
	},
	},
	},
	{
	"name": "neighbor.filter_list",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+neighbor
	\s+(?P<address>\S+)
	\s+filter-list
	\s+(?P<action>export\|import)
	- \s+(?P<list>\S+)
	- *$""",
	+ \s+(?P<list>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_neighbor_filter_list,
	"compval": "neighbor.filter_list",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"filter_list": [
	{
	"action": "{{ action }}",
	"path_list": "{{ list }}",
	},
	],
	},
	},
	},
	},
	{
	"name": "neighbor.local_as",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+neighbor
	\s+(?P<address>\S+)
	\s+local-as
	\s+(?P<as>\S+)
	\s+no-prepend
	*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp neighbor {{ neighbor.address }} local-as {{ neighbor.local_as }} no-prepend",
	"compval": "neighbor.local_as",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"local_as": "{{ as }}",
	},
	},
	},
	},
	{
	"name": "neighbor.maximum_prefix",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+neighbor
	\s+(?P<address>\S+)
	\s+maximum-prefix
	- \s+(?P<num>\S+)
	- *$""",
	+ \s+(?P<num>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp neighbor {{ neighbor.address }} maximum-prefix {{ neighbor.maximum_prefix }}",
	"compval": "neighbor.maximum_prefix",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"maximum_prefix": "{{ num }}",
	},
	},
	},
	},
	{
	"name": "neighbor.nexthop_self",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+neighbor
	\s+(?P<address>\S+)
	\s+nexthop-self
	*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp neighbor {{ neighbor.address }} nexthop-self",
	"compval": "neighbor.nexthop_self",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"nexthop_self": "{{ True }}",
	},
	},
	},
	},
	{
	"name": "neighbor.override_capability",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+neighbor
	\s+(?P<address>\S+)
	\s+override-capability
	*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp neighbor {{ neighbor.address }} override-capability",
	"compval": "neighbor.override_capability",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"override_capability": "{{ True }}",
	},
	},
	},
	},
	{
	"name": "neighbor.passive",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+neighbor
	\s+(?P<address>\S+)
	\s+passive
	*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp neighbor {{ neighbor.address }} passive",
	"compval": "neighbor.passive",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"passive": "{{ True }}",
	},
	},
	},
	},
	{
	"name": "neighbor.password",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+neighbor
	\s+(?P<address>\S+)
	\s+password
	- \s+(?P<pwd>\S+)
	- *$""",
	+ \s+(?P<pwd>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp neighbor {{ neighbor.address }} password {{ neighbor.password }}",
	"compval": "neighbor.password",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"password": "{{ pwd }}",
	},
	},
	},
	},
	{
	"name": "neighbor.peer_group_name",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+neighbor
	\s+(?P<address>\S+)
	\s+peer-group
	- \s+(?P<name>\S+)
	- *$""",
	+ \s+(?P<name>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp neighbor {{ neighbor.address }} peer-group {{ neighbor.peer_group_name }}",
	"compval": "neighbor.peer_group_name",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"peer_group_name": "{{ name }}",
	},
	},
	},
	},
	{
	"name": "neighbor.port",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+neighbor
	\s+(?P<address>\S+)
	\s+port
	- \s+(?P<num>\S+)
	- *$""",
	+ \s+(?P<num>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp neighbor {{ neighbor.address }} port {{ neighbor.port }}",
	"compval": "neighbor.port",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"port": "{{ num\|int }}",
	},
	},
	},
	},
	{
	"name": "neighbor.prefix_list",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+neighbor
	\s+(?P<address>\S+)
	\s+prefix-list
	\s+(?P<action>export\|import)
	- \s+(?P<list>\S+)
	- *$""",
	+ \s+(?P<list>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_neighbor_prefix_list,
	"compval": "neighbor.prefix_list",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"prefix_list": [
	{
	"action": "{{ action }}",
	"prefix_list": "{{ list }}",
	},
	],
	},
	},
	},
	},
	{
	"name": "neighbor.remote_as",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+neighbor
	\s+(?P<address>\S+)
	\s+remote-as
	- \s+(?P<num>\S+)
	- *$""",
	+ \s+(?P<num>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp neighbor {{ neighbor.address }} remote-as {{ neighbor.remote_as }}",
	"compval": "neighbor.remote_as",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"remote_as": "{{ num\|int }}",
	},
	},
	},
	},
	{
	"name": "neighbor.remove_private_as",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+neighbor
	\s+(?P<address>\S+)
	\s+remote-private-as
	*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp neighbor {{ neighbor.address }} remote-private-as",
	"compval": "neighbor.remove_private_as",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"remove_private_as": "{{ True }}",
	},
	},
	},
	},
	{
	"name": "neighbor.route_map",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+neighbor
	\s+(?P<address>\S+)
	\s+route-map
	\s+(?P<action>export\|import)
	- \s+(?P<map>\S+)
	- *$""",
	+ \s+(?P<map>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_neighbor_route_map,
	"compval": "neighbor.route_map",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"route_map": [
	{
	"action": "{{ action }}",
	"route_map": "{{ map }}",
	},
	],
	},
	},
	},
	},
	{
	"name": "neighbor.route_reflector_client",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+neighbor
	\s+(?P<address>\S+)
	\s+route-reflector-client
	*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp neighbor {{ neighbor.address }} router-reflector-client",
	"compval": "neighbor.route_reflector_client",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"route_reflector_client": "{{ True }}",
	},
	},
	},
	},
	{
	"name": "neighbor.route_server_client",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+neighbor
	\s+(?P<address>\S+)
	\s+route-server-client
	*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp neighbor {{ neighbor.address }} route-server-client",
	"compval": "neighbor.route_server_client",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"route_server_client": "{{ True }}",
	},
	},
	},
	},
	{
	"name": "neighbor.shutdown",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+neighbor
	\s+(?P<address>\S+)
	\s+shutdown
	*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp neighbor {{ neighbor.address }} shutdown",
	"compval": "neighbor.shutdown",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"shutdown": "{{ True }}",
	},
	},
	},
	},
	{
	"name": "neighbor.soft_reconfiguration",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+neighbor
	\s+(?P<address>\S+)
	\s+soft-reconfiguration
	\s+inbound
	*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp neighbor {{ neighbor.address }} soft-reconfiguration",
	"compval": "neighbor.soft_reconfiguration",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"soft_reconfiguration": "{{ True }}",
	},
	},
	},
	},
	{
	"name": "neighbor.strict_capability_match",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+neighbor
	\s+(?P<address>\S+)
	\s+strict-capability-match
	*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp neighbor {{ neighbor.address }} strict-capability-match",
	"compval": "neighbor.strict_capability_match",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"strict_capability_match": "{{ True }}",
	},
	},
	},
	},
	{
	"name": "neighbor.unsuppress_map",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+neighbor
	\s+(?P<address>\S+)
	\s+unsuppress-map
	- \s+(?P<map>\S+)
	- *$""",
	+ \s+(?P<map>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp neighbor {{ neighbor.address }} unsuppress-map {{ neighbor.unsuppress_map }}",
	"compval": "neighbor.unsuppress_map",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"unsuppress_map": "{{ map }}",
	},
	},
	},
	},
	{
	"name": "neighbor.update_source",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+neighbor
	\s+(?P<address>\S+)
	\s+update-source
	- \s+(?P<src>\S+)
	- *$""",
	+ \s+(?P<src>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp neighbor {{ neighbor.address }} update-source {{ neighbor.update_source }}",
	"compval": "neighbor.update_source",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"update_source": "{{ src }}",
	},
	},
	},
	},
	{
	"name": "neighbor.weight",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+neighbor
	\s+(?P<address>\S+)
	\s+weight
	- \s+(?P<num>\S+)
	- *$""",
	+ \s+(?P<num>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp neighbor {{ neighbor.address }} weight {{ neighbor.weight }}",
	"compval": "neighbor.weight",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"weight": "{{ num }}",
	},
	},
	},
	},
	{
	"name": "neighbor.ttl_security",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+neighbor
	\s+(?P<address>\S+)
	\s+ttl-security
	- \s+(?P<ttl>\S+)
	- *$""",
	+ \s+(?P<ttl>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp neighbor {{ neighbor.address }} ttl-security {{ neighbor.ttl_security }}",
	"compval": "neighbor.ttl_security",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"ttl_security": "{{ ttl\|int }}",
	},
	},
	},
	},
	{
	"name": "neighbor.timers",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+neighbor
	\s+(?P<address>\S+)
	\s+timers
	\s+(?P<type>connect\|holdtime\|keepalive)
	- \s+(?P<sec>\S+)
	- *$""",
	+ \s+(?P<sec>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_neighbor_timers,
	"remval": "protocols bgp neighbor {{ neighbor.address }} timers",
	"compval": "neighbor.timers",
	"result": {
	"as_number": "{{ as_num }}",
	"neighbor": {
	"{{ address }}": {
	"address": "{{ address }}",
	"timers": {
	"{{ type }}": "{{ sec }}",
	},
	},
	},
	},
	},
	{
	"name": "timers",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+timers
	\s+(?P<type>\S+)
	- \s+(?P<val>\S+)
	- *$""",
	+ \s+(?P<val>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_timers,
	"remval": "protocols bgp timers",
	"compval": "timers",
	"result": {
	"as_number": "{{ as_num }}",
	"timers": {
	"{{ type }}": "{{ val }}",
	},
	},
	},
	{
	"name": "bgp_params.always_compare_med",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+parameters
	\s+always-compare-med
	*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp parameters always-compare-med",
	"compval": "bgp_params.always_compare_med",
	"result": {
	"as_number": "{{ as_num }}",
	"bgp_params": {
	"always_compare_med": "{{ True }}",
	},
	},
	},
	{
	"name": "bgp_params.bestpath.as_path",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+parameters
	\s+bestpath
	\s+as-path
	\s+(?P<path>confed\|ignore)
	*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp parameters bestpath as-path {{ bgp_params.bestpath.as_path }}",
	"compval": "bgp_params.bestpath.as_path",
	"result": {
	"as_number": "{{ as_num }}",
	"bgp_params": {
	"bestpath": {
	"as_path": "{{ path }}",
	},
	},
	},
	},
	{
	"name": "bgp_params.bestpath.compare_routerid",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+parameters
	\s+bestpath
	\s+compare-routerid
	*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp parameters bestpath compare-routerid",
	"compval": "bgp_params.bestpath.compare_routerid",
	"result": {
	"as_number": "{{ as_num }}",
	"bgp_params": {
	"bestpath": {
	"compare_routerid": "{{ True }}",
	},
	},
	},
	},
	{
	"name": "bgp_params.bestpath.med",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+parameters
	\s+bestpath
	\s+med
	\s+(?P<path>confed\|missing-as-worst)
	*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp parameters bestpath med {{ bestpath.med }}",
	"compval": "bgp_params.bestpath.med",
	"result": {
	"as_number": "{{ as_num }}",
	"bgp_params": {
	"bestpath": {
	"med": "{{ path }}",
	},
	},
	},
	},
	{
	"name": "bgp_params.cluster_id",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+parameters
	\s+cluster-id
	- \s+(?P<id>\S+)
	- *$""",
	+ \s+(?P<id>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp parameters cluster-id {{ bgp_params.cluster_id }}",
	"compval": "bgp_params.cluster_id",
	"result": {
	"as_number": "{{ as_num }}",
	"bgp_params": {
	"cluster_id": "{{ id }}",
	},
	},
	},
	{
	"name": "bgp_params.confederation",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+parameters
	\s+confederation
	\s+(?P<type>identifier\|peers)
	- \s+(?P<val>\S+)
	- *$""",
	+ \s+(?P<val>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_params_confederation,
	"compval": "bgp_params.always_compare_med",
	"result": {
	"as_number": "{{ as_num }}",
	"bgp_params": {
	"confederation": [
	{
	"peers": "{{ val if type == 'peers' }}",
	"identifier": "{{ val if type == 'identifier' }}",
	},
	],
	},
	},
	},
	{
	"name": "bgp_params.dampening_half_life",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+parameters
	\s+dampening
	\s+half-life
	- \s+(?P<val>\S+)
	- *$""",
	+ \s+(?P<val>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp parameters dampening half-life {{ bgp_params.dampening.half_life}}",
	"compval": "bgp_params.dampening.half_life",
	"result": {
	"as_number": "{{ as_num }}",
	"bgp_params": {
	"dampening": {
	"half_life": "{{ val }}",
	},
	},
	},
	},
	{
	"name": "bgp_params.dampening_max_suppress_time",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+parameters
	\s+dampening
	\s+max-suppress-time
	- \s+(?P<val>\S+)
	- *$""",
	+ \s+(?P<val>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp parameters dampening max-suppress-time {{ bgp_params.dampening.max_suppress_time}}",
	"compval": "bgp_params.dampening.max_suppress_time",
	"result": {
	"as_number": "{{ as_num }}",
	"bgp_params": {
	"dampening": {
	"max_suppress_time": "{{ val }}",
	},
	},
	},
	},
	{
	"name": "bgp_params.dampening_re_use",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+parameters
	\s+dampening
	\s+re-use
	- \s+(?P<val>\S+)
	- *$""",
	+ \s+(?P<val>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp parameters dampening re-use {{ bgp_params.dampening.re_use}}",
	"compval": "bgp_params.dampening.re_use",
	"result": {
	"as_number": "{{ as_num }}",
	"bgp_params": {
	"dampening": {
	"re_use": "{{ val }}",
	},
	},
	},
	},
	{
	"name": "bgp_params.dampening_start_suppress_time",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+parameters
	\s+dampening
	\s+start-suppress-time
	- \s+(?P<val>\S+)
	- *$""",
	+ \s+(?P<val>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp parameters dampening start-suppress-time {{ bgp_params.dampening.start_suppress_time}}",
	"compval": "bgp_params.dampening.start_suppress_time",
	"result": {
	"as_number": "{{ as_num }}",
	"bgp_params": {
	"dampening": {
	"start_suppress_time": "{{ val }}",
	},
	},
	},
	},
	{
	"name": "bgp_params.default",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+parameters
	\s+default
	- \s(?P<no_ipv4_unicast>no-ipv4-unicast)
	- \s*(?P<local_pref>local-pref\s\S+)
	- *$""",
	+ \s*(?P<no_ipv4_unicast>no-ipv4-unicast)?
	+ \s(?P<local_pref>local-pref\s\S+)?\s$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_params_default,
	"remval": "protocols bgp parameters default",
	"compval": "bgp_params.default",
	"result": {
	"as_number": "{{ as_num }}",
	"bgp_params": {
	"default": {
	"no_ipv4_unicast": "{{ True if no_ipv4_unicast is defined }}",
	"local_pref": "{{ local_pref.split(" " )[1] if local_pref is defined }}",
	},
	},
	},
	},
	{
	"name": "bgp_params.deterministic_med",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+parameters
	\s+deterministic-med
	*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp parameters deterministic-med",
	"compval": "bgp_params.deterministic_med",
	"result": {
	"as_number": "{{ as_num }}",
	"bgp_params": {
	"deterministic_med": "{{ True }}",
	},
	},
	},
	{
	"name": "bgp_params.disbale_network_import_check",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+parameters
	\s+disable-network-import-check
	*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp parameters disable-network-import-check",
	"compval": "bgp_params.disable_network_import_check",
	"result": {
	"as_number": "{{ as_num }}",
	"bgp_params": {
	"disable_network_import_check": "{{ True }}",
	},
	},
	},
	{
	"name": "bgp_params.distance.prefix",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+parameters
	\s+distance\sprefix
	\s+(?P<prefix>\S+)
	\s+distance
	- \s+(?P<val>\S+)
	- *$""",
	+ \s+(?P<val>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp parameters distance prefix {{ bgp_params.distance.prefix }} distance {{ bgp_params.distance.value }}",
	"compval": "bgp_params.distance.prefix",
	"remval": "protocols bgp parameters distance prefix",
	"result": {
	"as_number": "{{ as_num }}",
	"bgp_params": {
	"distance": [
	{
	"prefix": "{{ prefix }}",
	"value": "{{ val }}",
	},
	],
	},
	},
	},
	{
	"name": "bgp_params.distance.global",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+parameters
	\s+distance\sglobal
	\s+(?P<type>\S+)
	- \s+(?P<val>\S+)
	- *$""",
	+ \s+(?P<val>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_bgp_params_distance,
	"remval": "protocols bgp parameters distance global",
	"compval": "bgp_params.distance",
	"result": {
	"as_number": "{{ as_num }}",
	"bgp_params": {
	"distance": [
	{
	"type": "{{ type }}",
	"value": "{{ val }}",
	},
	],
	},
	},
	},
	{
	"name": "bgp_params.enforce_first_as",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+parameters
	\s+enforce-first-as
	*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp parameters enforce-first-as",
	"compval": "bgp_params.enforce_first_as",
	"result": {
	"as_number": "{{ as_num }}",
	"bgp_params": {
	"enforce_first_as": "{{ True }}",
	},
	},
	},
	{
	"name": "bgp_params.graceful_restart",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+parameters
	\s+graceful-restart\s+stalepath-time
	- \s+(?P<val>\S+)
	- *$""",
	+ \s+(?P<val>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp parameters graceful-restart stalepath-time {{ bgp_params.graceful_restart }}",
	"compval": "bgp_params.graceful_restart",
	"result": {
	"as_number": "{{ as_num }}",
	"bgp_params": {
	"graceful_restart": "{{ val }}",
	},
	},
	},
	{
	"name": "bgp_params.log_neighbor_changes",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+parameters
	\s+log-neighbor-changes
	*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp parameters log-neighbor-changes",
	"compval": "bgp_params.log_neighbor_changes",
	"result": {
	"as_number": "{{ as_num }}",
	"bgp_params": {
	"log_neighbor_changes": "{{ True }}",
	},
	},
	},
	{
	"name": "bgp_params.no_client_to_client_reflection",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+parameters
	\s+no-client-to-client-reflection
	*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp parameters no-client-to-client-reflection",
	"compval": "bgp_params.log_neighbor_changes",
	"result": {
	"as_number": "{{ as_num }}",
	"bgp_params": {
	"no_client_to_client_reflection": "{{ True }}",
	},
	},
	},
	{
	"name": "bgp_params.no_fast_external_failover",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+parameters
	\s+no-fast-external-failover
	*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp parameters no-fast-external-failover",
	"compval": "bgp_params.no_fast_external_failover",
	"result": {
	"as_number": "{{ as_num }}",
	"bgp_params": {
	"no_fast_external_failover": "{{ True }}",
	},
	},
	},
	{
	"name": "bgp_params.routerid",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+parameters
	\s+router-id
	- \s+(?P<id>\S+)
	- *$""",
	+ \s+(?P<id>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp parameters router-id {{ bgp_params.router_id }}",
	"compval": "bgp_params.router_id",
	"result": {
	"as_number": "{{ as_num }}",
	"bgp_params": {
	"router_id": "{{ id }}",
	},
	},
	},
	{
	"name": "bgp_params.scan_time",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+bgp
	\s+parameters
	\s+scan-time
	\s+(?P<sec>\d+)
	*$""",
	re.VERBOSE,
	),
	"setval": "protocols bgp parameters scan-time {{ bgp_params.scan_time }}",
	"compval": "bgp_params.scan_time",
	"result": {
	"as_number": "{{ as_num }}",
	"bgp_params": {
	"scan_time": "{{ val }}",
	},
	},
	},
	]
	# fmt: on
	diff --git a/plugins/module_utils/network/vyos/rm_templates/ospf_interfaces.py b/plugins/module_utils/network/vyos/rm_templates/ospf_interfaces.py
	index 134effca..af04da3b 100644
	--- a/plugins/module_utils/network/vyos/rm_templates/ospf_interfaces.py
	+++ b/plugins/module_utils/network/vyos/rm_templates/ospf_interfaces.py
	@@ -1,776 +1,773 @@
	# -- coding: utf-8 --
	# Copyright 2020 Red Hat
	# GNU General Public License v3.0+
	# (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)

	from __future__ import absolute_import, division, print_function


	__metaclass__ = type

	"""
	The Ospf_interfaces parser templates file. This contains
	a list of parser definitions and associated functions that
	facilitates both facts gathering and native command generation for
	the given network resource.
	"""

	import re

	from ansible_collections.ansible.netcommon.plugins.module_utils.network.common.rm_base.network_template import (
	NetworkTemplate,
	)

	from ansible_collections.vyos.vyos.plugins.module_utils.network.vyos.utils.utils import (
	get_interface_type,
	get_interface_with_vif,
	)


	def _get_parameters(data):
	if data["afi"] == "ipv6":
	val = ["ospfv3", "ipv6"]
	else:
	val = ["ospf", "ip"]
	return val


	def _tmplt_ospf_int_delete(config_data):
	int_type = get_interface_type(config_data["name"])
	name = get_interface_with_vif(config_data["name"])
	params = _get_parameters(config_data["address_family"])
	command = "interfaces " + int_type + " " + name + " " + params[1] + " " + params[0]

	return command


	def _tmplt_ospf_int_cost(config_data):
	int_type = get_interface_type(config_data["name"])
	name = get_interface_with_vif(config_data["name"])
	params = _get_parameters(config_data["address_family"])
	command = (
	"interfaces "
	+ int_type
	+ " "
	+ name
	+ " "
	+ params[1]
	+ " "
	+ params[0]
	+ " cost {cost}".format(**config_data["address_family"])
	)

	return command


	def _tmplt_ospf_int_auth_password(config_data):
	int_type = get_interface_type(config_data["name"])
	name = get_interface_with_vif(config_data["name"])
	params = _get_parameters(config_data["address_family"])
	command = (
	"interfaces "
	+ int_type
	+ " "
	+ name
	+ " "
	+ params[1]
	+ " "
	+ params[0]
	+ " authentication plaintext-password {plaintext_password}".format(
	**config_data["address_family"]["authentication"],
	)
	)
	return command


	def _tmplt_ospf_int_auth_md5(config_data):
	int_type = get_interface_type(config_data["name"])
	name = get_interface_with_vif(config_data["name"])
	params = _get_parameters(config_data["address_family"])
	command = (
	"interfaces "
	+ int_type
	+ " "
	+ name
	+ " "
	+ params[1]
	+ " "
	+ params[0]
	+ " authentication md5 key-id {key_id} ".format(
	**config_data["address_family"]["authentication"]["md5_key"],
	)
	+ "md5-key {key}".format(**config_data["address_family"]["authentication"]["md5_key"])
	)

	return command


	def _tmplt_ospf_int_auth_md5_delete(config_data):
	int_type = get_interface_type(config_data["name"])
	name = get_interface_with_vif(config_data["name"])
	params = _get_parameters(config_data["address_family"])
	command = (
	"interfaces "
	+ int_type
	+ " "
	+ name
	+ " "
	+ params[1]
	+ " "
	+ params[0]
	+ " authentication"
	)

	return command


	def _tmplt_ospf_int_bw(config_data):
	int_type = get_interface_type(config_data["name"])
	name = get_interface_with_vif(config_data["name"])
	params = _get_parameters(config_data["address_family"])
	command = (
	"interfaces "
	+ int_type
	+ " "
	+ name
	+ " "
	+ params[1]
	+ " "
	+ params[0]
	+ " bandwidth {bandwidth}".format(**config_data["address_family"])
	)

	return command


	def _tmplt_ospf_int_hello_interval(config_data):
	int_type = get_interface_type(config_data["name"])
	name = get_interface_with_vif(config_data["name"])
	params = _get_parameters(config_data["address_family"])
	command = (
	"interfaces "
	+ int_type
	+ " "
	+ name
	+ " "
	+ params[1]
	+ " "
	+ params[0]
	+ " hello-interval {hello_interval}".format(**config_data["address_family"])
	)

	return command


	def _tmplt_ospf_int_dead_interval(config_data):
	int_type = get_interface_type(config_data["name"])
	name = get_interface_with_vif(config_data["name"])
	params = _get_parameters(config_data["address_family"])
	command = (
	"interfaces "
	+ int_type
	+ " "
	+ name
	+ " "
	+ params[1]
	+ " "
	+ params[0]
	+ " dead-interval {dead_interval}".format(**config_data["address_family"])
	)

	return command


	def _tmplt_ospf_int_mtu_ignore(config_data):
	int_type = get_interface_type(config_data["name"])
	name = get_interface_with_vif(config_data["name"])
	params = _get_parameters(config_data["address_family"])
	command = (
	"interfaces " + int_type + " " + name + " " + params[1] + " " + params[0] + " mtu-ignore"
	)

	return command


	def _tmplt_ospf_int_network(config_data):
	int_type = get_interface_type(config_data["name"])
	name = get_interface_with_vif(config_data["name"])
	params = _get_parameters(config_data["address_family"])
	command = (
	"interfaces "
	+ int_type
	+ " "
	+ name
	+ " "
	+ params[1]
	+ " "
	+ params[0]
	+ " network {network}".format(**config_data["address_family"])
	)

	return command


	def _tmplt_ospf_int_priority(config_data):
	int_type = get_interface_type(config_data["name"])
	name = get_interface_with_vif(config_data["name"])
	params = _get_parameters(config_data["address_family"])
	command = (
	"interfaces "
	+ int_type
	+ " "
	+ name
	+ " "
	+ params[1]
	+ " "
	+ params[0]
	+ " priority {priority}".format(**config_data["address_family"])
	)

	return command


	def _tmplt_ospf_int_retransmit_interval(config_data):
	int_type = get_interface_type(config_data["name"])
	name = get_interface_with_vif(config_data["name"])
	params = _get_parameters(config_data["address_family"])
	command = (
	"interfaces "
	+ int_type
	+ " "
	+ name
	+ " "
	+ params[1]
	+ " "
	+ params[0]
	+ " retransmit-interval {retransmit_interval}".format(**config_data["address_family"])
	)

	return command


	def _tmplt_ospf_int_transmit_delay(config_data):
	int_type = get_interface_type(config_data["name"])
	name = get_interface_with_vif(config_data["name"])
	params = _get_parameters(config_data["address_family"])
	command = (
	"interfaces "
	+ int_type
	+ " "
	+ name
	+ " "
	+ params[1]
	+ " "
	+ params[0]
	+ " transmit-delay {transmit_delay}".format(**config_data["address_family"])
	)

	return command


	def _tmplt_ospf_int_ifmtu(config_data):
	int_type = get_interface_type(config_data["name"])
	name = get_interface_with_vif(config_data["name"])
	params = _get_parameters(config_data["address_family"])
	command = (
	"interfaces "
	+ int_type
	+ " "
	+ name
	+ " "
	+ params[1]
	+ " "
	+ params[0]
	+ " ifmtu {ifmtu}".format(**config_data["address_family"])
	)

	return command


	def _tmplt_ospf_int_instance(config_data):
	int_type = get_interface_type(config_data["name"])
	name = get_interface_with_vif(config_data["name"])
	params = _get_parameters(config_data["address_family"])
	command = (
	"interfaces "
	+ int_type
	+ " "
	+ name
	+ " "
	+ params[1]
	+ " "
	+ params[0]
	+ " instance-id {instance}".format(**config_data["address_family"])
	)

	return command


	def _tmplt_ospf_int_passive(config_data):
	int_type = get_interface_type(config_data["name"])
	name = get_interface_with_vif(config_data["name"])
	params = _get_parameters(config_data["address_family"])
	command = "interfaces " + int_type + " " + name + " " + params[1] + " " + params[0] + " passive"

	return command


	class Ospf_interfacesTemplate(NetworkTemplate):
	def __init__(self, lines=None, module=None):
	prefix = {"set": "set", "remove": "delete"}
	super(Ospf_interfacesTemplate, self).__init__(
	lines=lines,
	tmplt=self,
	prefix=prefix,
	module=module,
	)

	# fmt: off
	PARSERS = [
	{
	"name": "ip_ospf",
	"getval": re.compile(
	r"""
	^set
	\s+interfaces
	\s+(?P<type>\S+)
	\s+(?P<name>\S+)
	(?:\s+vif\s+(?P<vif>\d+))?
	\s+(?P<afi>ip\|ipv6)
	\s+(?P<proto>ospf\|ospfv3)
	*$""",
	re.VERBOSE,
	),
	"remval": _tmplt_ospf_int_delete,
	"compval": "address_family",
	"result": {
	"name": "{{ name + '.' + vif if vif is defined else name }}",
	"address_family": {
	"{{ afi }}": {
	"afi": '{{ "ipv4" if afi == "ip" else "ipv6" }}',
	},
	},
	},
	},
	{
	"name": "authentication_password",
	"getval": re.compile(
	r"""
	^set
	\s+interfaces
	\s+(?P<type>\S+)
	\s+(?P<name>\S+)
	(?:\s+vif\s+(?P<vif>\d+))?
	\s+(?P<afi>ip\|ipv6)
	\s+(?P<proto>ospf\|ospfv3)
	\s+authentication
	\s+plaintext-password
	- \s+(?P<text>\S+)
	- *$""",
	+ \s+(?P<text>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_ospf_int_auth_password,
	"compval": "address_family.authentication",
	"result": {
	"name": "{{ name + '.' + vif if vif is defined else name }}",
	"address_family": {
	"{{ afi }}": {
	"afi": '{{ "ipv4" if afi == "ip" else "ipv6" }}',
	"authentication": {
	"plaintext_password": "{{ text }}",
	},
	},
	},
	},
	},
	{
	"name": "authentication_md5",
	"getval": re.compile(
	r"""
	^set
	\s+interfaces
	\s+(?P<type>\S+)
	\s+(?P<name>\S+)
	(?:\s+vif\s+(?P<vif>\d+))?
	\s+(?P<afi>ip\|ipv6)
	\s+(?P<proto>ospf\|ospfv3)
	\s+authentication
	\s+md5
	\s+key-id
	\s+(?P<id>\d+)
	\s+md5-key
	- \s+(?P<text>\S+)
	- *$""",
	+ \s+(?P<text>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_ospf_int_auth_md5,
	"remval": _tmplt_ospf_int_auth_md5_delete,
	"compval": "address_family.authentication",
	"result": {
	"name": "{{ name + '.' + vif if vif is defined else name }}",
	"address_family": {
	"{{ afi }}": {
	"afi": '{{ "ipv4" if afi == "ip" else "ipv6" }}',
	"authentication": {
	"md5_key": {
	"key_id": "{{ id }}",
	"key": "{{ text }}",
	},
	},
	},
	},
	},
	},
	{
	"name": "bandwidth",
	"getval": re.compile(
	r"""
	^set
	\s+interfaces
	\s+(?P<type>\S+)
	\s+(?P<name>\S+)
	(?:\s+vif\s+(?P<vif>\d+))?
	\s+(?P<afi>ip\|ipv6)
	\s+(?P<proto>ospf\|ospfv3)
	\s+bandwidth
	\s+(?P<bw>\'\d+\')
	*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_ospf_int_bw,
	"compval": "address_family.bandwidth",
	"result": {
	"name": "{{ name + '.' + vif if vif is defined else name }}",
	"address_family": {
	"{{ afi }}": {
	"afi": '{{ "ipv4" if afi == "ip" else "ipv6" }}',
	"bandwidth": "{{ bw }}",
	},
	},
	},
	},
	{
	"name": "cost",
	"getval": re.compile(
	r"""
	^set
	\s+interfaces
	\s+(?P<type>\S+)
	\s+(?P<name>\S+)
	(?:\s+vif\s+(?P<vif>\d+))?
	\s+(?P<afi>ip\|ipv6)
	\s+(?P<proto>ospf\|ospfv3)
	\s+cost
	\s+(?P<val>\'\d+\')
	*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_ospf_int_cost,
	"compval": "address_family.cost",
	"result": {
	"name": "{{ name + '.' + vif if vif is defined else name }}",
	"address_family": {
	"{{ afi }}": {
	"afi": '{{ "ipv4" if afi == "ip" else "ipv6" }}',
	"cost": "{{ val }}",
	},
	},
	},
	},
	{
	"name": "hello_interval",
	"getval": re.compile(
	r"""
	^set
	\s+interfaces
	\s+(?P<type>\S+)
	\s+(?P<name>\S+)
	(?:\s+vif\s+(?P<vif>\d+))?
	\s+(?P<afi>ip\|ipv6)
	\s+(?P<proto>ospf\|ospfv3)
	\s+hello-interval
	\s+(?P<val>\'\d+\')
	*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_ospf_int_hello_interval,
	"compval": "address_family.hello_interval",
	"result": {
	"name": "{{ name + '.' + vif if vif is defined else name }}",
	"address_family": {
	"{{ afi }}": {
	"afi": '{{ "ipv4" if afi == "ip" else "ipv6" }}',
	"hello_interval": "{{ val }}",
	},
	},
	},
	},
	{
	"name": "dead_interval",
	"getval": re.compile(
	r"""
	^set
	\s+interfaces
	\s+(?P<type>\S+)
	\s+(?P<name>\S+)
	(?:\s+vif\s+(?P<vif>\d+))?
	\s+(?P<afi>ip\|ipv6)
	\s+(?P<proto>ospf\|ospfv3)
	\s+dead-interval
	\s+(?P<val>\'\d+\')
	*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_ospf_int_dead_interval,
	"compval": "address_family.dead_interval",
	"result": {
	"name": "{{ name + '.' + vif if vif is defined else name }}",
	"address_family": {
	"{{ afi }}": {
	"afi": '{{ "ipv4" if afi == "ip" else "ipv6" }}',
	"dead_interval": "{{ val }}",
	},
	},
	},
	},
	{
	"name": "mtu_ignore",
	"getval": re.compile(
	r"""
	^set
	\s+interfaces
	\s+(?P<type>\S+)
	\s+(?P<name>\S+)
	(?:\s+vif\s+(?P<vif>\d+))?
	\s+(?P<afi>ip\|ipv6)
	\s+(?P<proto>ospf\|ospfv3)
	\s+(?P<mtu>mtu-ignore)
	*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_ospf_int_mtu_ignore,
	"compval": "address_family.mtu_ignore",
	"result": {
	"name": "{{ name + '.' + vif if vif is defined else name }}",
	"address_family": {
	"{{ afi }}": {
	"afi": '{{ "ipv4" if afi == "ip" else "ipv6" }}',
	"mtu_ignore": "{{ True if mtu is defined }}",
	},
	},
	},
	},
	{
	"name": "network",
	"getval": re.compile(
	r"""
	^set
	\s+interfaces
	\s+(?P<type>\S+)
	\s+(?P<name>\S+)
	(?:\s+vif\s+(?P<vif>\d+))?
	\s+(?P<afi>ip\|ipv6)
	\s+(?P<proto>ospf\|ospfv3)
	\s+network
	- \s+(?P<val>\S+)
	- *$""",
	+ \s+(?P<val>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_ospf_int_network,
	"compval": "address_family.network",
	"result": {
	"name": "{{ name + '.' + vif if vif is defined else name }}",
	"address_family": {
	"{{ afi }}": {
	"afi": '{{ "ipv4" if afi == "ip" else "ipv6" }}',
	"network": "{{ val }}",
	},
	},
	},
	},
	{
	"name": "priority",
	"getval": re.compile(
	r"""
	^set
	\s+interfaces
	\s+(?P<type>\S+)
	\s+(?P<name>\S+)
	(?:\s+vif\s+(?P<vif>\d+))?
	\s+(?P<afi>ip\|ipv6)
	\s+(?P<proto>ospf\|ospfv3)
	\s+priority
	\s+(?P<val>\'\d+\')
	*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_ospf_int_priority,
	"compval": "address_family.priority",
	"result": {
	"name": "{{ name + '.' + vif if vif is defined else name }}",
	"address_family": {
	"{{ afi }}": {
	"afi": '{{ "ipv4" if afi == "ip" else "ipv6" }}',
	"priority": "{{ val }}",
	},
	},
	},
	},
	{
	"name": "retransmit_interval",
	"getval": re.compile(
	r"""
	^set
	\s+interfaces
	\s+(?P<type>\S+)
	\s+(?P<name>\S+)
	(?:\s+vif\s+(?P<vif>\d+))?
	\s+(?P<afi>ip\|ipv6)
	\s+(?P<proto>ospf\|ospfv3)
	\s+retransmit-interval
	\s+(?P<val>\'\d+\')
	*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_ospf_int_retransmit_interval,
	"compval": "address_family.retransmit_interval",
	"result": {
	"name": "{{ name + '.' + vif if vif is defined else name }}",
	"address_family": {
	"{{ afi }}": {
	"afi": '{{ "ipv4" if afi == "ip" else "ipv6" }}',
	"retransmit_interval": "{{ val }}",
	},
	},
	},
	},
	{
	"name": "transmit_delay",
	"getval": re.compile(
	r"""
	^set
	\s+interfaces
	\s+(?P<type>\S+)
	\s+(?P<name>\S+)
	(?:\s+vif\s+(?P<vif>\d+))?
	\s+(?P<afi>ip\|ipv6)
	\s+(?P<proto>ospf\|ospfv3)
	\s+transmit-delay
	\s+(?P<val>\'\d+\')
	*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_ospf_int_transmit_delay,
	"compval": "address_family.transmit_delay",
	"result": {
	"name": "{{ name + '.' + vif if vif is defined else name }}",
	"address_family": {
	"{{ afi }}": {
	"afi": '{{ "ipv4" if afi == "ip" else "ipv6" }}',
	"transmit_delay": "{{ val }}",
	},
	},
	},
	},
	{
	"name": "ifmtu",
	"getval": re.compile(
	r"""
	^set
	\s+interfaces
	\s+(?P<type>\S+)
	\s+(?P<name>\S+)
	(?:\s+vif\s+(?P<vif>\d+))?
	\s+(?P<afi>ip\|ipv6)
	\s+(?P<proto>ospf\|ospfv3)
	\s+ifmtu
	\s+(?P<val>\'\d+\')
	*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_ospf_int_ifmtu,
	"compval": "address_family.ifmtu",
	"result": {
	"name": "{{ name + '.' + vif if vif is defined else name }}",
	"address_family": {
	"{{ afi }}": {
	"afi": '{{ "ipv4" if afi == "ip" else "ipv6" }}',
	"ifmtu": "{{ val }}",
	},
	},
	},
	},
	{
	"name": "instance",
	"getval": re.compile(
	r"""
	^set
	\s+interfaces
	\s+(?P<type>\S+)
	\s+(?P<name>\S+)
	(?:\s+vif\s+(?P<vif>\d+))?
	\s+(?P<afi>ip\|ipv6)
	\s+(?P<proto>ospf\|ospfv3)
	\s+instance-id
	\s+(?P<val>\'\d+\')
	*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_ospf_int_instance,
	"compval": "address_family.instance",
	"result": {
	"name": "{{ name + '.' + vif if vif is defined else name }}",
	"address_family": {
	"{{ afi }}": {
	"afi": '{{ "ipv4" if afi == "ip" else "ipv6" }}',
	"instance": "{{ val }}",
	},
	},
	},
	},
	{
	"name": "passive",
	"getval": re.compile(
	r"""
	^set
	\s+interfaces
	\s+(?P<type>\S+)
	\s+(?P<name>\S+)
	(?:\s+vif\s+(?P<vif>\d+))?
	\s+(?P<afi>ip\|ipv6)
	\s+(?P<proto>ospf\|ospfv3)
	\s+(?P<pass>passive)
	*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_ospf_int_passive,
	"compval": "address_family.passive",
	"result": {
	"name": "{{ name + '.' + vif if vif is defined else name }}",
	"address_family": {
	"{{ afi }}": {
	"afi": '{{ "ipv4" if afi == "ip" else "ipv6" }}',
	"passive": "{{ True if pass is defined }}",
	},
	},
	},
	},
	{
	"name": "interface_name",
	"getval": re.compile(
	r"""
	^set
	\s+interfaces
	\s+(?P<type>\S+)
	\s+(?P<name>\S+)
	(?:\s+vif\s+(?P<vif>\d+))?
	.*$""",
	re.VERBOSE,
	),
	"setval": "set interface {{ type }} {{ name }}",
	"result": {
	"name": "{{ name + '.' + vif if vif is defined else name }}",
	},
	},
	]
	# fmt: on
	diff --git a/plugins/module_utils/network/vyos/rm_templates/ospf_interfaces_14.py b/plugins/module_utils/network/vyos/rm_templates/ospf_interfaces_14.py
	index 0d3aa5a7..484d7c44 100644
	--- a/plugins/module_utils/network/vyos/rm_templates/ospf_interfaces_14.py
	+++ b/plugins/module_utils/network/vyos/rm_templates/ospf_interfaces_14.py
	@@ -1,651 +1,647 @@
	# -- coding: utf-8 --
	# Copyright 2020 Red Hat
	# GNU General Public License v3.0+
	# (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)

	from __future__ import absolute_import, division, print_function


	__metaclass__ = type

	"""
	The Ospf_interfaces parser templates file. This contains
	a list of parser definitions and associated functions that
	facilitates both facts gathering and native command generation for
	the given network resource.
	"""

	import re

	from ansible_collections.ansible.netcommon.plugins.module_utils.network.common.rm_base.network_template import (
	NetworkTemplate,
	)


	def _get_parameters(data):
	if data["afi"] == "ipv6":
	val = ["ospfv3", "ipv6"]
	else:
	val = ["ospf", "ip"]
	return val


	def _tmplt_ospf_int_delete(config_data):
	params = _get_parameters(config_data["address_family"])
	command = (
	"protocols " + params[0] + " interface {name}".format(**config_data)
	)

	return command


	def _tmplt_ospf_int_cost(config_data):
	params = _get_parameters(config_data["address_family"])
	command = (
	"protocols "
	+ params[0]
	+ " interface {name}".format(**config_data)
	+ " cost {cost}".format(**config_data["address_family"])
	)

	return command


	def _tmplt_ospf_int_auth_password(config_data):
	params = _get_parameters(config_data["address_family"])
	command = (
	"protocols "
	+ params[0]
	+ " interface {name}".format(**config_data)
	+ " authentication plaintext-password {plaintext_password}".format(
	**config_data["address_family"]["authentication"]
	)
	)
	return command


	def _tmplt_ospf_int_auth_md5(config_data):
	params = _get_parameters(config_data["address_family"])
	command = (
	"protocols "
	+ params[0]
	+ " interface {name}".format(**config_data)
	+ " authentication md5 key-id {key_id} ".format(
	**config_data["address_family"]["authentication"]["md5_key"]
	)
	+ "md5-key {key}".format(**config_data["address_family"]["authentication"]["md5_key"])
	)

	return command


	def _tmplt_ospf_int_auth_md5_delete(config_data):
	params = _get_parameters(config_data["address_family"])
	command = (
	"protocols "
	+ params[0]
	+ " interface {name}".format(**config_data)
	+ " authentication"
	)

	return command


	def _tmplt_ospf_int_bw(config_data):
	params = _get_parameters(config_data["address_family"])
	command = (
	"protocols "
	+ params[0]
	+ " interface {name}".format(**config_data)
	+ " bandwidth {bandwidth}".format(**config_data["address_family"])
	)

	return command


	def _tmplt_ospf_int_hello_interval(config_data):
	params = _get_parameters(config_data["address_family"])
	command = (
	"protocols "
	+ params[0]
	+ " interface {name}".format(**config_data)
	+ " hello-interval {hello_interval}".format(**config_data["address_family"])
	)

	return command


	def _tmplt_ospf_int_dead_interval(config_data):
	params = _get_parameters(config_data["address_family"])
	command = (
	"protocols "
	+ params[0]
	+ " interface {name}".format(**config_data)
	+ " dead-interval {dead_interval}".format(**config_data["address_family"])
	)

	return command


	def _tmplt_ospf_int_mtu_ignore(config_data):
	params = _get_parameters(config_data["address_family"])
	command = (
	"protocols "
	+ params[0]
	+ " interface {name}".format(**config_data)
	+ " mtu-ignore"
	)

	return command


	def _tmplt_ospf_int_network(config_data):
	params = _get_parameters(config_data["address_family"])
	command = (
	"protocols "
	+ params[0]
	+ " interface {name}".format(**config_data)
	+ " network {network}".format(**config_data["address_family"])
	)

	return command


	def _tmplt_ospf_int_priority(config_data):
	params = _get_parameters(config_data["address_family"])
	command = (
	"protocols "
	+ params[0]
	+ " interface {name}".format(**config_data)
	+ " priority {priority}".format(**config_data["address_family"])
	)

	return command


	def _tmplt_ospf_int_retransmit_interval(config_data):
	params = _get_parameters(config_data["address_family"])
	command = (
	"protocols "
	+ params[0]
	+ " interface {name}".format(**config_data)
	+ " retransmit-interval {retransmit_interval}".format(**config_data["address_family"])
	)

	return command


	def _tmplt_ospf_int_transmit_delay(config_data):
	params = _get_parameters(config_data["address_family"])
	command = (
	"protocols "
	+ params[0]
	+ " interface {name}".format(**config_data)
	+ " transmit-delay {transmit_delay}".format(**config_data["address_family"])
	)

	return command


	def _tmplt_ospf_int_ifmtu(config_data):
	params = _get_parameters(config_data["address_family"])
	command = (
	"protocols "
	+ params[0]
	+ " interface {name}".format(**config_data)
	+ " ifmtu {ifmtu}".format(**config_data["address_family"])
	)

	return command


	def _tmplt_ospf_int_instance(config_data):
	params = _get_parameters(config_data["address_family"])
	command = (
	"protocols "
	+ params[0]
	+ " interface {name}".format(**config_data)
	+ " instance-id {instance}".format(**config_data["address_family"])
	)

	return command


	def _tmplt_ospf_int_passive(config_data):
	params = _get_parameters(config_data["address_family"])
	command = (
	"protocols "
	+ params[0]
	+ " interface {name}".format(**config_data)
	+ " passive"
	)

	return command


	class Ospf_interfacesTemplate14(NetworkTemplate):
	def __init__(self, lines=None, module=None):
	prefix = {"set": "set", "remove": "delete"}
	super(Ospf_interfacesTemplate14, self).__init__(
	lines=lines, tmplt=self, prefix=prefix, module=module
	)

	# fmt: off
	PARSERS = [
	{
	"name": "ip_ospf",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+(?P<proto>ospf\|ospfv3)
	\s+interface
	- \s+(?P<name>\S+)
	- *$""",
	+ \s+(?P<name>\S+)\s*$""",
	re.VERBOSE,
	),
	"remval": _tmplt_ospf_int_delete,
	"compval": "address_family",
	"result": {
	"name": "{{ name }}",
	"address_family": {
	'{{ "ipv4" if proto == "ospf" else "ipv6" }}': {
	"afi": '{{ "ipv4" if proto == "ospf" else "ipv6" }}',
	}
	}
	}
	},
	{
	"name": "authentication_password",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+(?P<proto>ospf\|ospfv3)
	\s+interface
	\s+(?P<name>\S+)
	\s+authentication
	\s+plaintext-password
	- \s+(?P<text>\S+)
	- *$""",
	+ \s+(?P<text>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_ospf_int_auth_password,
	"compval": "address_family.authentication",
	"result": {
	"name": "{{ name }}",
	"address_family": {
	'{{ "ipv4" if proto == "ospf" else "ipv6" }}': {
	"afi": '{{ "ipv4" if proto == "ospf" else "ipv6" }}',
	"authentication": {
	"plaintext_password": "{{ text }}"
	}
	}
	}
	}
	},
	{
	"name": "authentication_md5",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+(?P<proto>ospf\|ospfv3)
	\s+interface
	\s+(?P<name>\S+)
	\s+authentication
	\s+md5
	\s+key-id
	\s+(?P<id>\d+)
	\s+md5-key
	- \s+(?P<text>\S+)
	- *$""",
	+ \s+(?P<text>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_ospf_int_auth_md5,
	"remval": _tmplt_ospf_int_auth_md5_delete,
	"compval": "address_family.authentication",
	"result": {
	"name": "{{ name }}",
	"address_family": {
	'{{ "ipv4" if proto == "ospf" else "ipv6" }}': {
	"afi": '{{ "ipv4" if proto == "ospf" else "ipv6" }}',
	"authentication": {
	"md5_key": {
	"key_id": "{{ id }}",
	"key": "{{ text }}"
	}
	}
	}
	}
	}
	},
	{
	"name": "bandwidth",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+(?P<proto>ospf\|ospfv3)
	\s+interface
	\s+(?P<name>\S+)
	\s+bandwidth
	\s+(?P<bw>\'\d+\')
	*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_ospf_int_bw,
	"compval": "address_family.bandwidth",
	"result": {
	"name": "{{ name }}",
	"address_family": {
	'{{ "ipv4" if proto == "ospf" else "ipv6" }}': {
	"afi": '{{ "ipv4" if proto == "ospf" else "ipv6" }}',
	"bandwidth": "{{ bw }}"
	}
	}
	}
	},
	{
	"name": "cost",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+(?P<proto>ospf\|ospfv3)
	\s+interface
	\s+(?P<name>\S+)
	\s+cost
	\s+(?P<val>\'\d+\')
	*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_ospf_int_cost,
	"compval": "address_family.cost",
	"result": {
	"name": "{{ name }}",
	"address_family": {
	'{{ "ipv4" if proto == "ospf" else "ipv6" }}': {
	"afi": '{{ "ipv4" if proto == "ospf" else "ipv6" }}',
	"cost": "{{ val }}"
	}
	}
	}
	},
	{
	"name": "hello_interval",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+(?P<proto>ospf\|ospfv3)
	\s+interface
	\s+(?P<name>\S+)
	\s+hello-interval
	\s+(?P<val>\'\d+\')
	*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_ospf_int_hello_interval,
	"compval": "address_family.hello_interval",
	"result": {
	"name": "{{ name }}",
	"address_family": {
	'{{ "ipv4" if proto == "ospf" else "ipv6" }}': {
	"afi": '{{ "ipv4" if proto == "ospf" else "ipv6" }}',
	"hello_interval": "{{ val }}"
	}
	}
	}
	},
	{
	"name": "dead_interval",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+(?P<proto>ospf\|ospfv3)
	\s+interface
	\s+(?P<name>\S+)
	\s+dead-interval
	\s+(?P<val>\'\d+\')
	*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_ospf_int_dead_interval,
	"compval": "address_family.dead_interval",
	"result": {
	"name": "{{ name }}",
	"address_family": {
	'{{ "ipv4" if proto == "ospf" else "ipv6" }}': {
	"afi": '{{ "ipv4" if proto == "ospf" else "ipv6" }}',
	"dead_interval": "{{ val }}"
	}
	}
	}
	},
	{
	"name": "mtu_ignore",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+(?P<proto>ospf\|ospfv3)
	\s+interface
	\s+(?P<name>\S+)
	\s+(?P<mtu>mtu-ignore)
	*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_ospf_int_mtu_ignore,
	"compval": "address_family.mtu_ignore",
	"result": {
	"name": "{{ name }}",
	"address_family": {
	'{{ "ipv4" if proto == "ospf" else "ipv6" }}': {
	"afi": '{{ "ipv4" if proto == "ospf" else "ipv6" }}',
	"mtu_ignore": "{{ True if mtu is defined }}"
	}
	}
	}
	},
	{
	"name": "network",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+(?P<proto>ospf\|ospfv3)
	\s+interface
	\s+(?P<name>\S+)
	\s+network
	- \s+(?P<val>\S+)
	- *$""",
	+ \s+(?P<val>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_ospf_int_network,
	"compval": "address_family.network",
	"result": {
	"name": "{{ name }}",
	"address_family": {
	'{{ "ipv4" if proto == "ospf" else "ipv6" }}': {
	"afi": '{{ "ipv4" if proto == "ospf" else "ipv6" }}',
	"network": "{{ val }}"
	}
	}
	}
	},
	{
	"name": "priority",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+(?P<proto>ospf\|ospfv3)
	\s+interface
	\s+(?P<name>\S+)
	\s+priority
	\s+(?P<val>\'\d+\')
	*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_ospf_int_priority,
	"compval": "address_family.priority",
	"result": {
	"name": "{{ name }}",
	"address_family": {
	'{{ "ipv4" if proto == "ospf" else "ipv6" }}': {
	"afi": '{{ "ipv4" if proto == "ospf" else "ipv6" }}',
	"priority": "{{ val }}"
	}
	}
	}
	},
	{
	"name": "retransmit_interval",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+(?P<proto>ospf\|ospfv3)
	\s+interface
	\s+(?P<name>\S+)
	\s+retransmit-interval
	\s+(?P<val>\'\d+\')
	*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_ospf_int_retransmit_interval,
	"compval": "address_family.retransmit_interval",
	"result": {
	"name": "{{ name }}",
	"address_family": {
	'{{ "ipv4" if proto == "ospf" else "ipv6" }}': {
	"afi": '{{ "ipv4" if proto == "ospf" else "ipv6" }}',
	"retransmit_interval": "{{ val }}"
	}
	}
	}
	},
	{
	"name": "transmit_delay",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+(?P<proto>ospf\|ospfv3)
	\s+interface
	\s+(?P<name>\S+)
	\s+transmit-delay
	\s+(?P<val>\'\d+\')
	*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_ospf_int_transmit_delay,
	"compval": "address_family.transmit_delay",
	"result": {
	"name": "{{ name }}",
	"address_family": {
	'{{ "ipv4" if proto == "ospf" else "ipv6" }}': {
	"afi": '{{ "ipv4" if proto == "ospf" else "ipv6" }}',
	"transmit_delay": "{{ val }}"
	}
	}
	}
	},
	{
	"name": "ifmtu",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+(?P<proto>ospf\|ospfv3)
	\s+interface
	\s+(?P<name>\S+)
	\s+ifmtu
	\s+(?P<val>\'\d+\')
	*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_ospf_int_ifmtu,
	"compval": "address_family.ifmtu",
	"result": {
	"name": "{{ name }}",
	"address_family": {
	'{{ "ipv4" if proto == "ospf" else "ipv6" }}': {
	"afi": '{{ "ipv4" if proto == "ospf" else "ipv6" }}',
	"ifmtu": "{{ val }}"
	}
	}
	}
	},
	{
	"name": "instance",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+(?P<proto>ospf\|ospfv3)
	\s+interface
	\s+(?P<name>\S+)
	\s+instance-id
	\s+(?P<val>\'\d+\')
	*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_ospf_int_instance,
	"compval": "address_family.instance",
	"result": {
	"name": "{{ name }}",
	"address_family": {
	'{{ "ipv4" if proto == "ospf" else "ipv6" }}': {
	"afi": '{{ "ipv4" if proto == "ospf" else "ipv6" }}',
	"instance": "{{ val }}"
	}
	}
	}
	},
	{
	"name": "passive",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+(?P<proto>ospf\|ospfv3)
	\s+interface
	\s+(?P<name>\S+)
	\s+(?P<pass>passive)
	*$""",
	re.VERBOSE,
	),
	"setval": _tmplt_ospf_int_passive,
	"compval": "address_family.passive",
	"result": {
	"name": "{{ name }}",
	"address_family": {
	'{{ "ipv4" if proto == "ospf" else "ipv6" }}': {
	"afi": '{{ "ipv4" if proto == "ospf" else "ipv6" }}',
	"passive": "{{ True if pass is defined }}"
	}
	}
	}
	},
	{
	"name": "interface_name",
	"getval": re.compile(
	r"""
	^set
	\s+protocols
	\s+(?P<proto>ospf\|ospfv3)
	\s+interface
	\s+(?P<name>\S+)
	.*$""",
	re.VERBOSE,
	),
	"setval": "set protocols {{ proto }} interface {{ name }}",
	"result": {
	"name": "{{ name }}",
	}
	},
	]
	# fmt: on
	diff --git a/plugins/module_utils/network/vyos/rm_templates/route_maps.py b/plugins/module_utils/network/vyos/rm_templates/route_maps.py
	index c6b88f7b..51d0ea1c 100644
	--- a/plugins/module_utils/network/vyos/rm_templates/route_maps.py
	+++ b/plugins/module_utils/network/vyos/rm_templates/route_maps.py
	@@ -1,1405 +1,1358 @@
	# -- coding: utf-8 --
	# Copyright 2021 Red Hat
	# GNU General Public License v3.0+
	# (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)

	from __future__ import absolute_import, division, print_function


	__metaclass__ = type

	"""
	The Route_maps parser templates file. This contains
	a list of parser definitions and associated functions that
	facilitates both facts gathering and native command generation for
	the given network resource.
	"""

	import re

	from ansible_collections.ansible.netcommon.plugins.module_utils.network.common.rm_base.network_template import (
	NetworkTemplate,
	)


	class Route_mapsTemplate(NetworkTemplate):
	def __init__(self, lines=None):
	prefix = {"set": "set", "remove": "delete"}
	super(Route_mapsTemplate, self).__init__(lines=lines, tmplt=self, prefix=prefix)

	# fmt: off
	PARSERS = [
	{
	"name": "route_map",
	"getval": re.compile(
	r"""
	- ^set\spolicy\sroute-map\s(?P<route_map>\S+)
	- *$""",
	+ ^set\spolicy\sroute-map\s(?P<route_map>\S+)\s*$""",
	re.VERBOSE,
	),
	"compval": "route_map",
	"setval": "policy route-map {{route_map}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	},
	},
	},
	},
	{
	"name": "sequence",
	"getval": re.compile(
	r"""
	- ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)
	- *$""",
	+ ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\s*$""",
	re.VERBOSE,
	),
	"compval": "sequence",
	"setval": "policy route-map {{route_map}} rule {{sequence}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	},
	},
	},
	},
	},
	},
	{
	"name": "call",
	"getval": re.compile(
	r"""
	- ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\scall\s(?P<call>\S+)
	- *$""",
	+ ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\scall\s(?P<call>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": "policy route-map {{route_map}} rule {{sequence}} call {{call}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"call": "{{call}}",
	},
	},
	},
	},
	},
	},
	{
	"name": "description",
	"getval": re.compile(
	r"""
	- ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sdescription\s(?P<description>\S+)
	- *$""",
	+ ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sdescription\s(?P<description>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": "policy route-map {{route_map}} rule {{sequence}} description {{description}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"description": "{{description}}",
	},
	},
	},
	},
	},
	},
	{
	"name": "action",
	"getval": re.compile(
	r"""
	- ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\saction\s(?P<action>\S+)
	- *$""",
	+ ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\saction\s(?P<action>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": "policy route-map {{route_map}} rule {{sequence}} action {{action}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"action": "{{action}}",
	},
	},
	},
	},
	},
	},
	{
	"name": "continue_sequence",
	"getval": re.compile(
	r"""
	- ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\scontinue\s(?P<continue>\S+)
	- *$""",
	+ ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\scontinue\s(?P<continue>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": "policy route-map {{route_map}} rule {{sequence}} continue {{continue_sequence}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"continue_sequence": "{{continue}}",
	},
	},
	},
	},
	},
	},
	{
	"name": "on_match_next",
	"getval": re.compile(
	r"""
	- ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\son-match\s(?P<next>next)
	- *$""",
	+ ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\son-match\s(?P<next>next)\s*$""",
	re.VERBOSE,
	),
	"compval": "on_match.next",
	"setval": "policy route-map {{route_map}} rule {{sequence}} on-match next",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"on_match": {
	"next": "{{True if next is defined}}",
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "on_match_goto",
	"getval": re.compile(
	r"""
	- ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\son-match\sgoto\s(?P<goto>\S+)
	- *$""",
	+ ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\son-match\sgoto\s(?P<goto>\S+)\s*$""",
	re.VERBOSE,
	),
	"compval": "on_match.goto",
	"setval": "policy route-map {{route_map}} rule {{sequence}} on-match goto {{on_match.goto}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"on_match": {
	"goto": "{{goto}}",
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "set_aggregator_ip",
	"getval": re.compile(
	r"""
	- ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\saggregator\sip\s(?P<ip>\S+)
	- *$""",
	+ ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\saggregator\sip\s(?P<ip>\S+)\s*$""",
	re.VERBOSE,
	),
	"compval": "set.aggregator.ip",
	"setval": "policy route-map {{route_map}} rule {{sequence}} set aggregator ip {{set.aggregator.ip}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"set": {
	"aggregator": {
	"ip": "{{ip}}",
	},
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "set_aggregator_as",
	"getval": re.compile(
	r"""
	- ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\saggregator\sas\s(?P<as>\S+)
	- *$""",
	+ ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\saggregator\sas\s(?P<as>\S+)\s*$""",
	re.VERBOSE,
	),
	"compval": "set.aggregator.as",
	"setval": "policy route-map {{route_map}} rule {{sequence}} set aggregator as {{set.aggregator.as}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"set": {
	"aggregator": {
	"as": "{{as}}",
	},
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "set_as_path_exclude",
	"getval": re.compile(
	r"""
	- ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sas-path-exclude\s(?P<as>\S+)
	- *$""",
	+ ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sas-path-exclude\s(?P<as>\S+)\s*$""",
	re.VERBOSE,
	),
	"compval": "set.as_path_exclude",
	"setval": "policy route-map {{route_map}} rule {{sequence}} set as-path-exclude {{set.as_path_exclude}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"set": {
	"as_path_exclude": "{{as}}",
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "set_as_path_prepend",
	"getval": re.compile(
	r"""
	^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sas-path-prepend\s(?P<as>.*)
	$""",
	re.VERBOSE,
	),
	"compval": "set.as_path_prepend",
	"setval": "policy route-map {{route_map}} rule {{sequence}} set as-path-prepend '{{set.as_path_prepend}}'",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"set": {
	"as_path_prepend": "{{as}}",
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "set_atomic_aggregate",
	"getval": re.compile(
	r"""
	- ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\s(?P<as>atomic-aggregate)
	- *$""",
	+ ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\s(?P<as>atomic-aggregate)\s*$""",
	re.VERBOSE,
	),
	"compval": "set.atomic_aggregate",
	"setval": "policy route-map {{route_map}} rule {{sequence}} set atomic-aggregate",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"set": {
	"atomic_aggregate": "{{True if as is defined}}",
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "set_bgp_extcommunity_rt",
	"getval": re.compile(
	r"""
	- ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sbgp-extcommunity-rt\s(?P<bgp>\S+)
	- *$""",
	+ ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sbgp-extcommunity-rt\s(?P<bgp>\S+)\s*$""",
	re.VERBOSE,
	),
	"compval": "set.bgp_extcommunity_rt",
	"setval": "policy route-map {{route_map}} rule {{sequence}} "
	"set bgp-extcommunity-rt {{set.bgp_extcommunity_rt}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"set": {
	"bgp_extcommunity_rt": "{{bgp}}",
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "set_comm_list",
	"getval": re.compile(
	r"""
	- ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\scommunity\scommunity-list\s(?P<comm_list>\S+)
	- *$""",
	+ ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\scommunity\scommunity-list\s(?P<comm_list>\S+)\s*$""",
	re.VERBOSE,
	),
	"compval": "match.community.community_list",
	"setval": "policy route-map {{route_map}} rule {{sequence}} "
	"match community community-list {{set.comm_list.comm_list}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"match": {
	"community": {"community_list": "{{comm_list}}"},
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "set_comm_list_delete",
	"getval": re.compile(
	r"""
	- ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\scomm-list\sdelete(?P<delete>\S+)
	- *$""",
	+ ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\scomm-list\s(?P<delete>delete)\s*$""",
	re.VERBOSE,
	),
	"compval": "set.comm_list.comm_list",
	"setval": "policy route-map {{route_map}} rule {{sequence}} "
	"set comm-list delete",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"set": {
	"comm_list": {"delete": "{{True if delete is defined}}"},
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "set_extcommunity_rt",
	"getval": re.compile(
	r"""
	- ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sextcommunity-rt\s(?P<extcommunity_rt>\S+)
	- *$""",
	+ ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sextcommunity-rt\s(?P<extcommunity_rt>\S+)\s*$""",
	re.VERBOSE,
	),
	"compval": "set.extcommunity_rt",
	"setval": "policy route-map {{route_map}} rule {{sequence}} "
	"set extcommunity-rt {{set.extcommunity_rt}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"set": {
	"extcommunity_rt": "{{extcommunity_rt}}",
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "set_extcommunity_soo",
	"getval": re.compile(
	r"""
	- ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sextcommunity-soo\s(?P<extcommunity_soo>\S+)
	- *$""",
	+ ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sextcommunity-soo\s(?P<extcommunity_soo>\S+)\s*$""",
	re.VERBOSE,
	),
	"compval": "set.extcommunity_soo",
	"setval": "policy route-map {{route_map}} rule {{sequence}} "
	"set extcommunity-soo {{set.extcommunity_soo}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"set": {
	"extcommunity_soo": "{{set.extcommunity_soo}}",
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "set_extcommunity_bandwidth",
	"getval": re.compile(
	r"""
	- ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sextcommunity\sbandwidth\s(?P<extcommunity_bw>\S+)
	- *$""",
	+ ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sextcommunity\sbandwidth\s(?P<extcommunity_bw>\S+)\s*$""",
	re.VERBOSE,
	),
	"compval": "set.extcommunity_bandwidth",
	"setval": "policy route-map {{route_map}} rule {{sequence}} "
	"set extcommunity bandwidth {{set.extcommunity_bandwidth}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"set": {
	"extcommunity_bandwidth": "{{extcommunity_bw}}",
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "set_extcommunity_bandwidth_non_transitive",
	"getval": re.compile(
	r"""
	- ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sextcommunity\s(?P<extcommunity_bw_nt>bandwidth-non-transitive)
	- *$""",
	+ ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)
	+ \sset\sextcommunity\s(?P<extcommunity_bw_nt>bandwidth-non-transitive)\s*$""",
	re.VERBOSE,
	),
	"compval": "set.extcommunity_bandwidth_non_transitive",
	"setval": "policy route-map {{route_map}} rule {{sequence}} "
	"set extcommunity bandwidth-non-transitive",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"set": {
	"extcommunity_bandwidth_non_transitive": "{{True if extcommunity_bw_nt is defined}}",
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "set_ip_next_hop",
	"getval": re.compile(
	r"""
	- ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sip-next-hop\s(?P<ip_next_hop>\S+)
	- *$""",
	+ ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sip-next-hop\s(?P<ip_next_hop>\S+)\s*$""",
	re.VERBOSE,
	),
	"compval": "set.ip_next_hop",
	"setval": "policy route-map {{route_map}} rule {{sequence}} "
	"set ip-next-hop {{set.ip_next_hop}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"set": {
	"ip_next_hop": "{{ip_next_hop}}",
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "set_ipv6_next_hop",
	"getval": re.compile(
	r"""
	^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sipv6-next-hop
	\s(?P<type>global\|local)
	- \s(?P<value>\S+)
	- *$""",
	+ \s(?P<value>\S+)\s*$""",
	re.VERBOSE,
	),
	"compval": "set.ipv6_next_hop",
	"setval": "policy route-map {{route_map}} rule {{sequence}} "
	"set ipv6-next-hop {{set.ipv6_next_hop.ip_type}} {{set.ipv6_next_hop.value}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"set": {
	"ipv6_next_hop": {
	"ip_type": "{{type}}",
	"value": "{{value}}",
	},
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "set_large_community",
	"getval": re.compile(
	r"""
	- ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\slarge-community\s(?P<large_community>\S+)
	- *$""",
	+ ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\slarge-community\s(?P<large_community>\S+)\s*$""",
	re.VERBOSE,
	),
	"compval": "set.large_community",
	"setval": "policy route-map {{route_map}} rule {{sequence}} "
	"set large-community {{set.large_community}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"set": {
	"large_community": "{{large_community}}",
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "set_local_preference",
	"getval": re.compile(
	r"""
	- ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\slocal-preference\s(?P<local_preference>\S+)
	- *$""",
	+ ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\slocal-preference\s(?P<local_preference>\S+)\s*$""",
	re.VERBOSE,
	),
	"compval": "set.local_preference",
	"setval": "policy route-map {{route_map}} rule {{sequence}} "
	"set local-preference {{set.local_preference}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"set": {
	"local_preference": "{{local_preference}}",
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "set_metric",
	"getval": re.compile(
	r"""
	- ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\smetric\s(?P<metric>\S+)
	- *$""",
	+ ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\smetric\s(?P<metric>\S+)\s*$""",
	re.VERBOSE,
	),
	"compval": "set.metric",
	"setval": "policy route-map {{route_map}} rule {{sequence}} "
	"set metric {{set.metric}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"set": {
	"metric": "{{metric}}",
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "set_metric_type",
	"getval": re.compile(
	r"""
	- ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\smetric-type\s(?P<metric_type>\S+)
	- *$""",
	+ ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\smetric-type\s(?P<metric_type>\S+)\s*$""",
	re.VERBOSE,
	),
	"compval": "set.metric_type",
	"setval": "policy route-map {{route_map}} rule {{sequence}} "
	"set metric-type {{set.metric_type}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"set": {
	"metric_type": "{{metric_type}}",
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "set_origin",
	"getval": re.compile(
	r"""
	- ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sorigin\s(?P<origin>\S+)
	- *$""",
	+ ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sorigin\s(?P<origin>\S+)\s*$""",
	re.VERBOSE,
	),
	"compval": "set.origin",
	"setval": "policy route-map {{route_map}} rule {{sequence}} "
	"set origin {{set.origin}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"set": {
	"origin": "{{origin}}",
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "set_originator_id",
	"getval": re.compile(
	r"""
	- ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\soriginator-id\s(?P<originator_id>\S+)
	- *$""",
	+ ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\soriginator-id\s(?P<originator_id>\S+)\s*$""",
	re.VERBOSE,
	),
	"compval": "set.originator_id",
	"setval": "policy route-map {{route_map}} rule {{sequence}} "
	"set originator-id {{set.originator_id}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"set": {
	"originator_id": "{{originator_id}}",
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "set_src",
	"getval": re.compile(
	r"""
	- ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\ssrc\s(?P<src>\S+)
	- *$""",
	+ ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\ssrc\s(?P<src>\S+)\s*$""",
	re.VERBOSE,
	),
	"compval": "set.src",
	"setval": "policy route-map {{route_map}} rule {{sequence}} "
	"set src {{set.src}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"set": {
	"src": "{{src}}",
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "set_tag",
	"getval": re.compile(
	r"""
	- ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\stag\s(?P<tag>\S+)
	- *$""",
	+ ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\stag\s(?P<tag>\S+)\s*$""",
	re.VERBOSE,
	),
	"compval": "set.tag",
	"setval": "policy route-map {{route_map}} rule {{sequence}} "
	"set tag {{set.tag}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"set": {
	"tag": "{{tag}}",
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "set_weight",
	"getval": re.compile(
	r"""
	- ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sweight\s(?P<weight>\S+)
	- *$""",
	+ ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sweight\s(?P<weight>\S+)\s*$""",
	re.VERBOSE,
	),
	"compval": "set.weight",
	"setval": "policy route-map {{route_map}} rule {{sequence}} "
	"set weight {{set.weight}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"set": {
	"weight": "{{weight}}",
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "set_table",
	"getval": re.compile(
	r"""
	- ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\stable\s(?P<table>\S+)
	- *$""",
	+ ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\stable\s(?P<table>\S+)\s*$""",
	re.VERBOSE,
	),
	"compval": "set.weight",
	"setval": "policy route-map {{route_map}} rule {{sequence}} "
	"set table {{set.table}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"set": {
	"table": "{{table}}",
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "set_community",
	"getval": re.compile(
	r"""
	- ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\scommunity\s(?P<value>\S+)
	- *$""",
	+ ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\scommunity\s(?P<value>\S+)\s*$""",
	re.VERBOSE,
	),
	"compval": "set.community.value",
	"setval": "policy route-map {{route_map}} rule {{sequence}} "
	"set community {{set.community.value}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"set": {
	"community": {
	"value": "{{value}}",
	},
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "match_as_path",
	"getval": re.compile(
	r"""
	- ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\sas-path\s(?P<as_path>\S+)
	- *$""",
	+ ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\sas-path\s(?P<as_path>\S+)\s*$""",
	re.VERBOSE,
	),
	"compval": "match.as_path",
	"setval": "policy route-map {{route_map}} rule {{sequence}} "
	"match as-path {{match.as_path}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"match": {
	"as_path": "{{as_path}}",
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "match_community_community_list",
	"getval": re.compile(
	r"""
	- ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\scommunity\scommunity-list\s(?P<community_list>\S+)
	- *$""",
	+ ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\scommunity\scommunity-list\s(?P<community_list>\S+)\s*$""",
	re.VERBOSE,
	),
	"compval": "match.community.community_list",
	"setval": "policy route-map {{route_map}} rule {{sequence}} "
	"match community community-list {{match.community.community_list}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"match": {
	"community": {"community_list": "{{community_list}}"},
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "match_community_exact_match",
	"getval": re.compile(
	r"""
	- ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\scommunity\sexact-match(?P<exact_match>)
	- *$""",
	+ ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\scommunity\sexact-match(?P<exact_match>)\s*$""",
	re.VERBOSE,
	),
	"compval": "match.community.exact_match",
	"setval": "policy route-map {{route_map}} rule {{sequence}} "
	"match community exact-match",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"match": {
	"community": {"exact_match": "{{True if exact_match is defined}}"},
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "match_extcommunity",
	"getval": re.compile(
	r"""
	- ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\sextcommunity\s(?P<extcommunity>\S+)
	- *$""",
	+ ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\sextcommunity\s(?P<extcommunity>\S+)\s*$""",
	re.VERBOSE,
	),
	"compval": "match.extcommunity",
	"setval": "policy route-map {{route_map}} rule {{sequence}} "
	"match extcommunity {{match.extcommunity}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"match": {
	"extcommunity": "{{extcommunity}}",
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "match_interface",
	"getval": re.compile(
	r"""
	- ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\sinterface\s(?P<interface>\S+)
	- *$""",
	+ ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\sinterface\s(?P<interface>\S+)\s*$""",
	re.VERBOSE,
	),
	"compval": "match.interface",
	"setval": "policy route-map {{route_map}} rule {{sequence}} "
	"match interface {{match.interface}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"match": {
	"interface": "{{interface}}",
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "match_large_community_large_community_list",
	"getval": re.compile(
	r"""
	- ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\slarge-community\slarge-community-list\s(?P<lc>\S+)
	- *$""",
	+ ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\slarge-community\slarge-community-list\s(?P<lc>\S+)\s*$""",
	re.VERBOSE,
	),
	"compval": "match.large_community_large_community_list",
	"setval": "policy route-map {{route_map}} rule {{sequence}} "
	"match large-community large-community-list {{match.large_community_large_community_list}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"match": {
	"large_community_large_community_list": "{{lc}}",
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "match_metric",
	"getval": re.compile(
	r"""
	- ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\smetric\s(?P<metric>\S+)
	- *$""",
	+ ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\smetric\s(?P<metric>\S+)\s*$""",
	re.VERBOSE,
	),
	"compval": "match.metric",
	"setval": "policy route-map {{route_map}} rule {{sequence}} "
	"match metric {{match.metric}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"match": {
	"metric": "{{metric}}",
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "match_origin",
	"getval": re.compile(
	r"""
	- ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\sorigin\s(?P<origin>\S+)
	- *$""",
	+ ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\sorigin\s(?P<origin>\S+)\s*$""",
	re.VERBOSE,
	),
	"compval": "match.origin",
	"setval": "policy route-map {{route_map}} rule {{sequence}} "
	"match origin {{match.origin}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"match": {
	"origin": "{{origin}}",
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "match_peer",
	"getval": re.compile(
	r"""
	- ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\speer\s(?P<peer>\S+)
	- *$""",
	+ ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\speer\s(?P<peer>\S+)\s*$""",
	re.VERBOSE,
	),
	"compval": "match.peer",
	"setval": "policy route-map {{route_map}} rule {{sequence}} "
	"match peer {{match.peer}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"match": {
	"peer": "{{peer}}",
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "match_ip_address",
	"getval": re.compile(
	r"""
	^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\sip\saddress
	\s(?P<list_type>access-list\|prefix-list)
	- \s(?P<value>\S+)
	- *$""",
	+ \s(?P<value>\S+)\s*$""",
	re.VERBOSE,
	),
	"compval": "match.ip.address",
	"setval": "policy route-map {{route_map}} rule {{sequence}} "
	"match ip address {{match.ip.address.list_type}} {{match.ip.address.value}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}": {
	"sequence": "{{sequence}}",
	"match": {
	"ip": {
	"address": {
	"list_type": "{{list_type}}",
	"value": "{{value}}",
	},
	},
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "match_ip_next_hop",
	"getval": re.compile(
	r"""
	^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\sip\snexthop
	\s(?P<list_type>access-list\|prefix-list)
	- \s(?P<value>\S+)
	- *$""",
	+ \s(?P<value>\S+)\s*$""",
	re.VERBOSE,
	),
	"compval": "match.ip.next_hop",
	"setval": "policy route-map {{route_map}} rule {{sequence}} "
	"match ip nexthop {{match.ip.next_hop.list_type}} {{match.ip.next_hop.value}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}": {
	"sequence": "{{sequence}}",
	"match": {
	"ip": {
	"next_hop": {
	"list_type": "{{list_type}}",
	"value": "{{value}}",
	},
	},
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "match_ip_route_source",
	"getval": re.compile(
	r"""
	^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\sip\sroute-source
	\s(?P<list_type>access-list\|prefix-list)
	- \s(?P<value>\S+)
	- *$""",
	+ \s(?P<value>\S+)\s*$""",
	re.VERBOSE,
	),
	"compval": "match.ip.route_source",
	"setval": "policy route-map {{route_map}} rule {{sequence}} "
	"match ip route-source {{match.ip.route_source.list_type}} {{match.ip.route_source.value}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}": {
	"sequence": "{{sequence}}",
	"match": {
	"ip": {
	"route_source": {
	"list_type": "{{list_type}}",
	"value": "{{value}}",
	},
	},
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "match_ipv6_address",
	"getval": re.compile(
	r"""
	^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\sipv6\saddress
	\s(?P<list_type>access-list\|prefix-list)
	- \s(?P<value>\S+)
	- *$""",
	+ \s(?P<value>\S+)\s*$""",
	re.VERBOSE,
	),
	"compval": "match.ipv6.address",
	"setval": "policy route-map {{route_map}} rule {{sequence}} "
	"match ipv6 address {{match.ipv6.address.list_type}} {{match.ipv6.address.value}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}": {
	"sequence": "{{sequence}}",
	"match": {
	"ipv6": {
	"address": {
	"list_type": "{{list_type}}",
	"value": "{{value}}",
	},
	},
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "match_ipv6_nexthop",
	"getval": re.compile(
	r"""
	^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\sipv6\snexthop
	- \s(?P<value>\S+)
	- *$""",
	+ \s(?P<value>\S+)\s*$""",
	re.VERBOSE,
	),
	"compval": "match.ipv6.next_hop",
	"setval": "policy route-map {{route_map}} rule {{sequence}} "
	"match ipv6 nexthop {{match.ipv6.next_hop}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}": {
	"sequence": "{{sequence}}",
	"match": {
	"ipv6": {
	"next_hop": "{{value}}",
	},
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "match_protocol",
	"getval": re.compile(
	r"""
	- ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\sprotocol\s(?P<value>\S+)
	- *$""",
	+ ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\sprotocol\s(?P<value>\S+)\s*$""",
	re.VERBOSE,
	),
	"compval": "match.protocol",
	"setval": "policy route-map {{route_map}} rule {{sequence}} "
	"match protocol {{match.protocol}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}": {
	"sequence": "{{sequence}}",
	"match": {
	"protocol": "{{value}}",
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "match_rpki",
	"getval": re.compile(
	r"""
	^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\srpki
	- \s(?P<value>\S+)
	- *$""",
	+ \s(?P<value>\S+)\s*$""",
	re.VERBOSE,
	),
	"compval": "match.rpki",
	"setval": "policy route-map {{route_map}} rule {{sequence}} "
	"match rpki {{match.rpki}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}": {
	"sequence": "{{sequence}}",
	"match": {
	"rpki": "{{value}}",
	},
	},
	},
	},
	},
	},
	},

	]
	# fmt: on
	diff --git a/plugins/module_utils/network/vyos/rm_templates/route_maps_14.py b/plugins/module_utils/network/vyos/rm_templates/route_maps_14.py
	index 6564280d..ea61a555 100644
	--- a/plugins/module_utils/network/vyos/rm_templates/route_maps_14.py
	+++ b/plugins/module_utils/network/vyos/rm_templates/route_maps_14.py
	@@ -1,1405 +1,1364 @@
	# -- coding: utf-8 --
	# Copyright 2021 Red Hat
	# GNU General Public License v3.0+
	# (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)

	from __future__ import absolute_import, division, print_function


	__metaclass__ = type

	"""
	The Route_maps parser templates file. This contains
	a list of parser definitions and associated functions that
	facilitates both facts gathering and native command generation for
	the given network resource.
	"""

	import re

	from ansible_collections.ansible.netcommon.plugins.module_utils.network.common.rm_base.network_template import (
	NetworkTemplate,
	)


	class Route_mapsTemplate14(NetworkTemplate):
	def __init__(self, lines=None):
	prefix = {"set": "set", "remove": "delete"}
	super(Route_mapsTemplate14, self).__init__(lines=lines, tmplt=self, prefix=prefix)

	# fmt: off
	PARSERS = [
	{
	"name": "route_map",
	"getval": re.compile(
	r"""
	- ^set\spolicy\sroute-map\s(?P<route_map>\S+)
	- *$""",
	+ ^set\spolicy\sroute-map\s(?P<route_map>\S+)\s*$""",
	re.VERBOSE,
	),
	"compval": "route_map",
	"setval": "policy route-map {{route_map}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	},
	},
	},
	},
	{
	"name": "sequence",
	"getval": re.compile(
	r"""
	^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)
	*$""",
	re.VERBOSE,
	),
	"compval": "sequence",
	"setval": "policy route-map {{route_map}} rule {{sequence}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	},
	},
	},
	},
	},
	},
	{
	"name": "call",
	"getval": re.compile(
	r"""
	- ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\scall\s(?P<call>\S+)
	- *$""",
	+ ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\scall\s(?P<call>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": "policy route-map {{route_map}} rule {{sequence}} call {{call}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"call": "{{call}}",
	},
	},
	},
	},
	},
	},
	{
	"name": "description",
	"getval": re.compile(
	r"""
	- ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sdescription\s(?P<description>\S+)
	- *$""",
	+ ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sdescription\s(?P<description>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": "policy route-map {{route_map}} rule {{sequence}} description {{description}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"description": "{{description}}",
	},
	},
	},
	},
	},
	},
	{
	"name": "action",
	"getval": re.compile(
	r"""
	- ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\saction\s(?P<action>\S+)
	- *$""",
	+ ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\saction\s(?P<action>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": "policy route-map {{route_map}} rule {{sequence}} action {{action}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"action": "{{action}}",
	},
	},
	},
	},
	},
	},
	{
	"name": "continue_sequence",
	"getval": re.compile(
	r"""
	- ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\scontinue\s(?P<continue>\S+)
	- *$""",
	+ ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\scontinue\s(?P<continue>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": "policy route-map {{route_map}} rule {{sequence}} continue {{continue_sequence}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"continue_sequence": "{{continue}}",
	},
	},
	},
	},
	},
	},
	{
	"name": "on_match_next",
	"getval": re.compile(
	r"""
	^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\son-match\s(?P<next>next)
	*$""",
	re.VERBOSE,
	),
	"compval": "on_match.next",
	"setval": "policy route-map {{route_map}} rule {{sequence}} on-match next",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"on_match": {
	"next": "{{True if next is defined}}",
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "on_match_goto",
	"getval": re.compile(
	r"""
	- ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\son-match\sgoto\s(?P<goto>\S+)
	- *$""",
	+ ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\son-match\sgoto\s(?P<goto>\S+)\s*$""",
	re.VERBOSE,
	),
	"compval": "on_match.goto",
	"setval": "policy route-map {{route_map}} rule {{sequence}} on-match goto {{on_match.goto}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"on_match": {
	"goto": "{{goto}}",
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "set_aggregator_ip",
	"getval": re.compile(
	r"""
	- ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\saggregator\sip\s(?P<ip>\S+)
	- *$""",
	+ ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\saggregator\sip\s(?P<ip>\S+)\s*$""",
	re.VERBOSE,
	),
	"compval": "set.aggregator.ip",
	"setval": "policy route-map {{route_map}} rule {{sequence}} set aggregator ip {{set.aggregator.ip}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"set": {
	"aggregator": {
	"ip": "{{ip}}",
	},
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "set_aggregator_as",
	"getval": re.compile(
	r"""
	- ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\saggregator\sas\s(?P<as>\S+)
	- *$""",
	+ ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\saggregator\sas\s(?P<as>\S+)\s*$""",
	re.VERBOSE,
	),
	"compval": "set.aggregator.as",
	"setval": "policy route-map {{route_map}} rule {{sequence}} set aggregator as {{set.aggregator.as}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"set": {
	"aggregator": {
	"as": "{{as}}",
	},
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "set_as_path_exclude",
	"getval": re.compile(
	r"""
	- ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sas-path\sexclude\s(?P<as>\S+)
	- *$""",
	+ ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sas-path\sexclude\s(?P<as>\S+)\s*$""",
	re.VERBOSE,
	),
	"compval": "set.as_path_exclude",
	"setval": "policy route-map {{route_map}} rule {{sequence}} set as-path exclude {{set.as_path_exclude}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"set": {
	"as_path_exclude": "{{as}}",
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "set_as_path_prepend",
	"getval": re.compile(
	r"""
	^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sas-path\sprepend\s(?P<as>.*)
	$""",
	re.VERBOSE,
	),
	"compval": "set.as_path_prepend",
	"setval": "policy route-map {{route_map}} rule {{sequence}} set as-path prepend '{{set.as_path_prepend}}'",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"set": {
	"as_path_prepend": "{{as}}",
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "set_atomic_aggregate",
	"getval": re.compile(
	r"""
	^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\s(?P<as>atomic-aggregate)
	*$""",
	re.VERBOSE,
	),
	"compval": "set.atomic_aggregate",
	"setval": "policy route-map {{route_map}} rule {{sequence}} set atomic-aggregate",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"set": {
	"atomic_aggregate": "{{True if as is defined}}",
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "set_bgp_extcommunity_rt",
	"getval": re.compile(
	r"""
	- ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sbgp-extcommunity-rt\s(?P<bgp>\S+)
	- *$""",
	+ ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sbgp-extcommunity-rt\s(?P<bgp>\S+)\s*$""",
	re.VERBOSE,
	),
	"compval": "set.bgp_extcommunity_rt",
	"setval": "policy route-map {{route_map}} rule {{sequence}} "
	"set bgp-extcommunity-rt {{set.bgp_extcommunity_rt}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"set": {
	"bgp_extcommunity_rt": "{{bgp}}",
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "set_comm_list",
	"getval": re.compile(
	r"""
	- ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\scommunity\scommunity-list\s(?P<comm_list>\S+)
	- *$""",
	+ ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\scommunity\scommunity-list\s(?P<comm_list>\S+)\s*$""",
	re.VERBOSE,
	),
	"compval": "match.community.community_list",
	"setval": "policy route-map {{route_map}} rule {{sequence}} "
	"match community community-list {{set.comm_list.comm_list}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"match": {
	"community": {"community_list": "{{comm_list}}"},
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "set_comm_list_delete",
	"getval": re.compile(
	r"""
	- ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\scomm-list\sdelete(?P<delete>\S+)
	- *$""",
	+ ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\scomm-list\s(?P<delete>delete)\s*$""",
	re.VERBOSE,
	),
	"compval": "set.comm_list.comm_list",
	"setval": "policy route-map {{route_map}} rule {{sequence}} "
	"set comm-list delete",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"set": {
	"comm_list": {"delete": "{{True if delete is defined}}"},
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "set_extcommunity_rt",
	"getval": re.compile(
	r"""
	- ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sextcommunity\srt\s(?P<extcommunity_rt>\S+)
	- *$""",
	+ ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sextcommunity\srt\s(?P<extcommunity_rt>\S+)\s*$""",
	re.VERBOSE,
	),
	"compval": "set.extcommunity_rt",
	"setval": "policy route-map {{route_map}} rule {{sequence}} "
	"set extcommunity rt {{set.extcommunity_rt}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"set": {
	"extcommunity_rt": "{{extcommunity_rt}}",
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "set_extcommunity_soo",
	"getval": re.compile(
	r"""
	- ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sextcommunity\ssoo\s(?P<extcommunity_soo>\S+)
	- *$""",
	+ ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sextcommunity\ssoo\s(?P<extcommunity_soo>\S+)\s*$""",
	re.VERBOSE,
	),
	"compval": "set.extcommunity_soo",
	"setval": "policy route-map {{route_map}} rule {{sequence}} "
	"set extcommunity soo {{set.extcommunity_soo}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"set": {
	"extcommunity_soo": "{{extcommunity_soo}}",
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "set_extcommunity_bandwidth",
	"getval": re.compile(
	r"""
	- ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sextcommunity\sbandwidth\s(?P<extcommunity_bw>\S+)
	- *$""",
	+ ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sextcommunity\sbandwidth\s(?P<extcommunity_bw>\S+)\s*$""",
	re.VERBOSE,
	),
	"compval": "set.extcommunity_bandwidth",
	"setval": "policy route-map {{route_map}} rule {{sequence}} "
	"set extcommunity bandwidth {{set.extcommunity_bandwidth}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"set": {
	"extcommunity_bandwidth": "{{extcommunity_bw}}",
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "set_extcommunity_bandwidth_non_transitive",
	"getval": re.compile(
	r"""
	^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sextcommunity\s(?P<extcommunity_bw_nt>bandwidth-non-transitive)
	*$""",
	re.VERBOSE,
	),
	"compval": "set.extcommunity_bandwidth_non_transitive",
	"setval": "policy route-map {{route_map}} rule {{sequence}} "
	"set extcommunity bandwidth-non-transitive",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"set": {
	"extcommunity_bandwidth_non_transitive": "{{True if extcommunity_bw_nt is defined}}",
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "set_ip_next_hop",
	"getval": re.compile(
	r"""
	- ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sip-next-hop\s(?P<ip_next_hop>\S+)
	- *$""",
	+ ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sip-next-hop\s(?P<ip_next_hop>\S+)\s*$""",
	re.VERBOSE,
	),
	"compval": "set.ip_next_hop",
	"setval": "policy route-map {{route_map}} rule {{sequence}} "
	"set ip-next-hop {{set.ip_next_hop}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"set": {
	"ip_next_hop": "{{ip_next_hop}}",
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "set_ipv6_next_hop",
	"getval": re.compile(
	r"""
	^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sipv6-next-hop
	\s(?P<type>global\|local)
	- \s(?P<value>\S+)
	- *$""",
	+ \s(?P<value>\S+)\s*$""",
	re.VERBOSE,
	),
	"compval": "set.ipv6_next_hop",
	"setval": "policy route-map {{route_map}} rule {{sequence}} "
	"set ipv6-next-hop {{set.ipv6_next_hop.ip_type}} {{set.ipv6_next_hop.value}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"set": {
	"ipv6_next_hop": {
	"ip_type": "{{type}}",
	"value": "{{value}}",
	},
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "set_large_community",
	"getval": re.compile(
	r"""
	^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\slarge-community\s(?P<op>none\|replace\s(?P<large_community>\S+))
	$""",
	re.VERBOSE,
	),
	"compval": "set.large_community",
	"setval": "policy route-map {{route_map}} rule {{sequence}} "
	"set large-community {{set.large_community if set.large_community == 'none' else 'replace ' + set.large_community}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"set": {
	"large_community": "{{op if op == 'none' else large_community}}",
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "set_local_preference",
	"getval": re.compile(
	r"""
	- ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\slocal-preference\s(?P<local_preference>\S+)
	- *$""",
	+ ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\slocal-preference\s(?P<local_preference>\S+)\s*$""",
	re.VERBOSE,
	),
	"compval": "set.local_preference",
	"setval": "policy route-map {{route_map}} rule {{sequence}} "
	"set local-preference {{set.local_preference}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"set": {
	"local_preference": "{{local_preference}}",
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "set_metric",
	"getval": re.compile(
	r"""
	- ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\smetric\s(?P<metric>\S+)
	- *$""",
	+ ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\smetric\s(?P<metric>\S+)\s*$""",
	re.VERBOSE,
	),
	"compval": "set.metric",
	"setval": "policy route-map {{route_map}} rule {{sequence}} "
	"set metric {{set.metric}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"set": {
	"metric": "{{metric}}",
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "set_metric_type",
	"getval": re.compile(
	r"""
	- ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\smetric-type\s(?P<metric_type>\S+)
	- *$""",
	+ ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\smetric-type\s(?P<metric_type>\S+)\s*$""",
	re.VERBOSE,
	),
	"compval": "set.metric_type",
	"setval": "policy route-map {{route_map}} rule {{sequence}} "
	"set metric-type {{set.metric_type}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"set": {
	"metric_type": "{{metric_type}}",
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "set_origin",
	"getval": re.compile(
	r"""
	- ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sorigin\s(?P<origin>\S+)
	- *$""",
	+ ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sorigin\s(?P<origin>\S+)\s*$""",
	re.VERBOSE,
	),
	"compval": "set.origin",
	"setval": "policy route-map {{route_map}} rule {{sequence}} "
	"set origin {{set.origin}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"set": {
	"origin": "{{origin}}",
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "set_originator_id",
	"getval": re.compile(
	r"""
	- ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\soriginator-id\s(?P<originator_id>\S+)
	- *$""",
	+ ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\soriginator-id\s(?P<originator_id>\S+)\s*$""",
	re.VERBOSE,
	),
	"compval": "set.originator_id",
	"setval": "policy route-map {{route_map}} rule {{sequence}} "
	"set originator-id {{set.originator_id}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"set": {
	"originator_id": "{{originator_id}}",
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "set_src",
	"getval": re.compile(
	r"""
	- ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\ssrc\s(?P<src>\S+)
	- *$""",
	+ ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\ssrc\s(?P<src>\S+)\s*$""",
	re.VERBOSE,
	),
	"compval": "set.src",
	"setval": "policy route-map {{route_map}} rule {{sequence}} "
	"set src {{set.src}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"set": {
	"src": "{{src}}",
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "set_tag",
	"getval": re.compile(
	r"""
	- ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\stag\s(?P<tag>\S+)
	- *$""",
	+ ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\stag\s(?P<tag>\S+)\s*$""",
	re.VERBOSE,
	),
	"compval": "set.tag",
	"setval": "policy route-map {{route_map}} rule {{sequence}} "
	"set tag {{set.tag}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"set": {
	"tag": "{{tag}}",
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "set_weight",
	"getval": re.compile(
	r"""
	- ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sweight\s(?P<weight>\S+)
	- *$""",
	+ ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sweight\s(?P<weight>\S+)\s*$""",
	re.VERBOSE,
	),
	"compval": "set.weight",
	"setval": "policy route-map {{route_map}} rule {{sequence}} "
	"set weight {{set.weight}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"set": {
	"weight": "{{weight}}",
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "set_table",
	"getval": re.compile(
	r"""
	- ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\stable\s(?P<table>\S+)
	- *$""",
	+ ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\stable\s(?P<table>\S+)\s*$""",
	re.VERBOSE,
	),
	"compval": "set.weight",
	"setval": "policy route-map {{route_map}} rule {{sequence}} "
	"set table {{set.table}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"set": {
	"table": "{{table}}",
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "set_community",
	"getval": re.compile(
	r"""
	^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\scommunity\s(?P<op>none\|replace\s(?P<value>\S+))
	$""",
	re.VERBOSE,
	),
	"compval": "set.community.value",
	"setval": "policy route-map {{route_map}} rule {{sequence}} "
	"set community {{set.community.value if set.community.value == 'none' else 'replace ' + set.community.value}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"set": {
	"community": {
	"value": "{{op if op == 'none' else value}}",
	},
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "match_as_path",
	"getval": re.compile(
	r"""
	- ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\sas-path\s(?P<as_path>\S+)
	- *$""",
	+ ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\sas-path\s(?P<as_path>\S+)\s*$""",
	re.VERBOSE,
	),
	"compval": "match.as_path",
	"setval": "policy route-map {{route_map}} rule {{sequence}} "
	"match as-path {{match.as_path}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"match": {
	"as_path": "{{as_path}}",
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "match_community_community_list",
	"getval": re.compile(
	r"""
	- ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\scommunity\scommunity-list\s(?P<community_list>\S+)
	- *$""",
	+ ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\scommunity\scommunity-list\s(?P<community_list>\S+)\s*$""",
	re.VERBOSE,
	),
	"compval": "match.community.community_list",
	"setval": "policy route-map {{route_map}} rule {{sequence}} "
	"match community community-list {{match.community.community_list}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"match": {
	"community": {"community_list": "{{community_list}}"},
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "match_community_exact_match",
	"getval": re.compile(
	r"""
	^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\scommunity\sexact-match(?P<exact_match>)
	*$""",
	re.VERBOSE,
	),
	"compval": "match.community.exact_match",
	"setval": "policy route-map {{route_map}} rule {{sequence}} "
	"match community exact-match",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"match": {
	"community": {"exact_match": "{{True if exact_match is defined}}"},
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "match_extcommunity",
	"getval": re.compile(
	r"""
	- ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\sextcommunity\s(?P<extcommunity>\S+)
	- *$""",
	+ ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\sextcommunity\s(?P<extcommunity>\S+)\s*$""",
	re.VERBOSE,
	),
	"compval": "match.extcommunity",
	"setval": "policy route-map {{route_map}} rule {{sequence}} "
	"match extcommunity {{match.extcommunity}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"match": {
	"extcommunity": "{{extcommunity}}",
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "match_interface",
	"getval": re.compile(
	r"""
	- ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\sinterface\s(?P<interface>\S+)
	- *$""",
	+ ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\sinterface\s(?P<interface>\S+)\s*$""",
	re.VERBOSE,
	),
	"compval": "match.interface",
	"setval": "policy route-map {{route_map}} rule {{sequence}} "
	"match interface {{match.interface}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"match": {
	"interface": "{{interface}}",
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "match_large_community_large_community_list",
	"getval": re.compile(
	r"""
	- ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\slarge-community\slarge-community-list\s(?P<lc>\S+)
	- *$""",
	+ ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\slarge-community\slarge-community-list\s(?P<lc>\S+)\s*$""",
	re.VERBOSE,
	),
	"compval": "match.large_community_large_community_list",
	"setval": "policy route-map {{route_map}} rule {{sequence}} "
	"match large-community large-community-list {{match.large_community_large_community_list}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"match": {
	"large_community_large_community_list": "{{lc}}",
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "match_metric",
	"getval": re.compile(
	r"""
	- ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\smetric\s(?P<metric>\S+)
	- *$""",
	+ ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\smetric\s(?P<metric>\S+)\s*$""",
	re.VERBOSE,
	),
	"compval": "match.metric",
	"setval": "policy route-map {{route_map}} rule {{sequence}} "
	"match metric {{match.metric}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"match": {
	"metric": "{{metric}}",
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "match_origin",
	"getval": re.compile(
	r"""
	- ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\sorigin\s(?P<origin>\S+)
	- *$""",
	+ ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\sorigin\s(?P<origin>\S+)\s*$""",
	re.VERBOSE,
	),
	"compval": "match.origin",
	"setval": "policy route-map {{route_map}} rule {{sequence}} "
	"match origin {{match.origin}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"match": {
	"origin": "{{origin}}",
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "match_peer",
	"getval": re.compile(
	r"""
	- ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\speer\s(?P<peer>\S+)
	- *$""",
	+ ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\speer\s(?P<peer>\S+)\s*$""",
	re.VERBOSE,
	),
	"compval": "match.peer",
	"setval": "policy route-map {{route_map}} rule {{sequence}} "
	"match peer {{match.peer}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}":
	{
	"sequence": "{{sequence}}",
	"match": {
	"peer": "{{peer}}",
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "match_ip_address",
	"getval": re.compile(
	r"""
	^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\sip\saddress
	\s(?P<list_type>access-list\|prefix-list)
	- \s(?P<value>\S+)
	- *$""",
	+ \s(?P<value>\S+)\s*$""",
	re.VERBOSE,
	),
	"compval": "match.ip.address",
	"setval": "policy route-map {{route_map}} rule {{sequence}} "
	"match ip address {{match.ip.address.list_type}} {{match.ip.address.value}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}": {
	"sequence": "{{sequence}}",
	"match": {
	"ip": {
	"address": {
	"list_type": "{{list_type}}",
	"value": "{{value}}",
	},
	},
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "match_ip_next_hop",
	"getval": re.compile(
	r"""
	^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\sip\snexthop
	\s(?P<list_type>access-list\|prefix-list)
	- \s(?P<value>\S+)
	- *$""",
	+ \s(?P<value>\S+)\s*$""",
	re.VERBOSE,
	),
	"compval": "match.ip.next_hop",
	"setval": "policy route-map {{route_map}} rule {{sequence}} "
	"match ip nexthop {{match.ip.next_hop.list_type}} {{match.ip.next_hop.value}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}": {
	"sequence": "{{sequence}}",
	"match": {
	"ip": {
	"next_hop": {
	"list_type": "{{list_type}}",
	"value": "{{value}}",
	},
	},
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "match_ip_route_source",
	"getval": re.compile(
	r"""
	^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\sip\sroute-source
	\s(?P<list_type>access-list\|prefix-list)
	- \s(?P<value>\S+)
	- *$""",
	+ \s(?P<value>\S+)\s*$""",
	re.VERBOSE,
	),
	"compval": "match.ip.route_source",
	"setval": "policy route-map {{route_map}} rule {{sequence}} "
	"match ip route-source {{match.ip.route_source.list_type}} {{match.ip.route_source.value}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}": {
	"sequence": "{{sequence}}",
	"match": {
	"ip": {
	"route_source": {
	"list_type": "{{list_type}}",
	"value": "{{value}}",
	},
	},
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "match_ipv6_address",
	"getval": re.compile(
	r"""
	^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\sipv6\saddress
	\s(?P<list_type>access-list\|prefix-list)
	- \s(?P<value>\S+)
	- *$""",
	+ \s(?P<value>\S+)\s*$""",
	re.VERBOSE,
	),
	"compval": "match.ipv6.address",
	"setval": "policy route-map {{route_map}} rule {{sequence}} "
	"match ipv6 address {{match.ipv6.address.list_type}} {{match.ipv6.address.value}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}": {
	"sequence": "{{sequence}}",
	"match": {
	"ipv6": {
	"address": {
	"list_type": "{{list_type}}",
	"value": "{{value}}",
	},
	},
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "match_ipv6_nexthop",
	"getval": re.compile(
	r"""
	^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\sipv6\snexthop
	- \s(?P<value>\S+)
	- *$""",
	+ \s(?P<value>\S+)\s*$""",
	re.VERBOSE,
	),
	"compval": "match.ipv6.next_hop",
	"setval": "policy route-map {{route_map}} rule {{sequence}} "
	"match ipv6 nexthop {{match.ipv6.next_hop}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}": {
	"sequence": "{{sequence}}",
	"match": {
	"ipv6": {
	"next_hop": "{{value}}",
	},
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "match_protocol",
	"getval": re.compile(
	r"""
	- ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\sprotocol\s(?P<value>\S+)
	- *$""",
	+ ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\sprotocol\s(?P<value>\S+)\s*$""",
	re.VERBOSE,
	),
	"compval": "match.protocol",
	"setval": "policy route-map {{route_map}} rule {{sequence}} "
	"match protocol {{match.protocol}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}": {
	"sequence": "{{sequence}}",
	"match": {
	"protocol": "{{value}}",
	},
	},
	},
	},
	},
	},
	},
	{
	"name": "match_rpki",
	"getval": re.compile(
	r"""
	^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\srpki
	- \s(?P<value>\S+)
	- *$""",
	+ \s(?P<value>\S+)\s*$""",
	re.VERBOSE,
	),
	"compval": "match.rpki",
	"setval": "policy route-map {{route_map}} rule {{sequence}} "
	"match rpki {{match.rpki}}",
	"result": {
	"route_maps": {
	"{{ route_map }}": {
	"route_map": '{{ route_map }}',
	"entries": {
	"{{sequence}}": {
	"sequence": "{{sequence}}",
	"match": {
	"rpki": "{{value}}",
	},
	},
	},
	},
	},
	},
	},

	]
	# fmt: on
	diff --git a/plugins/module_utils/network/vyos/rm_templates/snmp_server.py b/plugins/module_utils/network/vyos/rm_templates/snmp_server.py
	index 71753083..ff1c6465 100644
	--- a/plugins/module_utils/network/vyos/rm_templates/snmp_server.py
	+++ b/plugins/module_utils/network/vyos/rm_templates/snmp_server.py
	@@ -1,610 +1,602 @@
	# -- coding: utf-8 --
	# Copyright 2022 Red Hat
	# GNU General Public License v3.0+
	# (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)

	from __future__ import absolute_import, division, print_function


	__metaclass__ = type

	"""
	The Snmp_server parser templates file. This contains
	a list of parser definitions and associated functions that
	facilitates both facts gathering and native command generation for
	the given network resource.
	"""

	import re

	from ansible_collections.ansible.netcommon.plugins.module_utils.network.common.rm_base.network_template import (
	NetworkTemplate,
	)


	def _tmplt_snmp_server_communities(config_data):
	config_data = config_data["communities"]
	command = []
	cmd = "service snmp community {name}".format(**config_data)
	if "authorization_type" in config_data:
	auth_cmd = cmd + " authorization {authorization_type}".format(**config_data)
	command.append(auth_cmd)
	if "clients" in config_data:
	for c in config_data["clients"]:
	client_cmd = cmd + " client " + c
	command.append(client_cmd)
	if "networks" in config_data:
	for n in config_data["networks"]:
	network_command = cmd + " network " + n
	command.append(network_command)
	if not command:
	command.append(cmd)
	return command


	def _tmplt_snmp_server_trap_target(config_data):
	config_data = config_data["trap_target"]
	command = "service snmp trap-target {address}".format(**config_data)
	if "authorization_type" in config_data:
	command += " authorization {authorization_type}".format(**config_data)
	if "client" in config_data:
	command += " client {client}".format(**config_data)
	if "network" in config_data:
	command += " network {network}".format(**config_data)
	return command


	def _tmplt_snmp_server_v3_groups(config_data):
	config_data = config_data["snmp_v3"]["groups"]
	command = []
	cmd = "service snmp v3 group {group}".format(**config_data)
	if "mode" in config_data:
	mode_cmd = cmd + " mode {mode}".format(**config_data)
	command.append(mode_cmd)
	if "seclevel" in config_data:
	sec_cmd = cmd + " seclevel {seclevel}".format(**config_data)
	command.append(sec_cmd)
	if "view" in config_data:
	view_cmd = cmd + " view {view}".format(**config_data)
	command.append(view_cmd)
	return command


	def _tmplt_snmp_server_v3_trap_target(config_data):
	config_data = config_data["snmp_v3"]["trap_targets"]
	command = "service snmp v3 trap-target {address} ".format(**config_data)
	if "authentication" in config_data:
	command += " auth"
	config_data = config_data["authentication"]
	if "privacy" in config_data:
	command += " privacy"
	config_data = config_data["privacy"]
	if "type" in config_data:
	command += " type {mode}".format(**config_data)
	if "encrypted_key" in config_data:
	command += " encrypted-password {encrypted_key}".format(**config_data)
	if "plaintext_key" in config_data:
	command += " plaintext-password {plaintext_key}".format(**config_data)
	return command


	def _tmplt_snmp_server_v3_user(config_data):
	config_data = config_data["snmp_v3"]["users"]
	command = []
	cmd = "service snmp v3 user {user}".format(**config_data)
	for k in ["authentication", "privacy"]:
	if config_data.get(k):
	config = config_data[k]
	if k == "authentication":
	val = " auth"
	else:
	val = " privacy"
	if "type" in config:
	type_cmd = cmd + val + " type {type}".format(**config)
	command.append(type_cmd)
	if "encrypted_key" in config:
	enc_cmd = cmd + val + " encrypted-password {encrypted_key}".format(**config)
	command.append(enc_cmd)
	if "plaintext_key" in config:
	plain_cmd = cmd + val + " plaintext-password {plaintext_key}".format(**config)
	command.append(plain_cmd)
	return command


	def _tmplt_snmp_server_v3_views(config_data):
	config_data = config_data["snmp_v3"]["views"]
	command = "service snmp v3 view {view} oid {oid}".format(**config_data)
	if "exclude" in config_data:
	command += " exclude {exclude}".format(**config_data)
	if "mask" in config_data:
	command += " mask {mask}".format(**config_data)
	return command


	class Snmp_serverTemplate(NetworkTemplate):
	def __init__(self, lines=None, module=None):
	prefix = {"set": "set", "remove": "delete"}
	super(Snmp_serverTemplate, self).__init__(
	lines=lines,
	tmplt=self,
	prefix=prefix,
	module=module,
	)

	# fmt: off
	PARSERS = [
	# service snmp community <>
	{
	"name": "communities",
	"getval": re.compile(
	r"""
	^set\sservice\ssnmp\scommunity
	\s+(?P<name>\S+)
	- \s(?P<auth>authorization\srw\|authorization\sro)
	- \s(client\s(?P<client>\S+))
	- \s(network\s(?P<network>\S+))
	+ \s*(?P<auth>authorization\srw\|authorization\sro)?
	+ \s*(client\s(?P<client>\S+))?
	+ \s*(network\s(?P<network>\S+))?
	$""",
	re.VERBOSE,
	),
	"setval": _tmplt_snmp_server_communities,
	"result": {
	"communities": {
	"{{ name }}": {
	"name": "{{ name }}",
	"clients": ['{{ client if client is defined else "None" }}'],
	"networks": ['{{ network if network is defined else "None" }}'],
	"authorization_type": '{{ auth.split(" ")[1] if auth is defined else None }}',
	},
	},
	},
	},
	# service snmp contact <>
	{
	"name": "contact",
	"getval": re.compile(
	r"""
	^set\sservice\ssnmp\scontact
	- \s+(?P<name>\S+)
	- *$""",
	+ \s+(?P<name>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": "service snmp contact {{ contact }}",
	"result": {
	"contact": "{{ name }}",
	},
	},
	# service snmp description <>
	{
	"name": "description",
	"getval": re.compile(
	r"""
	^set\sservice\ssnmp\sdescription
	- \s+(?P<name>\S+)
	- *$""",
	+ \s+(?P<name>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": "service snmp description {{ description }}",
	"result": {
	"description": "{{ name }}",
	},
	},
	# service snmp listen-address <> port <>
	{
	"name": "listen_addresses",
	"getval": re.compile(
	r"""
	^set\sservice\ssnmp\slisten-address
	\s+(?P<addr>\S+)
	- \s(port)
	- \s(?P<port>\d+)
	+ \s*(port)?
	+ \s*(?P<port>\d+)?
	$""",
	re.VERBOSE,
	),
	"setval": "service snmp listen-address {{ listen_addresses.address }}"
	"{{ (' port ' + listen_addresses.port\|string) if listen_addresses.port is defined else '' }}",
	"result": {
	"listen_addresses": {
	"{{ addr }}": {
	"address": "{{ addr }}",
	"port": "{{ port }}",
	},
	},
	},
	},
	# service snmp location <>
	{
	"name": "location",
	"getval": re.compile(
	r"""
	^set\sservice\ssnmp\slocation
	\s(?P<name>.*)
	$""",
	re.VERBOSE,
	),
	"setval": "service snmp location {{ '\\'' + location + '\\''}}",
	"result": {
	"location": "{{ name }}",
	},
	},
	# service snmp smux-peer <>
	{
	"name": "smux_peer",
	"getval": re.compile(
	r"""
	^set\sservice\ssnmp\ssmux-peer
	- \s+(?P<name>\S+)
	- *$""",
	+ \s+(?P<name>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": "service snmp smux-peer {{ smux_peer }}",
	"result": {
	"smux_peer": "{{ name }}",
	},
	},
	# service snmp trap-source <>
	{
	"name": "trap_source",
	"getval": re.compile(
	r"""
	^set\sservice\ssnmp\strap-source
	- \s+(?P<name>\S+)
	- *$""",
	+ \s+(?P<name>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": "service snmp trap-source {{ trap_source }}",
	"result": {
	"trap_source": "{{ name }}",
	},
	},
	# service snmp trap-target <>
	{
	"name": "trap_target",
	"getval": re.compile(
	r"""
	^set\sservice\ssnmp\strap-target
	\s+(?P<name>\S+)
	- \s(?P<comm>community\s\S+)
	- \s(?P<port>port\s\d+)
	- $""",
	+ \s*(?P<comm>community\s\S+)?
	+ \s*(?P<port>port\s\d+)? $""",
	re.VERBOSE,
	),
	"setval": _tmplt_snmp_server_trap_target,
	"result": {
	"trap_target": {
	"address": "{{ name }}",
	"community": "{{ comm.split(" ")[1] if comm is defined else None }}",
	"port": "{{ port.split(" ")[1] if port is defined else None }}",
	},
	},
	},
	# service snmp v3 engineid <>
	{
	"name": "snmp_v3.engine_id",
	"getval": re.compile(
	r"""
	^set\sservice\ssnmp\sv3\sengineid
	- \s+(?P<name>\S+)
	- *$""",
	+ \s+(?P<name>\S+)\s*$""",
	re.VERBOSE,
	),
	"setval": "service snmp v3 engineid {{ snmp_v3.engine_id }}",
	"result": {
	"snmp_v3": {
	"engine_id": "{{ name }}",
	},
	},
	},
	# service snmp v3 group <>
	{
	"name": "snmp_v3.groups",
	"getval": re.compile(
	r"""
	^set\sservice\ssnmp\sv3\sgroup
	\s+(?P<name>\S+)
	- \s(?P<mode>mode\s\S+)
	- \s(?P<sec>seclevel\s\S+)
	- \s(?P<view>view\s\S+)
	+ \s*(?P<mode>mode\s\S+)?
	+ \s*(?P<sec>seclevel\s\S+)?
	+ \s*(?P<view>view\s\S+)?
	$""",
	re.VERBOSE,
	),
	"setval": _tmplt_snmp_server_v3_groups,
	"result": {
	"snmp_v3": {
	"groups": {
	"{{ name }}": {
	"group": "{{ name }}",
	"mode": '{{ mode.split(" ")[1] if mode is defined else None }}',
	"seclevel": '{{ sec.split(" ")[1] if sec is defined else None }}',
	"view": '{{ view.split(" ")[1] if view is defined else None }}',
	},
	},
	},
	},
	},
	# service snmp v3 trap-target <> auth <>
	{
	"name": "snmp_v3.trap_targets.authentication",
	"getval": re.compile(
	r"""
	^set\sservice\ssnmp\sv3\strap-target
	\s+(?P<name>\S+)
	\s+auth
	- \s(?P<enc>encrypted-password\s\S+)
	- \s(?P<plain>plaintext-password\s\S+)
	- \s(?P<type>type\s\S+)
	+ \s*(?P<enc>encrypted-password\s\S+)?
	+ \s*(?P<plain>plaintext-password\s\S+)?
	+ \s*(?P<type>type\s\S+)?
	$""",
	re.VERBOSE,
	),
	"setval": _tmplt_snmp_server_v3_trap_target,
	"result": {
	"snmp_v3": {
	"trap_targets": {
	"{{ name }}": {
	"address": "{{ name }}",
	"authentication": {
	"encrypted_key": '{{ enc.split(" ")[1] if enc is defined else None }}',
	"plaintext_key": '{{ plain.split(" ")[1] if plain is defined else None }}',
	"type": '{{ type.split(" ")[1] if type is defined else None }}',
	},
	},
	},
	},
	},
	},
	# service snmp v3 trap-target <> port <>
	{
	"name": "snmp_v3.trap_targets.port",
	"getval": re.compile(
	r"""
	^set\sservice\ssnmp\sv3\strap-target
	\s+(?P<name>\S+)
	- \s+(?P<port>port\s\d+)*
	- $""",
	+ \s+(?P<port>port\s\d+)? $""",
	re.VERBOSE,
	),
	"setval": "service snmp v3 trap-target port {{ snmp_v3.trap_targets.port }}",
	"result": {
	"snmp_v3": {
	"trap_targets": {
	"{{ name }}": {
	"address": "{{ name }}",
	"port": "{{ port }}",
	},
	},
	},
	},
	},
	# service snmp v3 trap-target <> protocol <>
	{
	"name": "snmp_v3.trap_targets.protocol",
	"getval": re.compile(
	r"""
	^set\sservice\ssnmp\sv3\strap-target
	\s+(?P<name>\S+)
	- \s+(?P<protocol>protocol\s\S+)*
	+ \s+(?P<protocol>protocol\s\S+)?
	$""",
	re.VERBOSE,
	),
	"setval": "service snmp v3 trap-target protocol {{ snmp_v3.trap_targets.protocol }}",
	"result": {
	"snmp_v3": {
	"trap_targets": {
	"{{ name }}": {
	"address": "{{ name }}",
	"protocol": "{{ protocol }}",
	},
	},
	},
	},
	},
	# service snmp v3 trap-target <> type <>
	{
	"name": "snmp_v3.trap_targets.type",
	"getval": re.compile(
	r"""
	^set\sservice\ssnmp\sv3\strap-target
	\s+(?P<name>\S+)
	- \s+(?P<type>type\s\S+)*
	+ \s+(?P<type>type\s\S+)?
	$""",
	re.VERBOSE,
	),
	"setval": "service snmp v3 trap-target type {{ snmp_v3.trap_targets.type }}",
	"result": {
	"snmp_v3": {
	"trap_targets": {
	"{{ name }}": {
	"address": "{{ name }}",
	"type": "{{ type }}",
	},
	},
	},
	},
	},
	# service snmp v3 trap-target <> user <>
	{
	"name": "snmp_v3.trap_targets.user",
	"getval": re.compile(
	r"""
	^set\sservice\ssnmp\sv3\strap-target
	\s+(?P<name>\S+)
	- \s+(?P<user>user\s\S+)*
	+ \s+(?P<user>user\s\S+)?
	$""",
	re.VERBOSE,
	),
	"setval": "service snmp v3 trap-target user {{ snmp_v3.trap_targets.user }}",
	"result": {
	"snmp_v3": {
	"trap_targets": {
	"{{ name }}": {
	"address": "{{ name }}",
	"user": "{{ user }}",
	},
	},
	},
	},
	},
	# service snmp v3 trap-target <> privacy <>
	{
	"name": "snmp_v3.trap_targets.privacy",
	"getval": re.compile(
	r"""
	^set\sservice\ssnmp\sv3\strap-target
	\s+(?P<name>\S+)
	\s+privacy
	- \s(?P<enc>encrypted-password\s\S+)
	- \s(?P<plain>plaintext-password\s\S+)
	- \s(?P<type>type\s\S+)
	+ \s*(?P<enc>encrypted-password\s\S+)?
	+ \s*(?P<plain>plaintext-password\s\S+)?
	+ \s*(?P<type>type\s\S+)?
	$""",
	re.VERBOSE,
	),
	"setval": _tmplt_snmp_server_v3_trap_target,
	"result": {
	"snmp_v3": {
	"trap_targets": {
	"{{ name }}": {
	"address": "{{ name }}",
	"privacy": {
	"encrypted_key": '{{ enc.split(" ")[1] if enc is defined else None }}',
	"plaintext_key": '{{ plain.split(" ")[1] if plain is defined else None }}',
	"type": '{{ type.split(" ")[1] if type is defined else None }}',
	},
	},
	},
	},
	},
	},
	# service snmp v3 user <> auth <>
	{
	"name": "snmp_v3.users.authentication",
	"getval": re.compile(
	r"""
	^set\sservice\ssnmp\sv3\suser
	\s+(?P<name>\S+)
	\s+auth
	- \s(?P<enc>encrypted-password\s\S+)
	- \s(?P<plain>plaintext-password\s\S+)
	- \s(?P<type>type\s\S+)
	+ \s*(?P<enc>encrypted-password\s\S+)?
	+ \s*(?P<plain>plaintext-password\s\S+)?
	+ \s*(?P<type>type\s\S+)?
	$""",
	re.VERBOSE,
	),
	"setval": _tmplt_snmp_server_v3_user,
	"result": {
	"snmp_v3": {
	"users": {
	"{{ name }}": {
	"user": "{{ name }}",
	"authentication": {
	"encrypted_key": '{{ enc.split(" ")[1] if enc is defined else None }}',
	"plaintext_key": '{{ plain.split(" ")[1] if plain is defined else None }}',
	"type": '{{ type.split(" ")[1] if type is defined else None }}',
	},
	},
	},
	},
	},
	},
	# service snmp v3 user <> privacy <>
	{
	"name": "snmp_v3.users.privacy",
	"getval": re.compile(
	r"""
	^set\sservice\ssnmp\sv3\suser
	\s+(?P<name>\S+)
	\s+privacy
	- \s(?P<enc>encrypted-password\s\S+)
	- \s(?P<plain>plaintext-password\s\S+)
	- \s(?P<type>type\s\S+)
	+ \s*(?P<enc>encrypted-password\s\S+)?
	+ \s*(?P<plain>plaintext-password\s\S+)?
	+ \s*(?P<type>type\s\S+)?
	$""",
	re.VERBOSE,
	),
	"setval": _tmplt_snmp_server_v3_user,
	"result": {
	"snmp_v3": {
	"users": {
	"{{ name }}": {
	"user": "{{ name }}",
	"privacy": {
	"encrypted_key": '{{ enc.split(" ")[1] if enc is defined else None }}',
	"plaintext_key": '{{ plain.split(" ")[1] if plain is defined else None }}',
	"type": '{{ type.split(" ")[1] if type is defined else None }}',
	},
	},
	},
	},
	},
	},
	# service snmp v3 user <> group <>
	{
	"name": "snmp_v3.users.group",
	"getval": re.compile(
	r"""
	^set\sservice\ssnmp\sv3\suser
	\s+(?P<name>\S+)
	- \s+(?P<group>group\s.+)*
	- $""",
	+ \s+(?P<group>group\s.+)? $""",
	re.VERBOSE,
	),
	"setval": "service snmp v3 user {{ snmp_v3.users.user }} group {{ snmp_v3.users.group }}",
	"result": {
	"snmp_v3": {
	"users": {
	"{{ name }}": {
	"user": "{{ name }}",
	"group": "{{ group.split(" ")[1] if group is defined else None }}",
	},
	},
	},
	},
	},
	# service snmp v3 user <> mode <>
	{
	"name": "snmp_v3.users.mode",
	"getval": re.compile(
	r"""
	^set\sservice\ssnmp\sv3\suser
	\s+(?P<name>\S+)
	- \s+(?P<mode>mode\s\S+)*
	+ \s+(?P<mode>mode\s\S+)?
	$""",
	re.VERBOSE,
	),
	"setval": "service snmp v3 user {{ snmp_v3.users.user }} mode {{ snmp_v3.users.mode }}",
	"result": {
	"snmp_v3": {
	"users": {
	"{{ name }}": {
	"user": "{{ name }}",
	"mode": "{{ mode }}",
	},
	},
	},
	},
	},
	# service snmp v3 view <>
	{
	"name": "snmp_v3.views",
	"getval": re.compile(
	r"""
	^set\sservice\ssnmp\sv3\sview
	\s+(?P<name>\S+)
	\s+(?P<oid>oid\s\S+)
	- \s(?P<ex>exclude\s\S+)
	- \s(?P<mask>mask\s\S+)
	+ \s*(?P<ex>exclude\s\S+)?
	+ \s*(?P<mask>mask\s\S+)?
	$""",
	re.VERBOSE,
	),
	"setval": _tmplt_snmp_server_v3_views,
	"result": {
	"snmp_v3": {
	"views": {
	"{{ name }}": {
	"view": "{{ name }}",
	"oid": '{{ oid.split(" ")[1] if oid is defined else None }}',
	"exclude": '{{ ex.split(" ")[1] if ex is defined else None }}',
	"mask": '{{ mask.split(" ")[1] if mask is defined else None }}',
	},
	},
	},
	},
	},
	]
	# fmt: on
	diff --git a/tests/unit/modules/network/vyos/test_rm_templates_perf.py b/tests/unit/modules/network/vyos/test_rm_templates_perf.py
	new file mode 100644
	index 00000000..d2060f46
	--- /dev/null
	+++ b/tests/unit/modules/network/vyos/test_rm_templates_perf.py
	@@ -0,0 +1,163 @@
	+# -- coding: utf-8 --
	+# Copyright 2026 Red Hat
	+# GNU General Public License v3.0+
	+# (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
	+
	+"""Performance budget tests for rm_templates parsers.
	+
	+These tests guard against re-introducing catastrophic regex backtracking
	+in the rm_template parsers (T8609). Pre-fix, parse() over realistic
	+device-output input could take 50+ seconds because of `(group)*`
	+quantifiers on groups containing `\\S+`. Post-fix, the same input
	+parses in single-digit milliseconds.
	+
	+A 1-second budget is comfortably above post-fix runtime and well below
	+the pre-regression cliff, so the test fails sharply if the bug returns.
	+"""
	+
	+from __future__ import absolute_import, division, print_function
	+
	+
	+__metaclass__ = type
	+
	+import time
	+
	+from ansible_collections.vyos.vyos.plugins.module_utils.network.vyos.rm_templates.bgp_address_family_14 import (
	+ Bgp_address_familyTemplate14,
	+)
	+from ansible_collections.vyos.vyos.plugins.module_utils.network.vyos.rm_templates.bgp_global_14 import (
	+ Bgp_globalTemplate14,
	+)
	+from ansible_collections.vyos.vyos.plugins.module_utils.network.vyos.rm_templates.route_maps_14 import (
	+ Route_mapsTemplate14,
	+)
	+from ansible_collections.vyos.vyos.plugins.module_utils.network.vyos.rm_templates.snmp_server import (
	+ Snmp_serverTemplate,
	+)
	+
	+
	+PARSE_BUDGET_SECONDS = 1.0
	+
	+
	+def _time_parse(parser_class, lines):
	+ """Time a single ``parse()`` call against ``lines``; returns elapsed seconds."""
	+ parser = parser_class(lines=lines)
	+ t0 = time.perf_counter()
	+ parser.parse()
	+ return time.perf_counter() - t0
	+
	+
	+def test_route_maps_14_parse_budget():
	+ """Realistic route-map config: parse() must finish under 1s.
	+
	+ Pre-T8609: ~50s. Post-fix: <50ms. Inputs use 20+ char names
	+ because the backtracking is exponential in the first \\S+ run
	+ after the prefix.
	+ """
	+ lines = [
	+ "set policy route-map ADVERTISE-ANYCAST-v6 rule 10 action 'permit'",
	+ "set policy route-map ADVERTISE-ANYCAST-v6 rule 10 match ipv6 address prefix-list 'ANYCAST-AGGREGATE-v6'",
	+ "set policy route-map DEFAULT-ORIGINATE-SENTINEL-v6 rule 10 action 'permit'",
	+ "set policy route-map DEFAULT-ORIGINATE-SENTINEL-v6 rule 10 match ipv6 address prefix-list 'AS64496-SENTINEL-v6'",
	+ "set policy route-map DEFAULT-ORIGINATE-SENTINEL-v6 rule 10 set local-preference '120'",
	+ "set policy route-map IXP-PEER-INGRESS-v4 rule 10 action 'permit'",
	+ "set policy route-map IXP-PEER-INGRESS-v4 rule 10 match ip address prefix-list 'IXP-INBOUND-v4'",
	+ "set policy route-map IXP-PEER-INGRESS-v4 rule 10 set community 'additive 65000:100'",
	+ "set policy route-map TRANSIT-EGRESS-v4 rule 100 action 'permit'",
	+ "set policy route-map TRANSIT-EGRESS-v4 rule 100 match ip address prefix-list 'CUSTOMER-PREFIXES-v4'",
	+ "set policy route-map TRANSIT-EGRESS-v4 rule 100 set as-path prepend '65000 65000'",
	+ "set policy route-map UPSTREAM-INGRESS-v4 rule 10 action 'permit'",
	+ ]
	+ elapsed = _time_parse(Route_mapsTemplate14, lines)
	+ assert elapsed < PARSE_BUDGET_SECONDS, (
	+ "Route_mapsTemplate14.parse() took %.2fs (budget %.2fs); "
	+ "possible regression of T8609 (rm_templates regex backtracking)."
	+ % (elapsed, PARSE_BUDGET_SECONDS)
	+ )
	+
	+
	+def test_bgp_global_14_parse_budget():
	+ """Realistic BGP neighbor/address-family config: parse() under 1s."""
	+ lines = [
	+ "set protocols bgp 65001 neighbor 2001:db8:abcd:1234::1 remote-as '65002'",
	+ "set protocols bgp 65001 neighbor 2001:db8:abcd:1234::1 description 'IXP-PEER-1'",
	+ "set protocols bgp 65001 neighbor 2001:db8:abcd:1234::1 address-family ipv6-unicast route-map import 'IXP-INGRESS-v6'",
	+ "set protocols bgp 65001 neighbor 2001:db8:abcd:1234::1 address-family ipv6-unicast route-map export 'IXP-EGRESS-v6'",
	+ "set protocols bgp 65001 neighbor 192.0.2.1 remote-as '65003'",
	+ "set protocols bgp 65001 neighbor 192.0.2.1 description 'TRANSIT-PROVIDER-1'",
	+ "set protocols bgp 65001 neighbor 192.0.2.1 address-family ipv4-unicast route-map import 'TRANSIT-INGRESS-v4'",
	+ "set protocols bgp 65001 neighbor 192.0.2.1 address-family ipv4-unicast route-map export 'TRANSIT-EGRESS-v4'",
	+ ]
	+ elapsed = _time_parse(Bgp_globalTemplate14, lines)
	+ assert elapsed < PARSE_BUDGET_SECONDS, (
	+ "Bgp_globalTemplate14.parse() took %.2fs (budget %.2fs); "
	+ "possible regression of T8609 (rm_templates regex backtracking)."
	+ % (elapsed, PARSE_BUDGET_SECONDS)
	+ )
	+
	+
	+def test_snmp_server_parse_budget():
	+ """Realistic SNMP v3 config: parse() under 1s."""
	+ lines = [
	+ "set service snmp community PUBLIC-COMMUNITY-NAME-1 authorization 'ro'",
	+ "set service snmp community PUBLIC-COMMUNITY-NAME-1 client '192.0.2.0/24'",
	+ "set service snmp v3 trap-target TRAP-TARGET-LONG-NAME-1 user 'monitor'",
	+ "set service snmp v3 trap-target TRAP-TARGET-LONG-NAME-1 protocol 'udp'",
	+ "set service snmp v3 trap-target TRAP-TARGET-LONG-NAME-1 port '162'",
	+ "set service snmp v3 user TRAP-USER-LONG-NAME-1 mode 'auth'",
	+ "set service snmp v3 user TRAP-USER-LONG-NAME-1 group 'monitor'",
	+ ]
	+ elapsed = _time_parse(Snmp_serverTemplate, lines)
	+ assert elapsed < PARSE_BUDGET_SECONDS, (
	+ "Snmp_serverTemplate.parse() took %.2fs (budget %.2fs); "
	+ "possible regression of T8609 (rm_templates regex backtracking)."
	+ % (elapsed, PARSE_BUDGET_SECONDS)
	+ )
	+
	+
	+def test_bgp_address_family_14_parse_budget():
	+ """Realistic BGP address-family aggregate config: parse() under 1s."""
	+ lines = [
	+ "set protocols bgp 65001 address-family ipv4-unicast network 198.51.100.0/24 backdoor",
	+ "set protocols bgp 65001 address-family ipv4-unicast network 198.51.100.0/24 path-limit '4'",
	+ "set protocols bgp 65001 address-family ipv4-unicast network 198.51.100.0/24 route-map 'NET-IN-v4'",
	+ "set protocols bgp 65001 address-family ipv4-unicast aggregate-address 203.0.113.0/24 as-set",
	+ "set protocols bgp 65001 address-family ipv4-unicast aggregate-address 203.0.113.0/24 summary-only",
	+ "set protocols bgp 65001 address-family ipv6-unicast network 2001:db8:abcd:1234::/64 backdoor",
	+ "set protocols bgp 65001 address-family ipv6-unicast network 2001:db8:abcd:1234::/64 route-map 'NET-IN-v6'",
	+ "set protocols bgp 65001 address-family ipv6-unicast aggregate-address 2001:db8::/32 as-set",
	+ "set protocols bgp 65001 address-family ipv6-unicast aggregate-address 2001:db8::/32 summary-only",
	+ ]
	+ elapsed = _time_parse(Bgp_address_familyTemplate14, lines)
	+ assert elapsed < PARSE_BUDGET_SECONDS, (
	+ "Bgp_address_familyTemplate14.parse() took %.2fs (budget %.2fs); "
	+ "possible regression of T8609 (rm_templates regex backtracking)."
	+ % (elapsed, PARSE_BUDGET_SECONDS)
	+ )
	+
	+
	+def test_route_maps_14_set_comm_list_delete_matches_setval():
	+ """Round-trip check: the `set_comm_list_delete` parser must match the line its setval generates.
	+
	+ `set_comm_list_delete`'s setval emits `set policy route-map X rule N set
	+ comm-list delete` with no token after `delete`. Pre-T8609 the getval
	+ happened to match this by accident (a `*` quantifier on the trailing
	+ `(?P<delete>\\S+)` made the group optional after VERBOSE-strip). An
	+ earlier draft of T8609's fix made the group required, causing the
	+ parser to silently ignore its own output. This test guards the
	+ round-trip.
	+ """
	+ line = "set policy route-map MY-MAP rule 10 set comm-list delete"
	+ parser = Route_mapsTemplate14(lines=[line])
	+ result = parser.parse()
	+ rm = result.get("route_maps", {}).get("MY-MAP")
	+ assert rm is not None, (
	+ "route_maps_14: set_comm_list_delete parser failed to match its "
	+ "own setval-generated line %r; the parser is broken." % line
	+ )
	+ entry = rm.get("entries", {}).get(10, {})
	+ comm_list = entry.get("set", {}).get("comm_list", {})
	+ assert comm_list.get("delete"), (
	+ "route_maps_14: set_comm_list_delete matched the line but did not "
	+ "populate set.comm_list.delete; check the result template."
	+ )

File Metadata

Mime Type: text/x-diff
Expires: Sat, Sep 26, 2:26 PM (1 d, 12 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 4285390
Default Alt Text: (424 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions