diff --git a/plugins/module_utils/network/vyos/config/firewall_rules/firewall_rules.py b/plugins/module_utils/network/vyos/config/firewall_rules/firewall_rules.py
index e58593f..5c37741 100644
--- a/plugins/module_utils/network/vyos/config/firewall_rules/firewall_rules.py
+++ b/plugins/module_utils/network/vyos/config/firewall_rules/firewall_rules.py
@@ -1,1034 +1,1017 @@
 #
 # -*- coding: utf-8 -*-
 # Copyright 2019 Red Hat
 # GNU General Public License v3.0+
 # (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
 """
 The vyos_firewall_rules class
 It is in this file where the current configuration (as dict)
 is compared to the provided configuration (as dict) and the command set
 necessary to bring the current configuration to it's desired end-state is
 created
 """
 from __future__ import absolute_import, division, print_function
 
 __metaclass__ = type
 
 from copy import deepcopy
 from ansible_collections.ansible.netcommon.plugins.module_utils.network.common.cfg.base import (
     ConfigBase,
 )
 from ansible_collections.ansible.netcommon.plugins.module_utils.network.common.utils import (
     to_list,
     remove_empties,
 )
 from ansible_collections.vyos.vyos.plugins.module_utils.network.vyos.facts.facts import (
     Facts,
 )
 from ansible.module_utils.six import iteritems
 from ansible_collections.vyos.vyos.plugins.module_utils.network.vyos.utils.utils import (
     list_diff_want_only,
 )
 
 
 class Firewall_rules(ConfigBase):
     """
     The vyos_firewall_rules class
     """
 
     gather_subset = [
         "!all",
         "!min",
     ]
 
     gather_network_resources = [
         "firewall_rules",
     ]
 
     def __init__(self, module):
         super(Firewall_rules, self).__init__(module)
 
     def get_firewall_rules_facts(self, data=None):
         """ Get the 'facts' (the current configuration)
 
         :rtype: A dictionary
         :returns: The current configuration as a dictionary
         """
         facts, _warnings = Facts(self._module).get_facts(
             self.gather_subset, self.gather_network_resources, data=data
         )
         firewall_rules_facts = facts["ansible_network_resources"].get(
             "firewall_rules"
         )
         if not firewall_rules_facts:
             return []
         return firewall_rules_facts
 
     def execute_module(self):
         """ Execute the module
 
         :rtype: A dictionary
         :returns: The result from module execution
         """
         result = {"changed": False}
         warnings = list()
         commands = list()
 
         if self.state in self.ACTION_STATES:
             existing_firewall_rules_facts = self.get_firewall_rules_facts()
         else:
             existing_firewall_rules_facts = []
 
         if self.state in self.ACTION_STATES or self.state == "rendered":
             commands.extend(self.set_config(existing_firewall_rules_facts))
 
         if commands and self.state in self.ACTION_STATES:
             if not self._module.check_mode:
                 self._connection.edit_config(commands)
             result["changed"] = True
 
         if self.state in self.ACTION_STATES:
             result["commands"] = commands
 
         if self.state in self.ACTION_STATES or self.state == "gathered":
             changed_firewall_rules_facts = self.get_firewall_rules_facts()
         elif self.state == "rendered":
             result["rendered"] = commands
         elif self.state == "parsed":
             running_config = self._module.params["running_config"]
             if not running_config:
                 self._module.fail_json(
                     msg="value of running_config parameter must not be empty for state parsed"
                 )
             result["parsed"] = self.get_firewall_rules_facts(
                 data=running_config
             )
         else:
             changed_firewall_rules_facts = []
 
         if self.state in self.ACTION_STATES:
             result["before"] = existing_firewall_rules_facts
             if result["changed"]:
                 result["after"] = changed_firewall_rules_facts
         elif self.state == "gathered":
             result["gathered"] = changed_firewall_rules_facts
 
         result["warnings"] = warnings
         return result
 
     def set_config(self, existing_firewall_rules_facts):
         """ Collect the configuration from the args passed to the module,
             collect the current configuration (as a dict from facts)
 
         :rtype: A list
         :returns: the commands necessary to migrate the current configuration
                   to the desired configuration
         """
         want = self._module.params["config"]
         have = existing_firewall_rules_facts
         resp = self.set_state(want, have)
         return to_list(resp)
 
     def set_state(self, w, h):
         """ Select the appropriate function based on the state provided
 
         :param want: the desired configuration as a dictionary
         :param have: the current configuration as a dictionary
         :rtype: A list
         :returns: the commands necessary to migrate the current configuration
                   to the desired configuration
         """
         commands = []
         if (
             self.state in ("merged", "replaced", "overridden", "rendered")
             and not w
         ):
             self._module.fail_json(
                 msg="value of config parameter must not be empty for state {0}".format(
                     self.state
                 )
             )
         if self.state == "overridden":
             commands.extend(self._state_overridden(w, h))
         elif self.state == "deleted":
             commands.extend(self._state_deleted(w, h))
         elif w:
             if self.state == "merged" or self.state == "rendered":
                 commands.extend(self._state_merged(w, h))
             elif self.state == "replaced":
                 commands.extend(self._state_replaced(w, h))
         return commands
 
     def _state_replaced(self, want, have):
         """ The command generator when state is replaced
          :rtype: A list
          :returns: the commands necessary to migrate the current configuration
                    to the desired configuration
          """
         commands = []
         if have:
             for h in have:
                 r_sets = self._get_r_sets(h)
                 for rs in r_sets:
                     w = self.search_r_sets_in_have(want, rs["name"], "r_list")
                     commands.extend(
                         self._add_r_sets(h["afi"], rs, w, opr=False)
                     )
         commands.extend(self._state_merged(want, have))
         return commands
 
     def _state_overridden(self, want, have):
         """ The command generator when state is overridden
 
         :rtype: A list
         :returns: the commands necessary to migrate the current configuration
                   to the desired configuration
         """
         commands = []
         if have:
             for h in have:
                 r_sets = self._get_r_sets(h)
                 for rs in r_sets:
                     w = self.search_r_sets_in_have(want, rs["name"], "r_list")
                     if not w:
                         commands.append(
                             self._compute_command(
                                 h["afi"], rs["name"], remove=True
                             )
                         )
                     else:
                         commands.extend(
                             self._add_r_sets(h["afi"], rs, w, opr=False)
                         )
         commands.extend(self._state_merged(want, have))
         return commands
 
     def _state_merged(self, want, have):
         """ The command generator when state is merged
 
         :rtype: A list
         :returns: the commands necessary to merge the provided into
                   the current configuration
         """
         commands = []
         for w in want:
             r_sets = self._get_r_sets(w)
             for rs in r_sets:
                 h = self.search_r_sets_in_have(have, rs["name"], "r_list")
                 commands.extend(self._add_r_sets(w["afi"], rs, h))
         return commands
 
     def _state_deleted(self, want, have):
         """ The command generator when state is deleted
 
         :rtype: A list
         :returns: the commands necessary to remove the current configuration
                   of the provided objects
         """
         commands = []
         if want:
             for w in want:
                 r_sets = self._get_r_sets(w)
                 if r_sets:
                     for rs in r_sets:
                         h = self.search_r_sets_in_have(
                             have, rs["name"], "r_list"
                         )
                         if h:
-                            w_rules = rs.get("rules") or []
-                            h_rules = h.get("rules") or []
-                            if w_rules and h_rules:
-                                for rule in w_rules:
-                                    if self.search_r_sets_in_have(
-                                        h_rules, rule["number"], "rules"
-                                    ):
-                                        commands.append(
-                                            self._add_r_base_attrib(
-                                                w["afi"],
-                                                rs["name"],
-                                                "number",
-                                                rule,
-                                                opr=False,
-                                            )
-                                        )
-                            else:
-                                commands.append(
-                                    self._compute_command(
-                                        w["afi"], h["name"], remove=True
-                                    )
+                            commands.append(
+                                self._compute_command(
+                                    w["afi"], h["name"], remove=True
                                 )
+                            )
                 elif have:
                     for h in have:
                         if h["afi"] == w["afi"]:
                             commands.append(
                                 self._compute_command(w["afi"], remove=True)
                             )
         elif have:
             for h in have:
                 r_sets = self._get_r_sets(h)
                 if r_sets:
                     commands.append(
                         self._compute_command(afi=h["afi"], remove=True)
                     )
         return commands
 
     def _add_r_sets(self, afi, want, have, opr=True):
         """
         This function forms the set/delete commands based on the 'opr' type
         for rule-sets attributes.
         :param afi: address type.
         :param want: desired config.
         :param have: target config.
         :param opr: True/False.
         :return: generated commands list.
         """
         commands = []
         l_set = ("description", "default_action", "enable_default_log")
         h_rs = {}
         h_rules = {}
         w_rs = deepcopy(remove_empties(want))
         w_rules = w_rs.pop("rules", None)
         if have:
             h_rs = deepcopy(remove_empties(have))
             h_rules = h_rs.pop("rules", None)
         if w_rs:
             for key, val in iteritems(w_rs):
                 if (
                     opr
                     and key in l_set
                     and not (h_rs and self._is_w_same(w_rs, h_rs, key))
                 ):
                     if key == "enable_default_log":
                         if val and (
                             not h_rs or key not in h_rs or not h_rs[key]
                         ):
                             commands.append(
                                 self._add_rs_base_attrib(
                                     afi, want["name"], key, w_rs
                                 )
                             )
                     else:
                         commands.append(
                             self._add_rs_base_attrib(
                                 afi, want["name"], key, w_rs
                             )
                         )
                 elif not opr and key in l_set:
                     if (
                         key == "enable_default_log"
                         and val
                         and h_rs
                         and (key not in h_rs or not h_rs[key])
                     ):
                         commands.append(
                             self._add_rs_base_attrib(
                                 afi, want["name"], key, w_rs, opr
                             )
                         )
                     elif not (h_rs and self._in_target(h_rs, key)):
                         commands.append(
                             self._add_rs_base_attrib(
                                 afi, want["name"], key, w_rs, opr
                             )
                         )
             commands.extend(
                 self._add_rules(afi, want["name"], w_rules, h_rules, opr)
             )
         if h_rules:
             have["rules"] = h_rules
         if w_rules:
             want["rules"] = w_rules
         return commands
 
     def _add_rules(self, afi, name, w_rules, h_rules, opr=True):
         """
         This function forms the set/delete commands based on the 'opr' type
         for rules attributes.
         :param want: desired config.
         :param have: target config.
         :return: generated commands list.
         """
         commands = []
         l_set = (
             "ipsec",
             "action",
             "number",
             "protocol",
             "fragment",
             "disabled",
             "description",
         )
         if w_rules:
             for w in w_rules:
                 cmd = self._compute_command(afi, name, w["number"], opr=opr)
                 h = self.search_r_sets_in_have(
                     h_rules, w["number"], type="rules"
                 )
                 for key, val in iteritems(w):
                     if val:
                         if (
                             opr
                             and key in l_set
                             and not (h and self._is_w_same(w, h, key))
                         ):
                             if key == "disabled":
                                 if not (
                                     not val
                                     and (not h or key not in h or not h[key])
                                 ):
                                     commands.append(
                                         self._add_r_base_attrib(
                                             afi, name, key, w
                                         )
                                     )
                             else:
                                 commands.append(
                                     self._add_r_base_attrib(afi, name, key, w)
                                 )
                         elif not opr:
                             if key == "number" and self._is_del(l_set, h):
                                 commands.append(
                                     self._add_r_base_attrib(
                                         afi, name, key, w, opr=opr
                                     )
                                 )
                                 continue
                             elif (
                                 key == "disabled"
                                 and val
                                 and h
                                 and (key not in h or not h[key])
                             ):
                                 commands.append(
                                     self._add_r_base_attrib(
                                         afi, name, key, w, opr=opr
                                     )
                                 )
                             elif (
                                 key in l_set
                                 and not (h and self._in_target(h, key))
                                 and not self._is_del(l_set, h)
                             ):
                                 commands.append(
                                     self._add_r_base_attrib(
                                         afi, name, key, w, opr=opr
                                     )
                                 )
                         elif key == "p2p":
                             commands.extend(self._add_p2p(key, w, h, cmd, opr))
                         elif key == "tcp":
                             commands.extend(self._add_tcp(key, w, h, cmd, opr))
                         elif key == "time":
                             commands.extend(
                                 self._add_time(key, w, h, cmd, opr)
                             )
                         elif key == "icmp":
                             commands.extend(
                                 self._add_icmp(key, w, h, cmd, opr)
                             )
                         elif key == "state":
                             commands.extend(
                                 self._add_state(key, w, h, cmd, opr)
                             )
                         elif key == "limit":
                             commands.extend(
                                 self._add_limit(key, w, h, cmd, opr)
                             )
                         elif key == "recent":
                             commands.extend(
                                 self._add_recent(key, w, h, cmd, opr)
                             )
                         elif key == "destination" or key == "source":
                             commands.extend(
                                 self._add_src_or_dest(key, w, h, cmd, opr)
                             )
         return commands
 
     def _add_p2p(self, attr, w, h, cmd, opr):
         """
         This function forms the set/delete commands based on the 'opr' type
         for p2p applications attributes.
         :param want: desired config.
         :param have: target config.
         :return: generated commands list.
         """
         commands = []
         have = []
         if w:
             want = w.get(attr) or []
         if h:
             have = h.get(attr) or []
         if want:
             if opr:
                 applications = list_diff_want_only(want, have)
                 for app in applications:
                     commands.append(
                         cmd + (" " + attr + " " + app["application"])
                     )
             elif not opr and have:
                 applications = list_diff_want_only(want, have)
                 for app in applications:
                     commands.append(
                         cmd + (" " + attr + " " + app["application"])
                     )
         return commands
 
     def _add_state(self, attr, w, h, cmd, opr):
         """
         This function forms the command for 'state' attributes based on the 'opr'.
         :param attr: attribute name.
         :param w: base config.
         :param h: target config.
         :param cmd: commands to be prepend.
         :return: generated list of commands.
         """
         h_state = {}
         commands = []
         l_set = ("new", "invalid", "related", "established")
         if w[attr]:
             if h and attr in h.keys():
                 h_state = h.get(attr) or {}
             for item, val in iteritems(w[attr]):
                 if (
                     opr
                     and item in l_set
                     and not (
                         h_state and self._is_w_same(w[attr], h_state, item)
                     )
                 ):
                     commands.append(
                         cmd
                         + (
                             " "
                             + attr
                             + " "
                             + item
                             + " "
                             + self._bool_to_str(val)
                         )
                     )
                 elif (
                     not opr
                     and item in l_set
                     and not (h_state and self._in_target(h_state, item))
                 ):
                     commands.append(cmd + (" " + attr + " " + item))
         return commands
 
     def _add_recent(self, attr, w, h, cmd, opr):
         """
         This function forms the command for 'recent' attributes based on the 'opr'.
         :param attr: attribute name.
         :param w: base config.
         :param h: target config.
         :param cmd: commands to be prepend.
         :return: generated list of commands.
         """
         commands = []
         h_recent = {}
         l_set = ("count", "time")
         if w[attr]:
             if h and attr in h.keys():
                 h_recent = h.get(attr) or {}
             for item, val in iteritems(w[attr]):
                 if (
                     opr
                     and item in l_set
                     and not (
                         h_recent and self._is_w_same(w[attr], h_recent, item)
                     )
                 ):
                     commands.append(
                         cmd + (" " + attr + " " + item + " " + str(val))
                     )
                 elif (
                     not opr
                     and item in l_set
                     and not (h_recent and self._in_target(h_recent, item))
                 ):
                     commands.append(cmd + (" " + attr + " " + item))
         return commands
 
     def _add_icmp(self, attr, w, h, cmd, opr):
         """
         This function forms the commands for 'icmp' attributes based on the 'opr'.
         :param attr: attribute name.
         :param w: base config.
         :param h: target config.
         :param cmd: commands to be prepend.
         :return: generated list of commands.
         """
         commands = []
         h_icmp = {}
         l_set = ("code", "type", "type_name")
         if w[attr]:
             if h and attr in h.keys():
                 h_icmp = h.get(attr) or {}
             for item, val in iteritems(w[attr]):
                 if (
                     opr
                     and item in l_set
                     and not (h_icmp and self._is_w_same(w[attr], h_icmp, item))
                 ):
                     if item == "type_name":
                         if "ipv6-name" in cmd:
                             commands.append(
                                 cmd
                                 + (" " + "icmpv6" + " " + "type" + " " + val)
                             )
                         else:
                             commands.append(
                                 cmd
                                 + (
                                     " "
                                     + attr
                                     + " "
                                     + item.replace("_", "-")
                                     + " "
                                     + val
                                 )
                             )
                     else:
                         commands.append(
                             cmd + (" " + attr + " " + item + " " + str(val))
                         )
                 elif (
                     not opr
                     and item in l_set
                     and not (h_icmp and self._in_target(h_icmp, item))
                 ):
                     commands.append(cmd + (" " + attr + " " + item))
         return commands
 
     def _add_time(self, attr, w, h, cmd, opr):
         """
         This function forms the commands for 'time' attributes based on the 'opr'.
         :param attr: attribute name.
         :param w: base config.
         :param h: target config.
         :param cmd: commands to be prepend.
         :return: generated list of commands.
         """
         commands = []
         h_time = {}
         l_set = (
             "utc",
             "stopdate",
             "stoptime",
             "weekdays",
             "monthdays",
             "startdate",
             "starttime",
         )
         if w[attr]:
             if h and attr in h.keys():
                 h_time = h.get(attr) or {}
             for item, val in iteritems(w[attr]):
                 if (
                     opr
                     and item in l_set
                     and not (h_time and self._is_w_same(w[attr], h_time, item))
                 ):
                     if item == "utc":
                         if not (
                             not val and (not h_time or item not in h_time)
                         ):
                             commands.append(cmd + (" " + attr + " " + item))
                     else:
                         commands.append(
                             cmd + (" " + attr + " " + item + " " + val)
                         )
                 elif (
                     not opr
                     and item in l_set
                     and not (h_time and self._is_w_same(w[attr], h_time, item))
                 ):
                     commands.append(cmd + (" " + attr + " " + item))
         return commands
 
     def _add_tcp(self, attr, w, h, cmd, opr):
         """
         This function forms the commands for 'tcp' attributes based on the 'opr'.
         :param attr: attribute name.
         :param w: base config.
         :param h: target config.
         :param cmd: commands to be prepend.
         :return: generated list of commands.
         """
         h_tcp = {}
         commands = []
         if w[attr]:
             key = "flags"
             flags = w[attr].get(key) or {}
             if flags:
                 if h and key in h[attr].keys():
                     h_tcp = h[attr].get(key) or {}
                 if flags:
                     if opr and not (
                         h_tcp and self._is_w_same(w[attr], h[attr], key)
                     ):
                         commands.append(
                             cmd + (" " + attr + " " + key + " " + flags)
                         )
                     if not opr and not (
                         h_tcp and self._is_w_same(w[attr], h[attr], key)
                     ):
                         commands.append(
                             cmd + (" " + attr + " " + key + " " + flags)
                         )
         return commands
 
     def _add_limit(self, attr, w, h, cmd, opr):
         """
         This function forms the commands for 'limit' attributes based on the 'opr'.
         :param attr: attribute name.
         :param w: base config.
         :param h: target config.
         :param cmd: commands to be prepend.
         :return: generated list of commands.
         """
         h_limit = {}
         commands = []
         if w[attr]:
             key = "burst"
             if (
                 opr
                 and key in w[attr].keys()
                 and not (
                     h
                     and attr in h.keys()
                     and self._is_w_same(w[attr], h[attr], key)
                 )
             ):
                 commands.append(
                     cmd
                     + (" " + attr + " " + key + " " + str(w[attr].get(key)))
                 )
             elif (
                 not opr
                 and key in w[attr].keys()
                 and not (
                     h and attr in h.keys() and self._in_target(h[attr], key)
                 )
             ):
                 commands.append(
                     cmd
                     + (" " + attr + " " + key + " " + str(w[attr].get(key)))
                 )
             key = "rate"
             rate = w[attr].get(key) or {}
             if rate:
                 if h and key in h[attr].keys():
                     h_limit = h[attr].get(key) or {}
                 if "unit" in rate and "number" in rate:
                     if opr and not (
                         h_limit
                         and self._is_w_same(rate, h_limit, "unit")
                         and self.is_w_same(rate, h_limit, "number")
                     ):
                         commands.append(
                             cmd
                             + (
                                 " "
                                 + attr
                                 + " "
                                 + key
                                 + " "
                                 + str(rate["number"])
                                 + "/"
                                 + rate["unit"]
                             )
                         )
                     if not opr and not (
                         h_limit
                         and self._is_w_same(rate, h_limit, "unit")
                         and self._is_w_same(rate, h_limit, "number")
                     ):
                         commands.append(cmd + (" " + attr + " " + key))
         return commands
 
     def _add_src_or_dest(self, attr, w, h, cmd, opr=True):
         """
         This function forms the commands for 'src/dest' attributes based on the 'opr'.
         :param attr: attribute name.
         :param w: base config.
         :param h: target config.
         :param cmd: commands to be prepend.
         :return: generated list of commands.
         """
         commands = []
         h_group = {}
         g_set = ("port_group", "address_group", "network_group")
         if w[attr]:
             keys = ("address", "mac_address", "port")
             for key in keys:
                 if (
                     opr
                     and key in w[attr].keys()
                     and not (
                         h
                         and attr in h.keys()
                         and self._is_w_same(w[attr], h[attr], key)
                     )
                 ):
                     commands.append(
                         cmd
                         + (
                             " "
                             + attr
                             + " "
                             + key.replace("_", "-")
                             + " "
                             + w[attr].get(key)
                         )
                     )
                 elif (
                     not opr
                     and key in w[attr].keys()
                     and not (
                         h
                         and attr in h.keys()
                         and self._in_target(h[attr], key)
                     )
                 ):
                     commands.append(cmd + (" " + attr + " " + key))
 
             key = "group"
             group = w[attr].get(key) or {}
             if group:
                 if h and key in h[attr].keys():
                     h_group = h[attr].get(key) or {}
                 for item, val in iteritems(group):
                     if val:
                         if (
                             opr
                             and item in g_set
                             and not (
                                 h_group
                                 and self._is_w_same(group, h_group, item)
                             )
                         ):
                             commands.append(
                                 cmd
                                 + (
                                     " "
                                     + attr
                                     + " "
                                     + key
                                     + " "
                                     + item.replace("_", "-")
                                     + " "
                                     + val
                                 )
                             )
                         elif (
                             not opr
                             and item in g_set
                             and not (
                                 h_group and self._in_target(h_group, item)
                             )
                         ):
                             commands.append(
                                 cmd
                                 + (
                                     " "
                                     + attr
                                     + " "
                                     + key
                                     + " "
                                     + item.replace("_", "-")
                                 )
                             )
         return commands
 
     def search_r_sets_in_have(self, have, w_name, type="rule_sets"):
         """
         This function  returns the rule-set/rule if it is present in target config.
         :param have: target config.
         :param w_name: rule-set name.
         :param type: rule_sets/rule/r_list.
         :return: rule-set/rule.
         """
         if have:
             key = "name"
             if type == "rules":
                 key = "number"
                 for r in have:
                     if r[key] == w_name:
                         return r
             elif type == "r_list":
                 for h in have:
                     r_sets = self._get_r_sets(h)
                     for rs in r_sets:
                         if rs[key] == w_name:
                             return rs
             else:
                 for rs in have:
                     if rs[key] == w_name:
                         return rs
         return None
 
     def _get_r_sets(self, item, type="rule_sets"):
         """
         This function returns the list of rule-sets/rules.
         :param item: config dictionary.
         :param type: rule_sets/rule/r_list.
         :return: list of rule-sets/rules.
         """
         rs_list = []
         r_sets = item[type]
         if r_sets:
             for rs in r_sets:
                 rs_list.append(rs)
         return rs_list
 
     def _compute_command(
         self,
         afi,
         name=None,
         number=None,
         attrib=None,
         value=None,
         remove=False,
         opr=True,
     ):
         """
         This function construct the add/delete command based on passed attributes.
         :param afi:  address type.
         :param name:  rule-set name.
         :param number: rule-number.
         :param attrib: attribute name.
         :param value: value.
         :param remove: True if delete command needed to be construct.
         :param opr: opeeration flag.
         :return: generated command.
         """
         if remove or not opr:
             cmd = "delete firewall " + self._get_fw_type(afi)
         else:
             cmd = "set firewall " + self._get_fw_type(afi)
         if name:
             cmd += " " + name
         if number:
             cmd += " rule " + str(number)
         if attrib:
             cmd += " " + attrib.replace("_", "-")
         if (
             value
             and opr
             and attrib != "enable_default_log"
             and attrib != "disabled"
         ):
             cmd += " '" + str(value) + "'"
         return cmd
 
     def _add_r_base_attrib(self, afi, name, attr, rule, opr=True):
         """
         This function forms the command for 'rules' attributes which doesn't
         have further sub attributes.
         :param afi: address type.
         :param name: rule-set name
         :param attrib: attribute name
         :param rule: rule config dictionary.
         :param opr: True/False.
         :return: generated command.
         """
         if attr == "number":
             command = self._compute_command(
                 afi=afi, name=name, number=rule["number"], opr=opr
             )
         else:
             command = self._compute_command(
                 afi=afi,
                 name=name,
                 number=rule["number"],
                 attrib=attr,
                 value=rule[attr],
                 opr=opr,
             )
         return command
 
     def _add_rs_base_attrib(self, afi, name, attrib, rule, opr=True):
         """
 
         This function forms the command for 'rule-sets' attributes which doesn't
         have further sub attributes.
         :param afi: address type.
         :param name: rule-set name
         :param attrib: attribute name
         :param rule: rule config dictionary.
         :param opr: True/False.
         :return: generated command.
         """
         command = self._compute_command(
             afi=afi, name=name, attrib=attrib, value=rule[attrib], opr=opr
         )
         return command
 
     def _bool_to_str(self, val):
         """
         This function converts the bool value into string.
         :param val: bool value.
         :return: enable/disable.
         """
         return "enable" if val else "disable"
 
     def _get_fw_type(self, afi):
         """
         This function returns the firewall rule-set type based on IP address.
         :param afi: address type
         :return: rule-set type.
         """
         return "ipv6-name" if afi == "ipv6" else "name"
 
     def _is_del(self, l_set, h, key="number"):
         """
         This function checks whether rule needs to be deleted based on
         the rule number.
         :param l_set: attribute set.
         :param h: target config.
         :param key: number.
         :return: True/False.
         """
         return key in l_set and not (h and self._in_target(h, key))
 
     def _is_w_same(self, w, h, key):
         """
         This function checks whether the key value is same in base and
         target config dictionary.
         :param w: base config.
         :param h: target config.
         :param key:attribute name.
         :return: True/False.
         """
         return True if h and key in h and h[key] == w[key] else False
 
     def _in_target(self, h, key):
         """
         This function checks whether the target nexist and key present in target config.
         :param h: target config.
         :param key: attribute name.
         :return: True/False.
         """
         return True if h and key in h else False
 
     def _is_base_attrib(self, key):
         """
         This function checks whether key is present in predefined
         based attribute set.
         :param key:
         :return: True/False.
         """
         r_set = (
             "p2p",
             "ipsec",
             "action",
             "fragment",
             "protocol",
             "disabled",
             "description",
             "mac_address",
             "default_action",
             "enable_default_log",
         )
         return True if key in r_set else False
diff --git a/plugins/modules/vyos_firewall_rules.py b/plugins/modules/vyos_firewall_rules.py
index a9e676b..9c2e832 100644
--- a/plugins/modules/vyos_firewall_rules.py
+++ b/plugins/modules/vyos_firewall_rules.py
@@ -1,1565 +1,1517 @@
 #!/usr/bin/python
 # -*- coding: utf-8 -*-
 # Copyright 2019 Red Hat
 # GNU General Public License v3.0+
 # (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
 
 #############################################
 #                WARNING                    #
 #############################################
 #
 # This file is auto generated by the resource
 #   module builder playbook.
 #
 # Do not edit this file manually.
 #
 # Changes to this file will be over written
 #   by the resource module builder.
 #
 # Changes should be made in the model used to
 #   generate this file or in the resource module
 #   builder template.
 #
 #############################################
 
 """
 The module file for vyos_firewall_rules
 """
 
 from __future__ import absolute_import, division, print_function
 
 __metaclass__ = type
 
 ANSIBLE_METADATA = {
     "metadata_version": "1.1",
     "status": ["preview"],
     "supported_by": "network",
 }
 
 DOCUMENTATION = """module: vyos_firewall_rules
-short_description: Manage firewall rule-set attributes on VyOS devices
+short_description: Firewall rules resource module
 description: This module manages firewall rule-set attributes on VyOS devices
+version_added: "1.0.0"
 notes:
 - Tested against VyOS 1.1.8 (helium).
 - This module works with connection C(network_cli). See L(the VyOS OS Platform Options,../network/user_guide/platform_vyos.html).
 author:
 - Rohit Thakur (@rohitthakur2590)
 options:
   config:
     description: A dictionary of Firewall rule-set options.
     type: list
     elements: dict
     suboptions:
       afi:
         description:
         - Specifies the type of rule-set.
         type: str
         choices:
         - ipv4
         - ipv6
         required: true
       rule_sets:
         description:
         - The Firewall rule-set list.
         type: list
         elements: dict
         suboptions:
           name:
             description:
             - Firewall rule set name.
             type: str
           default_action:
             description:
             - Default action for rule-set.
             - drop (Drop if no prior rules are hit (default))
             - reject (Drop and notify source if no prior rules are hit)
             - accept (Accept if no prior rules are hit)
             type: str
             choices:
             - drop
             - reject
             - accept
           description:
             description:
             - Rule set description.
             type: str
           enable_default_log:
             description:
             - Option to log packets hitting default-action.
             type: bool
           rules:
             description:
             - A ditionary that specifies the rule-set configurations.
             type: list
             elements: dict
             suboptions:
               number:
                 description:
                 - Rule number.
                 type: int
                 required: true
               description:
                 description:
                 - Description of this rule.
                 type: str
               action:
                 description:
                 - Specifying the action.
                 type: str
                 choices:
                 - drop
                 - reject
                 - accept
                 - inspect
               destination:
                 description:
                 - Specifying the destination parameters.
                 type: dict
                 suboptions:
                   address:
                     description:
                     - Destination ip address subnet or range.
                     - IPv4/6 address, subnet or range to match.
                     - Match everything except the specified address, subnet or range.
                     - Destination ip address subnet or range.
                     type: str
                   group:
                     description:
                     - Destination group.
                     type: dict
                     suboptions:
                       address_group:
                         description:
                         - Group of addresses.
                         type: str
                       network_group:
                         description:
                         - Group of networks.
                         type: str
                       port_group:
                         description:
                         - Group of ports.
                         type: str
                   port:
                     description:
                     - Multiple destination ports can be specified as a comma-separated
                       list.
                     - The whole list can also be "negated" using '!'.
                     - For example:'!22,telnet,http,123,1001-1005'.
                     type: str
               disabled:
                 description:
                 - Option to disable firewall rule.
                 type: bool
               fragment:
                 description:
                 - IP fragment match.
                 type: str
                 choices:
                 - match-frag
                 - match-non-frag
               icmp:
                 description:
                 - ICMP type and code information.
                 type: dict
                 suboptions:
                   type_name:
                     description:
                     - ICMP type-name.
                     type: str
                     choices:
                     - any
                     - echo-reply
                     - destination-unreachable
                     - network-unreachable
                     - host-unreachable
                     - protocol-unreachable
                     - port-unreachable
                     - fragmentation-needed
                     - source-route-failed
                     - network-unknown
                     - host-unknown
                     - network-prohibited
                     - host-prohibited
                     - TOS-network-unreachable
                     - TOS-host-unreachable
                     - communication-prohibited
                     - host-precedence-violation
                     - precedence-cutoff
                     - source-quench
                     - redirect
                     - network-redirect
                     - host-redirect
                     - TOS-network-redirect
                     - TOS-host-redirect
                     - echo-request
                     - router-advertisement
                     - router-solicitation
                     - time-exceeded
                     - ttl-zero-during-transit
                     - ttl-zero-during-reassembly
                     - parameter-problem
                     - ip-header-bad
                     - required-option-missing
                     - timestamp-request
                     - timestamp-reply
                     - address-mask-request
                     - address-mask-reply
                     - ping
                     - pong
                     - ttl-exceeded
                   code:
                     description:
                     - ICMP code.
                     type: int
                   type:
                     description:
                     - ICMP type.
                     type: int
               ipsec:
                 description:
                 - Inboud ip sec packets.
                 type: str
                 choices:
                 - match-ipsec
                 - match-none
               limit:
                 description:
                 - Rate limit using a token bucket filter.
                 type: dict
                 suboptions:
                   burst:
                     description:
                     - Maximum number of packets to allow in excess of rate.
                     type: int
                   rate:
                     description:
                     - format for rate (integer/time unit).
                     - any one of second, minute, hour or day may be used to specify
                       time unit.
                     - eg. 1/second implies rule to be matched at an average of once
                       per second.
                     type: dict
                     suboptions:
                       number:
                         description:
                         - This is the integer value.
                         type: int
                       unit:
                         description:
                         - This is the time unit.
                         type: str
               p2p:
                 description:
                 - P2P application packets.
                 type: list
                 elements: dict
                 suboptions:
                   application:
                     description:
                     - Name of the application.
                     type: str
                     choices:
                     - all
                     - applejuice
                     - bittorrent
                     - directconnect
                     - edonkey
                     - gnutella
                     - kazaa
               protocol:
                 description:
                 - Protocol to match (protocol name in /etc/protocols or protocol number
                   or all).
                 - <text> IP protocol name from /etc/protocols (e.g. "tcp" or "udp").
                 - <0-255> IP protocol number.
                 - tcp_udp Both TCP and UDP.
                 - all All IP protocols.
                 - (!)All IP protocols except for the specified name or number.
                 type: str
               recent:
                 description:
                 - Parameters for matching recently seen sources.
                 type: dict
                 suboptions:
                   count:
                     description:
                     - Source addresses seen more than N times.
                     type: int
                   time:
                     description:
                     - Source addresses seen in the last N seconds.
                     type: int
               source:
                 description:
                 - Source parameters.
                 type: dict
                 suboptions:
                   address:
                     description:
                     - Source ip address subnet or range.
                     - IPv4/6 address, subnet or range to match.
                     - Match everything except the specified address, subnet or range.
                     - Source ip address subnet or range.
                     type: str
                   group:
                     description:
                     - Source group.
                     type: dict
                     suboptions:
                       address_group:
                         description:
                         - Group of addresses.
                         type: str
                       network_group:
                         description:
                         - Group of networks.
                         type: str
                       port_group:
                         description:
                         - Group of ports.
                         type: str
                   port:
                     description:
                     - Multiple source ports can be specified as a comma-separated
                       list.
                     - The whole list can also be "negated" using '!'.
                     - For example:'!22,telnet,http,123,1001-1005'.
                     type: str
                   mac_address:
                     description:
                     - <MAC address> MAC address to match.
                     - <!MAC address> Match everything except the specified MAC address.
                     type: str
               state:
                 description:
                 - Session state.
                 type: dict
                 suboptions:
                   established:
                     description:
                     - Established state.
                     type: bool
                   invalid:
                     description:
                     - Invalid state.
                     type: bool
                   new:
                     description:
                     - New state.
                     type: bool
                   related:
                     description:
                     - Related state.
                     type: bool
               tcp:
                 description:
                 - TCP flags to match.
                 type: dict
                 suboptions:
                   flags:
                     description:
                     - TCP flags to be matched.
                     type: str
               time:
                 description:
                 - Time to match rule.
                 type: dict
                 suboptions:
                   utc:
                     description:
                     - Interpret times for startdate, stopdate, starttime and stoptime
                       to be UTC.
                     type: bool
                   monthdays:
                     description:
                     - Monthdays to match rule on.
                     type: str
                   startdate:
                     description:
                     - Date to start matching rule.
                     type: str
                   starttime:
                     description:
                     - Time of day to start matching rule.
                     type: str
                   stopdate:
                     description:
                     - Date to stop matching rule.
                     type: str
                   stoptime:
                     description:
                     - Time of day to stop matching rule.
                     type: str
                   weekdays:
                     description:
                     - Weekdays to match rule on.
                     type: str
   running_config:
     description:
-    - The module, by default, will connect to the remote device and retrieve the current
-      running-config to use as a base for comparing against the contents of source.
-      There are times when it is not desirable to have the task get the current running-config
-      for every task in a playbook.  The I(running_config) argument allows the implementer
-      to pass in the configuration to use as the base config for comparison. This
-      value of this option should be the output received from device by executing
-      command C(show configuration commands | grep 'firewall'
+      - This option is used only with state I(parsed).
+      - The value of this option should be the output received from the VyOS device by executing
+        the command B(show configuration commands | grep firewall).
+      - The state I(parsed) reads the configuration from C(running_config) option and transforms
+        it into Ansible structured data as per the resource module's argspec and the value is then
+        returned in the I(parsed) key within the result.
     type: str
   state:
     description:
     - The state the configuration should be left in
     type: str
     choices:
     - merged
     - replaced
     - overridden
     - deleted
     - gathered
     - rendered
     - parsed
     default: merged
 """
 EXAMPLES = """
 # Using deleted to delete firewall rules based on rule-set name
 #
 # Before state
 # -------------
 #
 # vyos@vyos:~$ show configuration commands| grep firewall
 # set firewall group address-group 'inbound'
 # set firewall name Downlink default-action 'accept'
 # set firewall name Downlink description 'IPv4 INBOUND rule set'
 # set firewall name Downlink rule 501 action 'accept'
 # set firewall name Downlink rule 501 description 'Rule 501 is configured by Ansible'
 # set firewall name Downlink rule 501 ipsec 'match-ipsec'
 # set firewall name Downlink rule 502 action 'reject'
 # set firewall name Downlink rule 502 description 'Rule 502 is configured by Ansible'
 # set firewall name Downlink rule 502 ipsec 'match-ipsec'
 #
 - name: Delete attributes of given firewall rules.
-  vyos_firewall_rules:
+  vyos.vyos.vyos_firewall_rules:
     config:
       - afi: ipv4
         rule_sets:
           - name: 'Downlink'
     state: deleted
 #
 #
 # ------------------------
 # Module Execution Results
 # ------------------------
 #
 #    "before": [
 #        {
 #            "afi": "ipv4",
 #            "rule_sets": [
 #                {
 #                    "default_action": "accept",
 #                    "description": "IPv4 INBOUND rule set",
 #                    "name": "Downlink",
 #                    "rules": [
 #                        {
 #                            "action": "accept",
 #                            "description": "Rule 501 is configured by Ansible",
 #                            "ipsec": "match-ipsec",
 #                            "number": 501
 #                        },
 #                        {
 #                            "action": "reject",
 #                            "description": "Rule 502 is configured by Ansible",
 #                            "ipsec": "match-ipsec",
 #                            "number": 502
 #                        }
 #                    ]
 #               }
 #            ]
 #        }
 #    ]
 #    "commands": [
 #        "delete firewall name Downlink"
 #    ]
 #
 # "after": []
 # After state
 # ------------
 # vyos@vyos# run show configuration commands | grep firewall
 # set firewall group address-group 'inbound'
 
 
-# Using deleted to delete all the the firewall rules when provided config is empty
+# Using deleted to delete firewall rules based on afi
 #
 # Before state
 # -------------
 #
 # vyos@vyos:~$ show configuration commands| grep firewall
+# set firewall ipv6-name UPLINK default-action 'accept'
+# set firewall ipv6-name UPLINK description 'This is ipv6 specific rule-set'
+# set firewall ipv6-name UPLINK rule 1 action 'accept'
+# set firewall ipv6-name UPLINK rule 1
+# set firewall ipv6-name UPLINK rule 1 description 'Fwipv6-Rule 1 is configured by Ansible'
+# set firewall ipv6-name UPLINK rule 1 ipsec 'match-ipsec'
+# set firewall ipv6-name UPLINK rule 2 action 'accept'
+# set firewall ipv6-name UPLINK rule 2
+# set firewall ipv6-name UPLINK rule 2 description 'Fwipv6-Rule 2 is configured by Ansible'
+# set firewall ipv6-name UPLINK rule 2 ipsec 'match-ipsec'
 # set firewall group address-group 'inbound'
 # set firewall name Downlink default-action 'accept'
 # set firewall name Downlink description 'IPv4 INBOUND rule set'
 # set firewall name Downlink rule 501 action 'accept'
 # set firewall name Downlink rule 501 description 'Rule 501 is configured by Ansible'
 # set firewall name Downlink rule 501 ipsec 'match-ipsec'
 # set firewall name Downlink rule 502 action 'reject'
 # set firewall name Downlink rule 502 description 'Rule 502 is configured by Ansible'
 # set firewall name Downlink rule 502 ipsec 'match-ipsec'
+
 #
 - name: Delete attributes of given firewall rules.
-  vyos_firewall_rules:
+  vyos.vyos.vyos_firewall_rules:
     config:
+      - afi: ipv4
     state: deleted
 #
 #
 # ------------------------
 # Module Execution Results
 # ------------------------
 #
 #    "before": [
 #        {
-#            "afi": "ipv4",
+#            "afi": "ipv6",
 #            "rule_sets": [
 #                {
 #                    "default_action": "accept",
-#                    "description": "IPv4 INBOUND rule set",
-#                    "name": "Downlink",
+#                    "description": "This is ipv6 specific rule-set",
+#                    "name": "UPLINK",
 #                    "rules": [
 #                        {
 #                            "action": "accept",
-#                            "description": "Rule 501 is configured by Ansible",
+#                            "description": "Fwipv6-Rule 1 is configured by Ansible",
 #                            "ipsec": "match-ipsec",
-#                            "number": 501
+#                            "number": 1
 #                        },
 #                        {
-#                            "action": "reject",
-#                            "description": "Rule 502 is configured by Ansible",
+#                            "action": "accept",
+#                            "description": "Fwipv6-Rule 2 is configured by Ansible",
 #                            "ipsec": "match-ipsec",
-#                            "number": 502
+#                            "number": 2
 #                        }
 #                    ]
-#               }
+#                }
 #            ]
-#        }
-#    ]
-#    "commands": [
-#        "delete firewall name"
-#    ]
-#
-# "after": []
-# After state
-# ------------
-# vyos@vyos# run show configuration commands | grep firewall
-# set firewall group address-group 'inbound'
-
-
-# Using deleted to delete the the firewall rules based on afi
-#
-# Before state
-# -------------
-#
-# vyos@vyos:~$ show configuration commands| grep firewall
-# set firewall group address-group 'inbound'
-# set firewall name Downlink default-action 'accept'
-# set firewall name Downlink description 'IPv4 INBOUND rule set'
-# set firewall name Downlink rule 501 action 'accept'
-# set firewall name Downlink rule 501 description 'Rule 501 is configured by Ansible'
-# set firewall name Downlink rule 501 ipsec 'match-ipsec'
-# set firewall name Downlink rule 502 action 'reject'
-# set firewall name Downlink rule 502 description 'Rule 502 is configured by Ansible'
-# set firewall name Downlink rule 502 ipsec 'match-ipsec'
-#
-- name: Delete attributes of given firewall rules.
-  vyos_firewall_rules:
-    config:
-      - afi: ipv4
-    state: deleted
-#
-#
-# ------------------------
-# Module Execution Results
-# ------------------------
-#
-#    "before": [
+#        },
 #        {
 #            "afi": "ipv4",
 #            "rule_sets": [
 #                {
 #                    "default_action": "accept",
 #                    "description": "IPv4 INBOUND rule set",
 #                    "name": "Downlink",
 #                    "rules": [
 #                        {
 #                            "action": "accept",
 #                            "description": "Rule 501 is configured by Ansible",
 #                            "ipsec": "match-ipsec",
 #                            "number": 501
 #                        },
 #                        {
 #                            "action": "reject",
 #                            "description": "Rule 502 is configured by Ansible",
 #                            "ipsec": "match-ipsec",
 #                            "number": 502
 #                        }
 #                    ]
 #               }
 #            ]
 #        }
 #    ]
 #    "commands": [
-#        "delete firewall name",
+#        "delete firewall name"
 #    ]
 #
 # "after": []
 # After state
 # ------------
-# vyos@vyos# run show configuration commands | grep firewall
-# set firewall group address-group 'inbound'
-
+# vyos@vyos:~$ show configuration commands| grep firewall
+# set firewall ipv6-name UPLINK default-action 'accept'
+# set firewall ipv6-name UPLINK description 'This is ipv6 specific rule-set'
+# set firewall ipv6-name UPLINK rule 1 action 'accept'
+# set firewall ipv6-name UPLINK rule 1
+# set firewall ipv6-name UPLINK rule 1 description 'Fwipv6-Rule 1 is configured by Ansible'
+# set firewall ipv6-name UPLINK rule 1 ipsec 'match-ipsec'
+# set firewall ipv6-name UPLINK rule 2 action 'accept'
+# set firewall ipv6-name UPLINK rule 2
+# set firewall ipv6-name UPLINK rule 2 description 'Fwipv6-Rule 2 is configured by Ansible'
+# set firewall ipv6-name UPLINK rule 2 ipsec 'match-ipsec'
 
 
-# Using deleted to delete the the firewall rules based on rule number/id
+# Using deleted to delete all the the firewall rules when provided config is empty
 #
 # Before state
 # -------------
 #
 # vyos@vyos:~$ show configuration commands| grep firewall
 # set firewall group address-group 'inbound'
 # set firewall name Downlink default-action 'accept'
 # set firewall name Downlink description 'IPv4 INBOUND rule set'
 # set firewall name Downlink rule 501 action 'accept'
 # set firewall name Downlink rule 501 description 'Rule 501 is configured by Ansible'
 # set firewall name Downlink rule 501 ipsec 'match-ipsec'
 # set firewall name Downlink rule 502 action 'reject'
 # set firewall name Downlink rule 502 description 'Rule 502 is configured by Ansible'
 # set firewall name Downlink rule 502 ipsec 'match-ipsec'
 #
 - name: Delete attributes of given firewall rules.
-  vyos_firewall_rules:
+  vyos.vyos.vyos_firewall_rules:
     config:
-      - afi: ipv4
-        rule_sets:
-          - name: 'Downlink'
-            rules:
-              - number: 501
     state: deleted
 #
 #
 # ------------------------
 # Module Execution Results
 # ------------------------
 #
 #    "before": [
 #        {
 #            "afi": "ipv4",
 #            "rule_sets": [
 #                {
 #                    "default_action": "accept",
 #                    "description": "IPv4 INBOUND rule set",
 #                    "name": "Downlink",
 #                    "rules": [
 #                        {
 #                            "action": "accept",
 #                            "description": "Rule 501 is configured by Ansible",
 #                            "ipsec": "match-ipsec",
 #                            "number": 501
 #                        },
 #                        {
 #                            "action": "reject",
 #                            "description": "Rule 502 is configured by Ansible",
 #                            "ipsec": "match-ipsec",
 #                            "number": 502
 #                        }
 #                    ]
 #               }
 #            ]
 #        }
 #    ]
 #    "commands": [
-#        "delete firewall ipv6-name Downlink rule 501"
+#        "delete firewall name"
 #    ]
 #
-#    "after": [
-#        {
-#            "afi": "ipv4",
-#            "rule_sets": [
-#                {
-#                    "default_action": "accept",
-#                    "description": "IPv4 INBOUND rule set",
-#                    "name": "Downlink",
-#                    "rules": [
-#                        {
-#                            "action": "reject",
-#                            "description": "Rule 502 is configured by Ansible",
-#                            "ipsec": "match-ipsec",
-#                            "number": 502
-#                        }
-#                    ]
-#               }
-#            ]
-#        }
-#    ]
+# "after": []
 # After state
 # ------------
-# vyos@vyos:~$ show configuration commands| grep firewall
+# vyos@vyos# run show configuration commands | grep firewall
 # set firewall group address-group 'inbound'
-# set firewall name Downlink default-action 'accept'
-# set firewall name Downlink description 'IPv4 INBOUND rule set'
-# set firewall name Downlink rule 502 action 'reject'
-# set firewall name Downlink rule 502 description 'Rule 502 is configured by Ansible'
-# set firewall name Downlink rule 502 ipsec 'match-ipsec'
 
 
 # Using merged
 #
 # Before state:
 # -------------
 #
 # vyos@vyos# run show  configuration commands | grep firewall
 # set firewall group address-group 'inbound'
 #
 - name: Merge the provided configuration with the exisiting running configuration
-  vyos_firewall_rules:
+  vyos.vyos.vyos_firewall_rules:
     config:
       - afi: 'ipv6'
         rule_sets:
           - name: 'UPLINK'
             description: 'This is ipv6 specific rule-set'
             default_action: 'accept'
             rules:
               - number: 1
                 action: 'accept'
                 description: 'Fwipv6-Rule 1 is configured by Ansible'
                 ipsec: 'match-ipsec'
               - number: 2
                 action: 'accept'
                 description: 'Fwipv6-Rule 2 is configured by Ansible'
                 ipsec: 'match-ipsec'
 
       - afi: 'ipv4'
         rule_sets:
           - name: 'INBOUND'
             description: 'IPv4 INBOUND rule set'
             default_action: 'accept'
             rules:
               - number: 101
                 action: 'accept'
                 description: 'Rule 101 is configured by Ansible'
                 ipsec: 'match-ipsec'
               - number: 102
                 action: 'reject'
                 description: 'Rule 102 is configured by Ansible'
                 ipsec: 'match-ipsec'
               - number: 103
                 action: 'accept'
                 description: 'Rule 103 is configured by Ansible'
                 destination:
                   group:
                     address_group: 'inbound'
                 source:
                   address: '192.0.2.0'
                 state:
                   established: true
                   new: false
                   invalid: false
                   related: true
     state: merged
 #
 #
 # -------------------------
 # Module Execution Result
 # -------------------------
 #
 # before": []
 #
 #    "commands": [
 #       "set firewall ipv6-name UPLINK default-action 'accept'",
 #       "set firewall ipv6-name UPLINK description 'This is ipv6 specific rule-set'",
 #       "set firewall ipv6-name UPLINK rule 1 action 'accept'",
 #       "set firewall ipv6-name UPLINK rule 1",
 #       "set firewall ipv6-name UPLINK rule 1 description 'Fwipv6-Rule 1 is configured by Ansible'",
 #       "set firewall ipv6-name UPLINK rule 1 ipsec 'match-ipsec'",
 #       "set firewall ipv6-name UPLINK rule 2 action 'accept'",
 #       "set firewall ipv6-name UPLINK rule 2",
 #       "set firewall ipv6-name UPLINK rule 2 description 'Fwipv6-Rule 2 is configured by Ansible'",
 #       "set firewall ipv6-name UPLINK rule 2 ipsec 'match-ipsec'",
 #       "set firewall name INBOUND default-action 'accept'",
 #       "set firewall name INBOUND description 'IPv4 INBOUND rule set'",
 #       "set firewall name INBOUND rule 101 action 'accept'",
 #       "set firewall name INBOUND rule 101",
 #       "set firewall name INBOUND rule 101 description 'Rule 101 is configured by Ansible'",
 #       "set firewall name INBOUND rule 101 ipsec 'match-ipsec'",
 #       "set firewall name INBOUND rule 102 action 'reject'",
 #       "set firewall name INBOUND rule 102",
 #       "set firewall name INBOUND rule 102 description 'Rule 102 is configured by Ansible'",
 #       "set firewall name INBOUND rule 102 ipsec 'match-ipsec'",
 #       "set firewall name INBOUND rule 103 description 'Rule 103 is configured by Ansible'",
 #       "set firewall name INBOUND rule 103 destination group address-group inbound",
 #       "set firewall name INBOUND rule 103",
 #       "set firewall name INBOUND rule 103 source address 192.0.2.0",
 #       "set firewall name INBOUND rule 103 state established enable",
 #       "set firewall name INBOUND rule 103 state related enable",
 #       "set firewall name INBOUND rule 103 state invalid disable",
 #       "set firewall name INBOUND rule 103 state new disable",
 #       "set firewall name INBOUND rule 103 action 'accept'"
 #    ]
 #
 # "after": [
 #        {
 #            "afi": "ipv6",
 #            "rule_sets": [
 #                {
 #                    "default_action": "accept",
 #                    "description": "This is ipv6 specific rule-set",
 #                    "name": "UPLINK",
 #                    "rules": [
 #                        {
 #                            "action": "accept",
 #                            "description": "Fwipv6-Rule 1 is configured by Ansible",
 #                            "ipsec": "match-ipsec",
 #                            "number": 1
 #                        },
 #                        {
 #                            "action": "accept",
 #                            "description": "Fwipv6-Rule 2 is configured by Ansible",
 #                            "ipsec": "match-ipsec",
 #                            "number": 2
 #                        }
 #                    ]
 #                }
 #            ]
 #        },
 #        {
 #            "afi": "ipv4",
 #            "rule_sets": [
 #                {
 #                    "default_action": "accept",
 #                    "description": "IPv4 INBOUND rule set",
 #                    "name": "INBOUND",
 #                    "rules": [
 #                        {
 #                            "action": "accept",
 #                            "description": "Rule 101 is configured by Ansible",
 #                            "ipsec": "match-ipsec",
 #                            "number": 101
 #                        },
 #                        {
 #                            "action": "reject",
 #                            "description": "Rule 102 is configured by Ansible",
 #                            "ipsec": "match-ipsec",
 #                            "number": 102
 #                        },
 #                        {
 #                            "action": "accept",
 #                            "description": "Rule 103 is configured by Ansible",
 #                            "destination": {
 #                                "group": {
 #                                    "address_group": "inbound"
 #                                }
 #                            },
 #                            "number": 103,
 #                            "source": {
 #                                "address": "192.0.2.0"
 #                            },
 #                            "state": {
 #                                "established": true,
 #                                "invalid": false,
 #                                "new": false,
 #                                "related": true
 #                            }
 #                        }
 #                    ]
 #                }
 #            ]
 #        }
 #    ]
 #
 # After state:
 # -------------
 #
 # vyos@vyos:~$ show configuration commands| grep firewall
 # set firewall group address-group 'inbound'
 # set firewall ipv6-name UPLINK default-action 'accept'
 # set firewall ipv6-name UPLINK description 'This is ipv6 specific rule-set'
 # set firewall ipv6-name UPLINK rule 1 action 'accept'
 # set firewall ipv6-name UPLINK rule 1 description 'Fwipv6-Rule 1 is configured by Ansible'
 # set firewall ipv6-name UPLINK rule 1 ipsec 'match-ipsec'
 # set firewall ipv6-name UPLINK rule 2 action 'accept'
 # set firewall ipv6-name UPLINK rule 2 description 'Fwipv6-Rule 2 is configured by Ansible'
 # set firewall ipv6-name UPLINK rule 2 ipsec 'match-ipsec'
 # set firewall name INBOUND default-action 'accept'
 # set firewall name INBOUND description 'IPv4 INBOUND rule set'
 # set firewall name INBOUND rule 101 action 'accept'
 # set firewall name INBOUND rule 101 description 'Rule 101 is configured by Ansible'
 # set firewall name INBOUND rule 101 ipsec 'match-ipsec'
 # set firewall name INBOUND rule 102 action 'reject'
 # set firewall name INBOUND rule 102 description 'Rule 102 is configured by Ansible'
 # set firewall name INBOUND rule 102 ipsec 'match-ipsec'
 # set firewall name INBOUND rule 103 action 'accept'
 # set firewall name INBOUND rule 103 description 'Rule 103 is configured by Ansible'
 # set firewall name INBOUND rule 103 destination group address-group 'inbound'
 # set firewall name INBOUND rule 103 source address '192.0.2.0'
 # set firewall name INBOUND rule 103 state established 'enable'
 # set firewall name INBOUND rule 103 state invalid 'disable'
 # set firewall name INBOUND rule 103 state new 'disable'
 # set firewall name INBOUND rule 103 state related 'enable'
 
 
 # Using replaced
 #
 # Before state:
 # -------------
 #
 # vyos@vyos:~$ show configuration commands| grep firewall
 # set firewall group address-group 'inbound'
 # set firewall ipv6-name UPLINK default-action 'accept'
 # set firewall ipv6-name UPLINK description 'This is ipv6 specific rule-set'
 # set firewall ipv6-name UPLINK rule 1 action 'accept'
 # set firewall ipv6-name UPLINK rule 1 description 'Fwipv6-Rule 1 is configured by Ansible'
 # set firewall ipv6-name UPLINK rule 1 ipsec 'match-ipsec'
 # set firewall ipv6-name UPLINK rule 2 action 'accept'
 # set firewall ipv6-name UPLINK rule 2 description 'Fwipv6-Rule 2 is configured by Ansible'
 # set firewall ipv6-name UPLINK rule 2 ipsec 'match-ipsec'
 # set firewall name INBOUND default-action 'accept'
 # set firewall name INBOUND description 'IPv4 INBOUND rule set'
 # set firewall name INBOUND rule 101 action 'accept'
 # set firewall name INBOUND rule 101 description 'Rule 101 is configured by Ansible'
 # set firewall name INBOUND rule 101 ipsec 'match-ipsec'
 # set firewall name INBOUND rule 102 action 'reject'
 # set firewall name INBOUND rule 102 description 'Rule 102 is configured by Ansible'
 # set firewall name INBOUND rule 102 ipsec 'match-ipsec'
 # set firewall name INBOUND rule 103 action 'accept'
 # set firewall name INBOUND rule 103 description 'Rule 103 is configured by Ansible'
 # set firewall name INBOUND rule 103 destination group address-group 'inbound'
 # set firewall name INBOUND rule 103 source address '192.0.2.0'
 # set firewall name INBOUND rule 103 state established 'enable'
 # set firewall name INBOUND rule 103 state invalid 'disable'
 # set firewall name INBOUND rule 103 state new 'disable'
 # set firewall name INBOUND rule 103 state related 'enable'
 #
 - name: Replace device configurations of listed firewall rules with provided configurations
-  vyos_firewall_rules:
+  vyos.vyos.vyos_firewall_rules:
     config:
       - afi: 'ipv6'
         rule_sets:
           - name: 'UPLINK'
             description: 'This is ipv6 specific rule-set'
             default_action: 'accept'
       - afi: 'ipv4'
         rule_sets:
           - name: 'INBOUND'
             description: 'IPv4 INBOUND rule set'
             default_action: 'accept'
             rules:
               - number: 101
                 action: 'accept'
                 description: 'Rule 101 is configured by Ansible'
                 ipsec: 'match-ipsec'
               - number: 104
                 action: 'reject'
                 description: 'Rule 104 is configured by Ansible'
                 ipsec: 'match-none'
     state: replaced
 #
 #
 # -------------------------
 # Module Execution Result
 # -------------------------
 #
 #    "before": [
 #        {
 #            "afi": "ipv6",
 #            "rule_sets": [
 #                {
 #                    "default_action": "accept",
 #                    "description": "This is ipv6 specific rule-set",
 #                    "name": "UPLINK",
 #                    "rules": [
 #                        {
 #                            "action": "accept",
 #                            "description": "Fwipv6-Rule 1 is configured by Ansible",
 #                            "ipsec": "match-ipsec",
 #                            "number": 1
 #                        },
 #                        {
 #                            "action": "accept",
 #                            "description": "Fwipv6-Rule 2 is configured by Ansible",
 #                            "ipsec": "match-ipsec",
 #                            "number": 2
 #                        }
 #                    ]
 #                }
 #            ]
 #        },
 #        {
 #            "afi": "ipv4",
 #            "rule_sets": [
 #                {
 #                    "default_action": "accept",
 #                    "description": "IPv4 INBOUND rule set",
 #                    "name": "INBOUND",
 #                    "rules": [
 #                        {
 #                            "action": "accept",
 #                            "description": "Rule 101 is configured by Ansible",
 #                            "ipsec": "match-ipsec",
 #                            "number": 101
 #                        },
 #                        {
 #                            "action": "reject",
 #                            "description": "Rule 102 is configured by Ansible",
 #                            "ipsec": "match-ipsec",
 #                            "number": 102
 #                        },
 #                        {
 #                            "action": "accept",
 #                            "description": "Rule 103 is configured by Ansible",
 #                            "destination": {
 #                                "group": {
 #                                    "address_group": "inbound"
 #                                }
 #                            },
 #                            "number": 103,
 #                            "source": {
 #                                "address": "192.0.2.0"
 #                            },
 #                            "state": {
 #                                "established": true,
 #                                "invalid": false,
 #                                "new": false,
 #                                "related": true
 #                            }
 #                        }
 #                    ]
 #                }
 #            ]
 #        }
 #    ]
 #
 # "commands": [
 #        "delete firewall ipv6-name UPLINK rule 1",
 #        "delete firewall ipv6-name UPLINK rule 2",
 #        "delete firewall name INBOUND rule 102",
 #        "delete firewall name INBOUND rule 103",
 #        "set firewall name INBOUND rule 104 action 'reject'",
 #        "set firewall name INBOUND rule 104 description 'Rule 104 is configured by Ansible'",
 #        "set firewall name INBOUND rule 104",
 #        "set firewall name INBOUND rule 104 ipsec 'match-none'"
 #    ]
 #
 #    "after": [
 #        {
 #            "afi": "ipv6",
 #            "rule_sets": [
 #                {
 #                    "default_action": "accept",
 #                    "description": "This is ipv6 specific rule-set",
 #                    "name": "UPLINK"
 #                }
 #            ]
 #        },
 #        {
 #            "afi": "ipv4",
 #            "rule_sets": [
 #                {
 #                    "default_action": "accept",
 #                    "description": "IPv4 INBOUND rule set",
 #                    "name": "INBOUND",
 #                    "rules": [
 #                        {
 #                            "action": "accept",
 #                            "description": "Rule 101 is configured by Ansible",
 #                            "ipsec": "match-ipsec",
 #                            "number": 101
 #                        },
 #                        {
 #                            "action": "reject",
 #                            "description": "Rule 104 is configured by Ansible",
 #                            "ipsec": "match-none",
 #                            "number": 104
 #                        }
 #                    ]
 #                }
 #            ]
 #        }
 #    ]
 #
 # After state:
 # -------------
 #
 # vyos@vyos:~$ show configuration commands| grep firewall
 # set firewall group address-group 'inbound'
 # set firewall ipv6-name UPLINK default-action 'accept'
 # set firewall ipv6-name UPLINK description 'This is ipv6 specific rule-set'
 # set firewall name INBOUND default-action 'accept'
 # set firewall name INBOUND description 'IPv4 INBOUND rule set'
 # set firewall name INBOUND rule 101 action 'accept'
 # set firewall name INBOUND rule 101 description 'Rule 101 is configured by Ansible'
 # set firewall name INBOUND rule 101 ipsec 'match-ipsec'
 # set firewall name INBOUND rule 104 action 'reject'
 # set firewall name INBOUND rule 104 description 'Rule 104 is configured by Ansible'
 # set firewall name INBOUND rule 104 ipsec 'match-none'
 
 
 # Using overridden
 #
 # Before state
 # --------------
 #
 # vyos@vyos:~$ show configuration commands| grep firewall
 # set firewall group address-group 'inbound'
 # set firewall ipv6-name UPLINK default-action 'accept'
 # set firewall ipv6-name UPLINK description 'This is ipv6 specific rule-set'
 # set firewall name INBOUND default-action 'accept'
 # set firewall name INBOUND description 'IPv4 INBOUND rule set'
 # set firewall name INBOUND rule 101 action 'accept'
 # set firewall name INBOUND rule 101 description 'Rule 101 is configured by Ansible'
 # set firewall name INBOUND rule 101 ipsec 'match-ipsec'
 # set firewall name INBOUND rule 104 action 'reject'
 # set firewall name INBOUND rule 104 description 'Rule 104 is configured by Ansible'
 # set firewall name INBOUND rule 104 ipsec 'match-none'
 #
 - name: Overrides all device configuration with provided configuration
-  vyos_firewall_rules:
+  vyos.vyos.vyos_firewall_rules:
     config:
       - afi: 'ipv4'
         rule_sets:
           - name: 'Downlink'
             description: 'IPv4 INBOUND rule set'
             default_action: 'accept'
             rules:
               - number: 501
                 action: 'accept'
                 description: 'Rule 501 is configured by Ansible'
                 ipsec: 'match-ipsec'
               - number: 502
                 action: 'reject'
                 description: 'Rule 502 is configured by Ansible'
                 ipsec: 'match-ipsec'
     state: overridden
 #
 #
 # -------------------------
 # Module Execution Result
 # -------------------------
 #
 # "before": [
 #        {
 #            "afi": "ipv6",
 #            "rule_sets": [
 #                {
 #                    "default_action": "accept",
 #                    "description": "This is ipv6 specific rule-set",
 #                    "name": "UPLINK"
 #                }
 #            ]
 #        },
 #        {
 #            "afi": "ipv4",
 #            "rule_sets": [
 #                {
 #                    "default_action": "accept",
 #                    "description": "IPv4 INBOUND rule set",
 #                    "name": "INBOUND",
 #                    "rules": [
 #                        {
 #                            "action": "accept",
 #                            "description": "Rule 101 is configured by Ansible",
 #                            "ipsec": "match-ipsec",
 #                            "number": 101
 #                        },
 #                        {
 #                            "action": "reject",
 #                            "description": "Rule 104 is configured by Ansible",
 #                            "ipsec": "match-none",
 #                            "number": 104
 #                        }
 #                    ]
 #                }
 #            ]
 #        }
 #    ]
 #
 #    "commands": [
 #        "delete firewall ipv6-name UPLINK",
 #        "delete firewall name INBOUND",
 #        "set firewall name Downlink default-action 'accept'",
 #        "set firewall name Downlink description 'IPv4 INBOUND rule set'",
 #        "set firewall name Downlink rule 501 action 'accept'",
 #        "set firewall name Downlink rule 501",
 #        "set firewall name Downlink rule 501 description 'Rule 501 is configured by Ansible'",
 #        "set firewall name Downlink rule 501 ipsec 'match-ipsec'",
 #        "set firewall name Downlink rule 502 action 'reject'",
 #        "set firewall name Downlink rule 502",
 #        "set firewall name Downlink rule 502 description 'Rule 502 is configured by Ansible'",
 #        "set firewall name Downlink rule 502 ipsec 'match-ipsec'"
 #
 #
 #    "after": [
 #        {
 #            "afi": "ipv4",
 #            "rule_sets": [
 #                {
 #                    "default_action": "accept",
 #                    "description": "IPv4 INBOUND rule set",
 #                    "name": "Downlink",
 #                    "rules": [
 #                        {
 #                            "action": "accept",
 #                            "description": "Rule 501 is configured by Ansible",
 #                            "ipsec": "match-ipsec",
 #                            "number": 501
 #                        },
 #                        {
 #                            "action": "reject",
 #                            "description": "Rule 502 is configured by Ansible",
 #                            "ipsec": "match-ipsec",
 #                            "number": 502
 #                        }
 #                    ]
 #               }
 #            ]
 #        }
 #    ]
 #
 #
 # After state
 # ------------
 #
 # vyos@vyos:~$ show configuration commands| grep firewall
 # set firewall group address-group 'inbound'
 # set firewall name Downlink default-action 'accept'
 # set firewall name Downlink description 'IPv4 INBOUND rule set'
 # set firewall name Downlink rule 501 action 'accept'
 # set firewall name Downlink rule 501 description 'Rule 501 is configured by Ansible'
 # set firewall name Downlink rule 501 ipsec 'match-ipsec'
 # set firewall name Downlink rule 502 action 'reject'
 # set firewall name Downlink rule 502 description 'Rule 502 is configured by Ansible'
 # set firewall name Downlink rule 502 ipsec 'match-ipsec'
 
 
 # Using gathered
 #
 # Before state:
 # -------------
 #
 # vyos@vyos:~$ show configuration commands| grep firewall
 # set firewall group address-group 'inbound'
 # set firewall ipv6-name UPLINK default-action 'accept'
 # set firewall ipv6-name UPLINK description 'This is ipv6 specific rule-set'
 # set firewall ipv6-name UPLINK rule 1 action 'accept'
 # set firewall ipv6-name UPLINK rule 1 description 'Fwipv6-Rule 1 is configured by Ansible'
 # set firewall ipv6-name UPLINK rule 1 ipsec 'match-ipsec'
 # set firewall ipv6-name UPLINK rule 2 action 'accept'
 # set firewall ipv6-name UPLINK rule 2 description 'Fwipv6-Rule 2 is configured by Ansible'
 # set firewall ipv6-name UPLINK rule 2 ipsec 'match-ipsec'
 # set firewall name INBOUND default-action 'accept'
 # set firewall name INBOUND description 'IPv4 INBOUND rule set'
 # set firewall name INBOUND rule 101 action 'accept'
 # set firewall name INBOUND rule 101 description 'Rule 101 is configured by Ansible'
 # set firewall name INBOUND rule 101 ipsec 'match-ipsec'
 # set firewall name INBOUND rule 102 action 'reject'
 # set firewall name INBOUND rule 102 description 'Rule 102 is configured by Ansible'
 # set firewall name INBOUND rule 102 ipsec 'match-ipsec'
 # set firewall name INBOUND rule 103 action 'accept'
 # set firewall name INBOUND rule 103 description 'Rule 103 is configured by Ansible'
 # set firewall name INBOUND rule 103 destination group address-group 'inbound'
 # set firewall name INBOUND rule 103 source address '192.0.2.0'
 # set firewall name INBOUND rule 103 state established 'enable'
 # set firewall name INBOUND rule 103 state invalid 'disable'
 # set firewall name INBOUND rule 103 state new 'disable'
 # set firewall name INBOUND rule 103 state related 'enable'
 #
 - name: Gather listed firewall rules with provided configurations
-  vyos_firewall_rules:
+  vyos.vyos.vyos_firewall_rules:
     config:
     state: gathered
 #
 #
 # -------------------------
 # Module Execution Result
 # -------------------------
 #
 #    "gathered": [
 #        {
 #            "afi": "ipv6",
 #            "rule_sets": [
 #                {
 #                    "default_action": "accept",
 #                    "description": "This is ipv6 specific rule-set",
 #                    "name": "UPLINK",
 #                    "rules": [
 #                        {
 #                            "action": "accept",
 #                            "description": "Fwipv6-Rule 1 is configured by Ansible",
 #                            "ipsec": "match-ipsec",
 #                            "number": 1
 #                        },
 #                        {
 #                            "action": "accept",
 #                            "description": "Fwipv6-Rule 2 is configured by Ansible",
 #                            "ipsec": "match-ipsec",
 #                            "number": 2
 #                        }
 #                    ]
 #                }
 #            ]
 #        },
 #        {
 #            "afi": "ipv4",
 #            "rule_sets": [
 #                {
 #                    "default_action": "accept",
 #                    "description": "IPv4 INBOUND rule set",
 #                    "name": "INBOUND",
 #                    "rules": [
 #                        {
 #                            "action": "accept",
 #                            "description": "Rule 101 is configured by Ansible",
 #                            "ipsec": "match-ipsec",
 #                            "number": 101
 #                        },
 #                        {
 #                            "action": "reject",
 #                            "description": "Rule 102 is configured by Ansible",
 #                            "ipsec": "match-ipsec",
 #                            "number": 102
 #                        },
 #                        {
 #                            "action": "accept",
 #                            "description": "Rule 103 is configured by Ansible",
 #                            "destination": {
 #                                "group": {
 #                                    "address_group": "inbound"
 #                                }
 #                            },
 #                            "number": 103,
 #                            "source": {
 #                                "address": "192.0.2.0"
 #                            },
 #                            "state": {
 #                                "established": true,
 #                                "invalid": false,
 #                                "new": false,
 #                                "related": true
 #                            }
 #                        }
 #                    ]
 #                }
 #            ]
 #        }
 #    ]
 #
 #
 # After state:
 # -------------
 #
 # vyos@vyos:~$ show configuration commands| grep firewall
 # set firewall group address-group 'inbound'
 # set firewall ipv6-name UPLINK default-action 'accept'
 # set firewall ipv6-name UPLINK description 'This is ipv6 specific rule-set'
 # set firewall ipv6-name UPLINK rule 1 action 'accept'
 # set firewall ipv6-name UPLINK rule 1 description 'Fwipv6-Rule 1 is configured by Ansible'
 # set firewall ipv6-name UPLINK rule 1 ipsec 'match-ipsec'
 # set firewall ipv6-name UPLINK rule 2 action 'accept'
 # set firewall ipv6-name UPLINK rule 2 description 'Fwipv6-Rule 2 is configured by Ansible'
 # set firewall ipv6-name UPLINK rule 2 ipsec 'match-ipsec'
 # set firewall name INBOUND default-action 'accept'
 # set firewall name INBOUND description 'IPv4 INBOUND rule set'
 # set firewall name INBOUND rule 101 action 'accept'
 # set firewall name INBOUND rule 101 description 'Rule 101 is configured by Ansible'
 # set firewall name INBOUND rule 101 ipsec 'match-ipsec'
 # set firewall name INBOUND rule 102 action 'reject'
 # set firewall name INBOUND rule 102 description 'Rule 102 is configured by Ansible'
 # set firewall name INBOUND rule 102 ipsec 'match-ipsec'
 # set firewall name INBOUND rule 103 action 'accept'
 # set firewall name INBOUND rule 103 description 'Rule 103 is configured by Ansible'
 # set firewall name INBOUND rule 103 destination group address-group 'inbound'
 # set firewall name INBOUND rule 103 source address '192.0.2.0'
 # set firewall name INBOUND rule 103 state established 'enable'
 # set firewall name INBOUND rule 103 state invalid 'disable'
 # set firewall name INBOUND rule 103 state new 'disable'
 # set firewall name INBOUND rule 103 state related 'enable'
 
 
 # Using rendered
 #
 #
 - name: Render the commands for provided  configuration
-  vyos_firewall_rules:
+  vyos.vyos.vyos_firewall_rules:
     config:
       - afi: 'ipv6'
         rule_sets:
           - name: 'UPLINK'
             description: 'This is ipv6 specific rule-set'
             default_action: 'accept'
       - afi: 'ipv4'
         rule_sets:
           - name: 'INBOUND'
             description: 'IPv4 INBOUND rule set'
             default_action: 'accept'
             rules:
               - number: 101
                 action: 'accept'
                 description: 'Rule 101 is configured by Ansible'
                 ipsec: 'match-ipsec'
               - number: 102
                 action: 'reject'
                 description: 'Rule 102 is configured by Ansible'
                 ipsec: 'match-ipsec'
               - number: 103
                 action: 'accept'
                 description: 'Rule 103 is configured by Ansible'
                 destination:
                   group:
                     address_group: 'inbound'
                 source:
                   address: '192.0.2.0'
                 state:
                   established: true
                   new: false
                   invalid: false
                   related: true
     state: rendered
 #
 #
 # -------------------------
 # Module Execution Result
 # -------------------------
 #
 #
 # "rendered": [
 #        "set firewall ipv6-name UPLINK default-action 'accept'",
 #        "set firewall ipv6-name UPLINK description 'This is ipv6 specific rule-set'",
 #        "set firewall name INBOUND default-action 'accept'",
 #        "set firewall name INBOUND description 'IPv4 INBOUND rule set'",
 #        "set firewall name INBOUND rule 101 action 'accept'",
 #        "set firewall name INBOUND rule 101",
 #        "set firewall name INBOUND rule 101 description 'Rule 101 is configured by Ansible'",
 #        "set firewall name INBOUND rule 101 ipsec 'match-ipsec'",
 #        "set firewall name INBOUND rule 102 action 'reject'",
 #        "set firewall name INBOUND rule 102",
 #        "set firewall name INBOUND rule 102 description 'Rule 102 is configured by Ansible'",
 #        "set firewall name INBOUND rule 102 ipsec 'match-ipsec'",
 #        "set firewall name INBOUND rule 103 description 'Rule 103 is configured by Ansible'",
 #        "set firewall name INBOUND rule 103 destination group address-group inbound",
 #        "set firewall name INBOUND rule 103",
 #        "set firewall name INBOUND rule 103 source address 192.0.2.0",
 #        "set firewall name INBOUND rule 103 state established enable",
 #        "set firewall name INBOUND rule 103 state related enable",
 #        "set firewall name INBOUND rule 103 state invalid disable",
 #        "set firewall name INBOUND rule 103 state new disable",
 #        "set firewall name INBOUND rule 103 action 'accept'"
 #    ]
 
 
 # Using parsed
 #
 #
-- name: Render the commands for provided  configuration
-  vyos_firewall_rules:
+- name: Parsed the provided input commands.
+  vyos.vyos.vyos_firewall_rules:
     running_config:
       "set firewall group address-group 'inbound'
  set firewall name Downlink default-action 'accept'
  set firewall name Downlink description 'IPv4 INBOUND rule set'
  set firewall name Downlink rule 501 action 'accept'
  set firewall name Downlink rule 501 description 'Rule 501 is configured by Ansible'
  set firewall name Downlink rule 501 ipsec 'match-ipsec'
  set firewall name Downlink rule 502 action 'reject'
  set firewall name Downlink rule 502 description 'Rule 502 is configured by Ansible'
  set firewall name Downlink rule 502 ipsec 'match-ipsec'"
     state: parsed
 #
 #
 # -------------------------
 # Module Execution Result
 # -------------------------
 #
 #
 # "parsed": [
 #        {
 #            "afi": "ipv4",
 #            "rule_sets": [
 #                {
 #                    "default_action": "accept",
 #                    "description": "IPv4 INBOUND rule set",
 #                    "name": "Downlink",
 #                    "rules": [
 #                        {
 #                            "action": "accept",
 #                            "description": "Rule 501 is configured by Ansible",
 #                            "ipsec": "match-ipsec",
 #                            "number": 501
 #                        },
 #                        {
 #                            "action": "reject",
 #                            "description": "Rule 502 is configured by Ansible",
 #                            "ipsec": "match-ipsec",
 #                            "number": 502
 #                        }
 #                    ]
 #                }
 #            ]
 #        }
 #    ]
 
 
 """
 RETURN = """
 before:
   description: The configuration prior to the model invocation.
   returned: always
   type: list
   sample: >
     The configuration returned will always be in the same format
      of the parameters above.
 after:
   description: The resulting configuration model invocation.
   returned: when changed
   type: list
   sample: >
     The configuration returned will always be in the same format
      of the parameters above.
 commands:
   description: The set of commands pushed to the remote device.
   returned: always
   type: list
   sample:
     - "set firewall name Downlink default-action 'accept'"
     - "set firewall name Downlink description 'IPv4 INBOUND rule set'"
     - "set firewall name Downlink rule 501 action 'accept'"
     - "set firewall name Downlink rule 502 description 'Rule 502 is configured by Ansible'"
     - "set firewall name Downlink rule 502 ipsec 'match-ipsec'"
 """
 
 
 from ansible.module_utils.basic import AnsibleModule
 from ansible_collections.vyos.vyos.plugins.module_utils.network.vyos.argspec.firewall_rules.firewall_rules import (
     Firewall_rulesArgs,
 )
 from ansible_collections.vyos.vyos.plugins.module_utils.network.vyos.config.firewall_rules.firewall_rules import (
     Firewall_rules,
 )
 
 
 def main():
     """
     Main entry point for module execution
     :returns: the result form module invocation
     """
     required_if = [
         ("state", "merged", ("config",)),
         ("state", "replaced", ("config",)),
+        ("state", "rendered", ("config",)),
         ("state", "overridden", ("config",)),
         ("state", "parsed", ("running_config",)),
     ]
     mutually_exclusive = [("config", "running_config")]
 
     module = AnsibleModule(
         argument_spec=Firewall_rulesArgs.argument_spec,
         required_if=required_if,
         supports_check_mode=True,
         mutually_exclusive=mutually_exclusive,
     )
     result = Firewall_rules(module).execute_module()
     module.exit_json(**result)
 
 
 if __name__ == "__main__":
     main()
diff --git a/tests/integration/targets/vyos_firewall_rules/tests/cli/deleted.yaml b/tests/integration/targets/vyos_firewall_rules/tests/cli/deleted.yaml
index 7acfe65..67bfd3c 100644
--- a/tests/integration/targets/vyos_firewall_rules/tests/cli/deleted.yaml
+++ b/tests/integration/targets/vyos_firewall_rules/tests/cli/deleted.yaml
@@ -1,60 +1,56 @@
 ---
 - debug:
     msg: Start vyos_firewall_rules deleted integration tests ansible_connection={{
       ansible_connection }}
 
 - include_tasks: _populate.yaml
 
 - block:
 
     - name: Delete firewall rule set.
       register: result
       vyos.vyos.vyos_firewall_rules: &id001
         config:
-
           - afi: ipv6
             rule_sets:
-
               - name: UPLINK
-
           - afi: ipv4
             rule_sets:
-
               - name: INBOUND
         state: deleted
 
     - name: Assert that the before dicts were correctly generated
       assert:
         that:
           - "{{ populate | symmetric_difference(result['before']) |length == 0 }}"
 
     - name: Assert that the correct set of commands were generated
       assert:
         that:
           - "{{ deleted_rs['commands'] | symmetric_difference(result['commands'])\
             \ |length == 0 }}"
 
     - name: Assert that the after dicts were correctly generated
       assert:
         that:
           - "{{ deleted_rs['after'] | symmetric_difference(result['after']) |length\
             \ == 0 }}"
 
     - name: Delete attributes of given interfaces (IDEMPOTENT)
       register: result
       vyos.vyos.vyos_firewall_rules: *id001
 
     - name: Assert that the previous task was idempotent
       assert:
         that:
           - result.changed == false
           - result.commands|length == 0
 
     - name: Assert that the before dicts were correctly generated
       assert:
         that:
           - "{{ deleted_rs['after'] | symmetric_difference(result['before']) |length\
             \ == 0 }}"
   always:
 
     - include_tasks: _remove_config.yaml
diff --git a/tests/integration/targets/vyos_firewall_rules/tests/cli/deleted_rule.yaml b/tests/integration/targets/vyos_firewall_rules/tests/cli/deleted_rule.yaml
deleted file mode 100644
index d77e2a9..0000000
--- a/tests/integration/targets/vyos_firewall_rules/tests/cli/deleted_rule.yaml
+++ /dev/null
@@ -1,58 +0,0 @@
----
-- debug:
-    msg: Start vyos_firewall_rules deleted integration tests ansible_connection={{
-      ansible_connection }}
-
-- include_tasks: _populate.yaml
-
-- block:
-
-    - name: Delete firewall rule.
-      register: result
-      vyos.vyos.vyos_firewall_rules: &id001
-        config:
-
-          - afi: ipv6
-            rule_sets:
-
-              - name: UPLINK
-                rules:
-
-                  - number: 1
-        state: deleted
-
-    - name: Assert that the before dicts were correctly generated
-      assert:
-        that:
-          - "{{ populate | symmetric_difference(result['before']) |length == 0 }}"
-
-    - name: Assert that the correct set of commands were generated
-      assert:
-        that:
-          - "{{ deleted_r['commands'] | symmetric_difference(result['commands'])\
-            \ |length == 0 }}"
-
-    - name: Assert that the after dicts were correctly generated
-      assert:
-        that:
-          - "{{ deleted_r['after'] | symmetric_difference(result['after']) |length\
-            \ == 0 }}"
-
-    - name: Delete attributes of given interfaces (IDEMPOTENT)
-      register: result
-      vyos.vyos.vyos_firewall_rules: *id001
-
-    - name: Assert that the previous task was idempotent
-      assert:
-        that:
-          - result.changed == false
-          - result.commands|length == 0
-
-    - name: Assert that the before dicts were correctly generated
-      assert:
-        that:
-          - "{{ deleted_r['after'] | symmetric_difference(result['before']) |length\
-            \ == 0 }}"
-  always:
-
-    - include_tasks: _remove_config.yaml
diff --git a/tests/integration/targets/vyos_firewall_rules/tests/cli/gathered.yaml b/tests/integration/targets/vyos_firewall_rules/tests/cli/gathered.yaml
index cdc8e51..59c81aa 100644
--- a/tests/integration/targets/vyos_firewall_rules/tests/cli/gathered.yaml
+++ b/tests/integration/targets/vyos_firewall_rules/tests/cli/gathered.yaml
@@ -1,34 +1,26 @@
 ---
 - debug:
     msg: START vyos_firewall_rules gathered integration tests on connection={{ ansible_connection
       }}
 
 - include_tasks: _remove_config.yaml
 
 - include_tasks: _populate.yaml
 
 - block:
 
-    - name: Merge the provided configuration with the exisiting running configuration
+    - name: Gather the provided configuration with the exisiting running configuration
       register: result
-      vyos.vyos.vyos_firewall_rules: &id001
+      vyos.vyos.vyos_firewall_rules:
         config:
         state: gathered
 
     - name: Assert that gathered dicts was correctly generated
       assert:
         that:
           - "{{ populate | symmetric_difference(result['gathered']) |length == 0\
             \ }}"
 
-    - name: Gather the existing running configuration (IDEMPOTENT)
-      register: result
-      vyos.vyos.vyos_firewall_rules: *id001
-
-    - name: Assert that the previous task was idempotent
-      assert:
-        that:
-          - result['changed'] == false
   always:
 
     - include_tasks: _remove_config.yaml
diff --git a/tests/integration/targets/vyos_firewall_rules/tests/cli/parsed.yaml b/tests/integration/targets/vyos_firewall_rules/tests/cli/parsed.yaml
index a793ac5..bc95524 100644
--- a/tests/integration/targets/vyos_firewall_rules/tests/cli/parsed.yaml
+++ b/tests/integration/targets/vyos_firewall_rules/tests/cli/parsed.yaml
@@ -1,41 +1,16 @@
 ---
 - debug:
     msg: START vyos_firewall_rules parsed integration tests on connection={{ ansible_connection
       }}
 
-- include_tasks: _remove_config.yaml
-
-- include_tasks: _populate.yaml
-
-- block:
-
-    - name: Gather firewall_rules facts
-      register: firewall_rules_facts
-      vyos.vyos.vyos_facts:
-        gather_subset:
-          - default
-        gather_network_resources:
-          - firewall_rules
-
-    - name: Provide the running configuration for parsing (config to be parsed)
-      register: result
-      vyos.vyos.vyos_firewall_rules: &id001
-        running_config: "{{ lookup('file', '_parsed_config.cfg') }}"
-        state: parsed
-
-    - name: Assert that correct parsing done
-      assert:
-        that: "{{ ansible_facts['network_resources']['firewall_rules'] | symmetric_difference(result['parsed'])\
-          \ |length == 0 }}"
-
-    - name: Gather the existing running configuration (IDEMPOTENT)
-      register: result
-      vyos.vyos.vyos_firewall_rules: *id001
-
-    - name: Assert that the previous task was idempotent
-      assert:
-        that:
-          - result['changed'] == false
-  always:
-
-    - include_tasks: _remove_config.yaml
+- name: Parse externally provided Firewall rules config to agnostic model
+  register: result
+  vyos.vyos.vyos_firewall_rules:
+    running_config: "{{ lookup('file', '_parsed_config.cfg') }}"
+    state: parsed
+
+- name: Assert that config was correctly parsed
+  assert:
+    that:
+      - "{{ parsed['after'] | symmetric_difference(result['parsed']) |length ==\
+        \ 0 }}"
diff --git a/tests/integration/targets/vyos_firewall_rules/tests/cli/rendered.yaml b/tests/integration/targets/vyos_firewall_rules/tests/cli/rendered.yaml
index f000998..6670fd7 100644
--- a/tests/integration/targets/vyos_firewall_rules/tests/cli/rendered.yaml
+++ b/tests/integration/targets/vyos_firewall_rules/tests/cli/rendered.yaml
@@ -1,73 +1,62 @@
 ---
 - debug:
     msg: START vyos_firewall_rules rendered integration tests on connection={{ ansible_connection
       }}
 
 - include_tasks: _remove_config.yaml
 
-- include_tasks: _populate.yaml
-
 - block:
 
     - name: Structure provided configuration into device specific commands
       register: result
-      vyos.vyos.vyos_firewall_rules: &id001
+      vyos.vyos.vyos_firewall_rules:
         config:
 
           - afi: ipv6
             rule_sets:
 
               - name: UPLINK
                 description: This is ipv6 specific rule-set
                 default_action: accept
 
           - afi: ipv4
             rule_sets:
 
               - name: INBOUND
                 description: IPv4 INBOUND rule set
                 default_action: accept
                 rules:
 
                   - number: 101
                     action: accept
                     description: Rule 101 is configured by Ansible
                     ipsec: match-ipsec
 
                   - number: 102
                     action: reject
                     description: Rule 102 is configured by Ansible
                     ipsec: match-ipsec
 
                   - number: 103
                     action: accept
                     description: Rule 103 is configured by Ansible
                     destination:
                       group:
                         address_group: inbound
                     source:
                       address: 192.0.2.0
                     state:
                       established: true
                       new: false
                       invalid: false
                       related: true
         state: rendered
 
     - name: Assert that correct set of commands were generated
       assert:
         that:
           - "{{ rendered['commands'] | symmetric_difference(result['rendered'])\
             \ |length == 0 }}"
 
-    - name: Structure provided configuration into device specific commands (IDEMPOTENT)
-      register: result
-      vyos.vyos.vyos_firewall_rules: *id001
-
-    - name: Assert that the previous task was idempotent
-      assert:
-        that:
-          - result['changed'] == false
-  always:
-
-    - include_tasks: _remove_config.yaml
+- debug:
+    msg: END vyos_firewall_rules rendered integration tests on connection={{ ansible_connection }}
diff --git a/tests/integration/targets/vyos_firewall_rules/vars/main.yaml b/tests/integration/targets/vyos_firewall_rules/vars/main.yaml
index c15a101..88323ba 100644
--- a/tests/integration/targets/vyos_firewall_rules/vars/main.yaml
+++ b/tests/integration/targets/vyos_firewall_rules/vars/main.yaml
@@ -1,312 +1,314 @@
 ---
 merged:
   before: []
   commands:
     - set firewall ipv6-name UPLINK default-action 'accept'
     - set firewall ipv6-name UPLINK description 'This is ipv6 specific rule-set'
     - set firewall ipv6-name UPLINK rule 1 action 'accept'
     - set firewall ipv6-name UPLINK rule 1
     - set firewall ipv6-name UPLINK rule 1 description 'Fwipv6-Rule 1 is configured
       by Ansible'
     - set firewall ipv6-name UPLINK rule 1 ipsec 'match-ipsec'
     - set firewall ipv6-name UPLINK rule 2 action 'accept'
     - set firewall ipv6-name UPLINK rule 2
     - set firewall ipv6-name UPLINK rule 2 description 'Fwipv6-Rule 2 is configured
       by Ansible'
     - set firewall ipv6-name UPLINK rule 2 ipsec 'match-ipsec'
     - set firewall name INBOUND default-action 'accept'
     - set firewall name INBOUND description 'IPv4 INBOUND rule set'
     - set firewall name INBOUND rule 101 action 'accept'
     - set firewall name INBOUND rule 101
     - set firewall name INBOUND rule 101 description 'Rule 101 is configured by Ansible'
     - set firewall name INBOUND rule 101 ipsec 'match-ipsec'
     - set firewall name INBOUND rule 102 action 'reject'
     - set firewall name INBOUND rule 102
     - set firewall name INBOUND rule 102 description 'Rule 102 is configured by Ansible'
     - set firewall name INBOUND rule 102 ipsec 'match-ipsec'
     - set firewall name INBOUND rule 103 description 'Rule 103 is configured by Ansible'
     - set firewall name INBOUND rule 103 destination group address-group inbound
     - set firewall name INBOUND rule 103
     - set firewall name INBOUND rule 103 source address 192.0.2.0
     - set firewall name INBOUND rule 103 state established enable
     - set firewall name INBOUND rule 103 state related enable
     - set firewall name INBOUND rule 103 state invalid disable
     - set firewall name INBOUND rule 103 state new disable
     - set firewall name INBOUND rule 103 action 'accept'
   after:
     - afi: ipv6
       rule_sets:
         - name: UPLINK
           description: This is ipv6 specific rule-set
           default_action: accept
           rules:
             - number: 1
               action: accept
               description: Fwipv6-Rule 1 is configured by Ansible
               ipsec: match-ipsec
             - number: 2
               action: accept
               description: Fwipv6-Rule 2 is configured by Ansible
               ipsec: match-ipsec
     - afi: ipv4
       rule_sets:
         - name: INBOUND
           description: IPv4 INBOUND rule set
           default_action: accept
           rules:
             - number: 101
               action: accept
               description: Rule 101 is configured by Ansible
               ipsec: match-ipsec
             - number: 102
               action: reject
               description: Rule 102 is configured by Ansible
               ipsec: match-ipsec
             - number: 103
               action: accept
               description: Rule 103 is configured by Ansible
               destination:
                 group:
                   address_group: inbound
               source:
                 address: 192.0.2.0
               state:
                 established: true
                 new: false
                 invalid: false
                 related: true
 populate:
   - afi: ipv6
     rule_sets:
       - name: UPLINK
         description: This is ipv6 specific rule-set
         default_action: accept
         rules:
           - number: 1
             action: accept
             description: Fwipv6-Rule 1 is configured by Ansible
             ipsec: match-ipsec
           - number: 2
             action: accept
             description: Fwipv6-Rule 2 is configured by Ansible
             ipsec: match-ipsec
   - afi: ipv4
     rule_sets:
       - name: INBOUND
         description: IPv4 INBOUND rule set
         default_action: accept
         rules:
           - number: 101
             action: accept
             description: Rule 101 is configured by Ansible
             ipsec: match-ipsec
           - number: 102
             action: reject
             description: Rule 102 is configured by Ansible
             ipsec: match-ipsec
           - number: 103
             action: accept
             description: Rule 103 is configured by Ansible
             destination:
               group:
                 address_group: inbound
             source:
               address: 192.0.2.0
             state:
               established: true
               new: false
               invalid: false
               related: true
 replaced:
   commands:
     - delete firewall ipv6-name UPLINK rule 1
     - delete firewall ipv6-name UPLINK rule 2
     - delete firewall name INBOUND rule 102
     - delete firewall name INBOUND rule 103
     - set firewall name INBOUND rule 104 action 'reject'
     - set firewall name INBOUND rule 104 description 'Rule 104 is configured by Ansible'
     - set firewall name INBOUND rule 104
     - set firewall name INBOUND rule 104 ipsec 'match-none'
   after:
     - afi: ipv6
       rule_sets:
         - name: UPLINK
           description: This is ipv6 specific rule-set
           default_action: accept
     - afi: ipv4
       rule_sets:
         - name: INBOUND
           description: IPv4 INBOUND rule set
           default_action: accept
           rules:
             - number: 101
               action: accept
               description: Rule 101 is configured by Ansible
               ipsec: match-ipsec
             - number: 104
               action: reject
               description: Rule 104 is configured by Ansible
               ipsec: match-none
 overridden:
   before:
     - afi: ipv6
       rule_sets:
         - name: UPLINK
           description: This is ipv6 specific rule-set
           default_action: accept
     - afi: ipv4
       rule_sets:
         - name: INBOUND
           description: IPv4 INBOUND rule set
           default_action: accept
           rules:
             - number: 101
               action: accept
               description: Rule 101 is configured by Ansible
               ipsec: match-ipsec
             - number: 104
               action: reject
               description: Rule 104 is configured by Ansible
               ipsec: match-none
   commands:
     - delete firewall ipv6-name UPLINK
     - delete firewall name INBOUND
     - set firewall name Downlink default-action 'accept'
     - set firewall name Downlink description 'IPv4 INBOUND rule set'
     - set firewall name Downlink rule 501 action 'accept'
     - set firewall name Downlink rule 501
     - set firewall name Downlink rule 501 description 'Rule 501 is configured by Ansible'
     - set firewall name Downlink rule 501 ipsec 'match-ipsec'
     - set firewall name Downlink rule 502 action 'reject'
     - set firewall name Downlink rule 502
     - set firewall name Downlink rule 502 description 'Rule 502 is configured by Ansible'
     - set firewall name Downlink rule 502 ipsec 'match-ipsec'
   after:
     - afi: ipv4
       rule_sets:
         - name: Downlink
           description: IPv4 INBOUND rule set
           default_action: accept
           rules:
             - number: 501
               action: accept
               description: Rule 501 is configured by Ansible
               ipsec: match-ipsec
             - number: 502
               action: reject
               description: Rule 502 is configured by Ansible
               ipsec: match-ipsec
-rendered:
-  commands:
-    - set firewall ipv6-name UPLINK default-action 'accept'
-    - set firewall ipv6-name UPLINK description 'This is ipv6 specific rule-set'
-    - set firewall name INBOUND default-action 'accept'
-    - set firewall name INBOUND description 'IPv4 INBOUND rule set'
-    - set firewall name INBOUND rule 101 action 'accept'
-    - set firewall name INBOUND rule 101
-    - set firewall name INBOUND rule 101 description 'Rule 101 is configured by Ansible'
-    - set firewall name INBOUND rule 101 ipsec 'match-ipsec'
-    - set firewall name INBOUND rule 102 action 'reject'
-    - set firewall name INBOUND rule 102
-    - set firewall name INBOUND rule 102 description 'Rule 102 is configured by Ansible'
-    - set firewall name INBOUND rule 102 ipsec 'match-ipsec'
-    - set firewall name INBOUND rule 103 description 'Rule 103 is configured by Ansible'
-    - set firewall name INBOUND rule 103 destination group address-group inbound
-    - set firewall name INBOUND rule 103
-    - set firewall name INBOUND rule 103 source address 192.0.2.0
-    - set firewall name INBOUND rule 103 state established enable
-    - set firewall name INBOUND rule 103 state related enable
-    - set firewall name INBOUND rule 103 state invalid disable
-    - set firewall name INBOUND rule 103 state new disable
-    - set firewall name INBOUND rule 103 action 'accept'
-deleted_rs:
-  commands:
-    - delete firewall ipv6-name UPLINK
-    - delete firewall name INBOUND
-  after: []
-deleted_afi_all:
-  commands:
-    - delete firewall ipv6-name
-    - delete firewall name
-  after: []
-deleted_r:
-  commands:
-    - delete firewall ipv6-name UPLINK rule 1
+parsed:
   after:
     - afi: ipv6
       rule_sets:
         - name: UPLINK
           description: This is ipv6 specific rule-set
           default_action: accept
           rules:
+            - number: 1
+              action: accept
+              description: Fwipv6-Rule 1 is configured by Ansible
+              ipsec: match-ipsec
             - number: 2
               action: accept
               description: Fwipv6-Rule 2 is configured by Ansible
               ipsec: match-ipsec
     - afi: ipv4
       rule_sets:
         - name: INBOUND
           description: IPv4 INBOUND rule set
           default_action: accept
           rules:
             - number: 101
               action: accept
               description: Rule 101 is configured by Ansible
               ipsec: match-ipsec
             - number: 102
               action: reject
               description: Rule 102 is configured by Ansible
               ipsec: match-ipsec
             - number: 103
               action: accept
               description: Rule 103 is configured by Ansible
               destination:
                 group:
                   address_group: inbound
               source:
                 address: 192.0.2.0
               state:
                 established: true
                 new: false
                 invalid: false
                 related: true
+rendered:
+  commands:
+    - set firewall ipv6-name UPLINK default-action 'accept'
+    - set firewall ipv6-name UPLINK description 'This is ipv6 specific rule-set'
+    - set firewall name INBOUND default-action 'accept'
+    - set firewall name INBOUND description 'IPv4 INBOUND rule set'
+    - set firewall name INBOUND rule 101 action 'accept'
+    - set firewall name INBOUND rule 101
+    - set firewall name INBOUND rule 101 description 'Rule 101 is configured by Ansible'
+    - set firewall name INBOUND rule 101 ipsec 'match-ipsec'
+    - set firewall name INBOUND rule 102 action 'reject'
+    - set firewall name INBOUND rule 102
+    - set firewall name INBOUND rule 102 description 'Rule 102 is configured by Ansible'
+    - set firewall name INBOUND rule 102 ipsec 'match-ipsec'
+    - set firewall name INBOUND rule 103 description 'Rule 103 is configured by Ansible'
+    - set firewall name INBOUND rule 103 destination group address-group inbound
+    - set firewall name INBOUND rule 103
+    - set firewall name INBOUND rule 103 source address 192.0.2.0
+    - set firewall name INBOUND rule 103 state established enable
+    - set firewall name INBOUND rule 103 state related enable
+    - set firewall name INBOUND rule 103 state invalid disable
+    - set firewall name INBOUND rule 103 state new disable
+    - set firewall name INBOUND rule 103 action 'accept'
+deleted_rs:
+  commands:
+    - delete firewall ipv6-name UPLINK
+    - delete firewall name INBOUND
+  after: []
+deleted_afi_all:
+  commands:
+    - delete firewall ipv6-name
+    - delete firewall name
+  after: []
 round_trip:
   after:
     - afi: ipv6
       rule_sets:
         - name: UPLINK
           description: This is ipv6 specific rule-set
           default_action: accept
           rules:
             - number: 1
               action: accept
               description: Fwipv6-Rule 1 is configured by Ansible
               ipsec: match-ipsec
             - number: 2
               action: accept
               description: Fwipv6-Rule 2 is configured by Ansible
               ipsec: match-ipsec
     - afi: ipv4
       rule_sets:
         - name: INBOUND
           description: IPv4 INBOUND rule set
           default_action: accept
           rules:
             - number: 101
               action: accept
               description: Rule 101 is configured by Ansible
               ipsec: match-ipsec
             - number: 102
               action: reject
               description: Rule 102 is configured by Ansible
               ipsec: match-ipsec
             - number: 103
               action: accept
               description: Rule 103 is configured by Ansible
               source:
                 address: 192.0.2.0
               state:
                 established: true
                 new: false
                 invalid: false
                 related: true