diff --git a/changelogs/fragments/271_equuleus_facts.yaml b/changelogs/fragments/271_equuleus_facts.yaml
new file mode 100644
index 0000000..1399180
--- /dev/null
+++ b/changelogs/fragments/271_equuleus_facts.yaml
@@ -0,0 +1,3 @@
+---
+minor_changes:
+  - Update fact gathering to support v1.3 show version output
diff --git a/plugins/cliconf/vyos.py b/plugins/cliconf/vyos.py
index f2064d7..885cf1f 100644
--- a/plugins/cliconf/vyos.py
+++ b/plugins/cliconf/vyos.py
@@ -1,363 +1,363 @@
 # (c) 2017 Red Hat Inc.
 #
 # This file is part of Ansible
 #
 # Ansible is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation, either version 3 of the License, or
 # (at your option) any later version.
 #
 # Ansible is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License
 # along with Ansible.  If not, see <http://www.gnu.org/licenses/>.
 #
 from __future__ import absolute_import, division, print_function
 
 __metaclass__ = type
 
 DOCUMENTATION = """
 author: Ansible Networking Team (@ansible-network)
 name: vyos
 short_description: Use vyos cliconf to run command on VyOS platform
 description:
 - This vyos plugin provides low level abstraction apis for sending and receiving CLI
   commands from VyOS network devices.
 version_added: 1.0.0
 options:
   config_commands:
     description:
     - Specifies a list of commands that can make configuration changes
       to the target device.
     - When `ansible_network_single_user_mode` is enabled, if a command sent
       to the device is present in this list, the existing cache is invalidated.
     version_added: 2.0.0
     type: list
     elements: str
     default: []
     vars:
     - name: ansible_vyos_config_commands
 """
 
 import re
 import json
 
 from ansible.errors import AnsibleConnectionFailure
 from ansible.module_utils._text import to_text
 from ansible.module_utils.common._collections_compat import Mapping
 from ansible_collections.ansible.netcommon.plugins.module_utils.network.common.config import (
     NetworkConfig,
 )
 from ansible_collections.ansible.netcommon.plugins.module_utils.network.common.utils import (
     to_list,
 )
 from ansible_collections.ansible.netcommon.plugins.plugin_utils.cliconf_base import (
     CliconfBase,
 )
 
 
 class Cliconf(CliconfBase):
     __rpc__ = CliconfBase.__rpc__ + [
         "commit",
         "discard_changes",
         "get_diff",
         "run_commands",
     ]
 
     def __init__(self, *args, **kwargs):
         super(Cliconf, self).__init__(*args, **kwargs)
         self._device_info = {}
 
     def get_device_info(self):
         if not self._device_info:
             device_info = {}
 
             device_info["network_os"] = "vyos"
             reply = self.get("show version")
             data = to_text(reply, errors="surrogate_or_strict").strip()
 
             match = re.search(r"Version:\s*(.*)", data)
             if match:
                 device_info["network_os_version"] = match.group(1)
 
-            match = re.search(r"HW model:\s*(\S+)", data)
+            match = re.search(r"(?:HW|Hardware) model:\s*(\S+)", data)
             if match:
                 device_info["network_os_model"] = match.group(1)
 
             reply = self.get("show host name")
             device_info["network_os_hostname"] = to_text(
                 reply, errors="surrogate_or_strict"
             ).strip()
 
             self._device_info = device_info
 
         return self._device_info
 
     def get_config(self, flags=None, format=None):
         if format:
             option_values = self.get_option_values()
             if format not in option_values["format"]:
                 raise ValueError(
                     "'format' value %s is invalid. Valid values of format are %s"
                     % (format, ", ".join(option_values["format"]))
                 )
 
         if not flags:
             flags = []
 
         if format == "text":
             command = "show configuration"
         else:
             command = "show configuration commands"
 
         command += " ".join(to_list(flags))
         command = command.strip()
 
         out = self.send_command(command)
         return out
 
     def edit_config(
         self, candidate=None, commit=True, replace=None, comment=None
     ):
         resp = {}
         operations = self.get_device_operations()
         self.check_edit_config_capability(
             operations, candidate, commit, replace, comment
         )
 
         results = []
         requests = []
         self.send_command("configure")
         for cmd in to_list(candidate):
             if not isinstance(cmd, Mapping):
                 cmd = {"command": cmd}
 
             results.append(self.send_command(**cmd))
             requests.append(cmd["command"])
         out = self.get("compare")
         out = to_text(out, errors="surrogate_or_strict")
         diff_config = out if not out.startswith("No changes") else None
 
         if diff_config:
             if commit:
                 try:
                     self.commit(comment)
                 except AnsibleConnectionFailure as e:
                     msg = "commit failed: %s" % e.message
                     self.discard_changes()
                     raise AnsibleConnectionFailure(msg)
                 else:
                     self.send_command("exit")
             else:
                 self.discard_changes()
         else:
             self.send_command("exit")
             if (
                 to_text(
                     self._connection.get_prompt(), errors="surrogate_or_strict"
                 )
                 .strip()
                 .endswith("#")
             ):
                 self.discard_changes()
 
         if diff_config:
             resp["diff"] = diff_config
         resp["response"] = results
         resp["request"] = requests
         return resp
 
     def get(
         self,
         command=None,
         prompt=None,
         answer=None,
         sendonly=False,
         newline=True,
         output=None,
         check_all=False,
     ):
         if not command:
             raise ValueError("must provide value of command to execute")
         if output:
             raise ValueError(
                 "'output' value %s is not supported for get" % output
             )
 
         return self.send_command(
             command=command,
             prompt=prompt,
             answer=answer,
             sendonly=sendonly,
             newline=newline,
             check_all=check_all,
         )
 
     def commit(self, comment=None):
         if comment:
             command = 'commit comment "{0}"'.format(comment)
         else:
             command = "commit"
         self.send_command(command)
 
     def discard_changes(self):
         self.send_command("exit discard")
 
     def get_diff(
         self,
         candidate=None,
         running=None,
         diff_match="line",
         diff_ignore_lines=None,
         path=None,
         diff_replace=None,
     ):
         diff = {}
         device_operations = self.get_device_operations()
         option_values = self.get_option_values()
 
         if candidate is None and device_operations["supports_generate_diff"]:
             raise ValueError(
                 "candidate configuration is required to generate diff"
             )
 
         if diff_match not in option_values["diff_match"]:
             raise ValueError(
                 "'match' value %s in invalid, valid values are %s"
                 % (diff_match, ", ".join(option_values["diff_match"]))
             )
 
         if diff_replace:
             raise ValueError("'replace' in diff is not supported")
 
         if diff_ignore_lines:
             raise ValueError("'diff_ignore_lines' in diff is not supported")
 
         if path:
             raise ValueError("'path' in diff is not supported")
 
         set_format = candidate.startswith("set") or candidate.startswith(
             "delete"
         )
         candidate_obj = NetworkConfig(indent=4, contents=candidate)
         if not set_format:
             config = [c.line for c in candidate_obj.items]
             commands = list()
             # this filters out less specific lines
             for item in config:
                 for index, entry in enumerate(commands):
                     if item.startswith(entry):
                         del commands[index]
                         break
                 commands.append(item)
 
             candidate_commands = [
                 "set %s" % cmd.replace(" {", "") for cmd in commands
             ]
 
         else:
             candidate_commands = str(candidate).strip().split("\n")
 
         if diff_match == "none":
             diff["config_diff"] = list(candidate_commands)
             return diff
 
         running_commands = [
             str(c).replace("'", "") for c in running.splitlines()
         ]
 
         updates = list()
         visited = set()
 
         for line in candidate_commands:
             item = str(line).replace("'", "")
 
             if not item.startswith("set") and not item.startswith("delete"):
                 raise ValueError(
                     "line must start with either `set` or `delete`"
                 )
 
             elif item.startswith("set") and item not in running_commands:
                 updates.append(line)
 
             elif item.startswith("delete"):
                 if not running_commands:
                     updates.append(line)
                 else:
                     item = re.sub(r"delete", "set", item)
                     for entry in running_commands:
                         if entry.startswith(item) and line not in visited:
                             updates.append(line)
                             visited.add(line)
 
         diff["config_diff"] = list(updates)
         return diff
 
     def run_commands(self, commands=None, check_rc=True):
         if commands is None:
             raise ValueError("'commands' value is required")
 
         responses = list()
         for cmd in to_list(commands):
             if not isinstance(cmd, Mapping):
                 cmd = {"command": cmd}
 
             output = cmd.pop("output", None)
             if output:
                 raise ValueError(
                     "'output' value %s is not supported for run_commands"
                     % output
                 )
 
             try:
                 out = self.send_command(**cmd)
             except AnsibleConnectionFailure as e:
                 if check_rc:
                     raise
                 out = getattr(e, "err", e)
 
             responses.append(out)
 
         return responses
 
     def get_device_operations(self):
         return {
             "supports_diff_replace": False,
             "supports_commit": True,
             "supports_rollback": False,
             "supports_defaults": False,
             "supports_onbox_diff": True,
             "supports_commit_comment": True,
             "supports_multiline_delimiter": False,
             "supports_diff_match": True,
             "supports_diff_ignore_lines": False,
             "supports_generate_diff": False,
             "supports_replace": False,
         }
 
     def get_option_values(self):
         return {
             "format": ["text", "set"],
             "diff_match": ["line", "none"],
             "diff_replace": [],
             "output": [],
         }
 
     def get_capabilities(self):
         result = super(Cliconf, self).get_capabilities()
         result["device_operations"] = self.get_device_operations()
         result.update(self.get_option_values())
         return json.dumps(result)
 
     def set_cli_prompt_context(self):
         """
         Make sure we are in the operational cli mode
         :return: None
         """
         if self._connection.connected:
             self._update_cli_prompt_context(
                 config_context="#", exit_command="exit discard"
             )
diff --git a/plugins/module_utils/network/vyos/facts/legacy/base.py b/plugins/module_utils/network/vyos/facts/legacy/base.py
index a493421..6f063d6 100644
--- a/plugins/module_utils/network/vyos/facts/legacy/base.py
+++ b/plugins/module_utils/network/vyos/facts/legacy/base.py
@@ -1,162 +1,162 @@
 # -*- 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 interfaces fact class
 It is in this file the configuration is collected from the device
 for a given resource, parsed, and the facts tree is populated
 based on the configuration.
 """
 
 from __future__ import absolute_import, division, print_function
 
 __metaclass__ = type
 import platform
 import re
 from ansible_collections.vyos.vyos.plugins.module_utils.network.vyos.vyos import (
     run_commands,
     get_capabilities,
 )
 
 
 class LegacyFactsBase(object):
 
     COMMANDS = frozenset()
 
     def __init__(self, module):
         self.module = module
         self.facts = dict()
         self.warnings = list()
         self.responses = None
 
     def populate(self):
         self.responses = run_commands(self.module, list(self.COMMANDS))
 
 
 class Default(LegacyFactsBase):
 
     COMMANDS = [
         "show version",
     ]
 
     def populate(self):
         super(Default, self).populate()
         data = self.responses[0]
         self.facts["serialnum"] = self.parse_serialnum(data)
         self.facts.update(self.platform_facts())
 
     def parse_serialnum(self, data):
-        match = re.search(r"HW S/N:\s+(\S+)", data)
+        match = re.search(r"(?:HW|Hardware) S/N:\s+(\S+)", data)
         if match:
             return match.group(1)
 
     def platform_facts(self):
         platform_facts = {}
 
         resp = get_capabilities(self.module)
         device_info = resp["device_info"]
 
         platform_facts["system"] = device_info["network_os"]
 
         for item in ("model", "image", "version", "platform", "hostname"):
             val = device_info.get("network_os_%s" % item)
             if val:
                 platform_facts[item] = val
 
         platform_facts["api"] = resp["network_api"]
         platform_facts["python_version"] = platform.python_version()
 
         return platform_facts
 
 
 class Config(LegacyFactsBase):
 
     COMMANDS = [
         "show configuration commands",
         "show system commit",
     ]
 
     def populate(self):
         super(Config, self).populate()
 
         self.facts["config"] = self.responses
 
         commits = self.responses[1]
         entries = list()
         entry = None
 
         for line in commits.split("\n"):
             match = re.match(r"(\d+)\s+(.+)by(.+)via(.+)", line)
             if match:
                 if entry:
                     entries.append(entry)
 
                 entry = dict(
                     revision=match.group(1),
                     datetime=match.group(2),
                     by=str(match.group(3)).strip(),
                     via=str(match.group(4)).strip(),
                     comment=None,
                 )
             else:
                 entry["comment"] = line.strip()
 
         self.facts["commits"] = entries
 
 
 class Neighbors(LegacyFactsBase):
 
     COMMANDS = [
         "show lldp neighbors",
         "show lldp neighbors detail",
     ]
 
     def populate(self):
         super(Neighbors, self).populate()
 
         all_neighbors = self.responses[0]
         if "LLDP not configured" not in all_neighbors:
             neighbors = self.parse(self.responses[1])
             self.facts["neighbors"] = self.parse_neighbors(neighbors)
 
     def parse(self, data):
         parsed = list()
         values = None
         for line in data.split("\n"):
             if not line:
                 continue
             if line[0] == " ":
                 values += "\n%s" % line
             elif line.startswith("Interface"):
                 if values:
                     parsed.append(values)
                 values = line
         if values:
             parsed.append(values)
         return parsed
 
     def parse_neighbors(self, data):
         facts = dict()
         for item in data:
             interface = self.parse_interface(item)
             host = self.parse_host(item)
             port = self.parse_port(item)
             if interface not in facts:
                 facts[interface] = list()
             facts[interface].append(dict(host=host, port=port))
         return facts
 
     def parse_interface(self, data):
         match = re.search(r"^Interface:\s+(\S+),", data)
         return match.group(1)
 
     def parse_host(self, data):
         match = re.search(r"SysName:\s+(.+)$", data, re.M)
         if match:
             return match.group(1)
 
     def parse_port(self, data):
         match = re.search(r"PortDescr:\s+(.+)$", data, re.M)
         if match:
             return match.group(1)