diff --git a/SabreTools.DatFiles.Test/FormatsTests.cs b/SabreTools.DatFiles.Test/FormatsTests.cs
index a9fbc68e..84aa1986 100644
--- a/SabreTools.DatFiles.Test/FormatsTests.cs
+++ b/SabreTools.DatFiles.Test/FormatsTests.cs
@@ -2,6 +2,7 @@ using System;
 using System.Linq;
 using SabreTools.DatFiles.Formats;
 using SabreTools.DatItems;
+using SabreTools.DatItems.Formats;
 using Xunit;
 
 namespace SabreTools.DatFiles.Test
@@ -27,29 +28,43 @@ namespace SabreTools.DatFiles.Test
         {
             var datFile = new ArchiveDotOrg(null);
             var actual = datFile.SupportedTypes;
-            Assert.True(actual.SequenceEqual([ItemType.Rom]));
+            Assert.True(actual.SequenceEqual([
+                ItemType.Rom,
+            ]));
         }
 
         #endregion
 
         #region AttractMode
 
-        // TODO: Write AttractMode format tests
-
         [Fact]
         public void AttractMode_SupportedTypes()
         {
             var datFile = new AttractMode(null);
             var actual = datFile.SupportedTypes;
-            Assert.True(actual.SequenceEqual([ItemType.Rom]));
+            Assert.True(actual.SequenceEqual([
+                ItemType.Rom,
+            ]));
+        }
+
+        [Fact]
+        public void AttractMode_GetMissingRequiredFields_Rom()
+        {
+            var datItem = new Rom();
+            var datFile = new AttractMode(null);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.Rom.NameKey,
+            ]));
         }
 
         #endregion
 
         #region ClrMamePro
 
-        // TODO: Write ClrMamePro format tests
-
         [Fact]
         public void ClrMamePro_SupportedTypes()
         {
@@ -72,76 +87,324 @@ namespace SabreTools.DatFiles.Test
             ]));
         }
 
+        [Fact]
+        public void ClrMamePro_GetMissingRequiredFields_Release()
+        {
+            var datItem = new Release();
+            var datFile = new ClrMamePro(null);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.Release.NameKey,
+                Models.Metadata.Release.RegionKey,
+            ]));
+        }
+
+        [Fact]
+        public void ClrMamePro_GetMissingRequiredFields_BiosSet()
+        {
+            var datItem = new BiosSet();
+            var datFile = new ClrMamePro(null);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.BiosSet.NameKey,
+                Models.Metadata.BiosSet.DescriptionKey,
+            ]));
+        }
+
+        [Fact]
+        public void ClrMamePro_GetMissingRequiredFields_Rom()
+        {
+            var datItem = new Rom();
+            var datFile = new ClrMamePro(null);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.Rom.NameKey,
+                Models.Metadata.Rom.SizeKey,
+                Models.Metadata.Rom.SHA1Key,
+            ]));
+        }
+
+        [Fact]
+        public void ClrMamePro_GetMissingRequiredFields_Disk()
+        {
+            var datItem = new Disk();
+            var datFile = new ClrMamePro(null);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.Disk.NameKey,
+                Models.Metadata.Disk.SHA1Key,
+            ]));
+        }
+
+        [Fact]
+        public void ClrMamePro_GetMissingRequiredFields_Sample()
+        {
+            var datItem = new Sample();
+            var datFile = new ClrMamePro(null);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.Sample.NameKey,
+            ]));
+        }
+
+        [Fact]
+        public void ClrMamePro_GetMissingRequiredFields_Archive()
+        {
+            var datItem = new Archive();
+            var datFile = new ClrMamePro(null);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.Archive.NameKey,
+            ]));
+        }
+
+        [Fact]
+        public void ClrMamePro_GetMissingRequiredFields_Chip()
+        {
+            var datItem = new Chip();
+            var datFile = new ClrMamePro(null);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.Chip.ChipTypeKey,
+                Models.Metadata.Chip.NameKey,
+            ]));
+        }
+
+        [Fact]
+        public void ClrMamePro_GetMissingRequiredFields_Display()
+        {
+            var datItem = new Display();
+            var datFile = new ClrMamePro(null);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.Display.DisplayTypeKey,
+                Models.Metadata.Display.RotateKey,
+            ]));
+        }
+
+        [Fact]
+        public void ClrMamePro_GetMissingRequiredFields_Sound()
+        {
+            var datItem = new Sound();
+            var datFile = new ClrMamePro(null);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.Sound.ChannelsKey,
+            ]));
+        }
+
+        [Fact]
+        public void ClrMamePro_GetMissingRequiredFields_Input()
+        {
+            var datItem = new Input();
+            var datFile = new ClrMamePro(null);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.Input.PlayersKey,
+                Models.Metadata.Input.ControlKey,
+            ]));
+        }
+
+        [Fact]
+        public void ClrMamePro_GetMissingRequiredFields_DipSwitch()
+        {
+            var datItem = new DipSwitch();
+            var datFile = new ClrMamePro(null);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.DipSwitch.NameKey,
+            ]));
+        }
+
+        [Fact]
+        public void ClrMamePro_GetMissingRequiredFields_Driver()
+        {
+            var datItem = new Driver();
+            var datFile = new ClrMamePro(null);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.Driver.StatusKey,
+                Models.Metadata.Driver.EmulationKey,
+            ]));
+        }
+
         #endregion
 
         #region DosCenter
 
-        // TODO: Write DosCenter format tests
-
         [Fact]
         public void DosCenter_SupportedTypes()
         {
             var datFile = new DosCenter(null);
             var actual = datFile.SupportedTypes;
-            Assert.True(actual.SequenceEqual([ItemType.Rom]));
+            Assert.True(actual.SequenceEqual([
+                ItemType.Rom,
+            ]));
+        }
+
+        [Fact]
+        public void DosCenter_GetMissingRequiredFields_Rom()
+        {
+            var datItem = new Rom();
+            var datFile = new DosCenter(null);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.Rom.NameKey,
+                Models.Metadata.Rom.SizeKey,
+                Models.Metadata.Rom.CRCKey,
+            ]));
         }
 
         #endregion
 
         #region EverdriveSMDB
 
-        // TODO: Write EverdriveSMDB format tests
-
         [Fact]
         public void EverdriveSMDB_SupportedTypes()
         {
             var datFile = new EverdriveSMDB(null);
             var actual = datFile.SupportedTypes;
-            Assert.True(actual.SequenceEqual([ItemType.Rom]));
+            Assert.True(actual.SequenceEqual([
+                ItemType.Rom,
+            ]));
+        }
+
+        [Fact]
+        public void EverdriveSMDB_GetMissingRequiredFields_Rom()
+        {
+            var datItem = new Rom();
+            var datFile = new EverdriveSMDB(null);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.Rom.NameKey,
+                Models.Metadata.Rom.SHA256Key,
+                Models.Metadata.Rom.SHA1Key,
+                Models.Metadata.Rom.MD5Key,
+                Models.Metadata.Rom.CRCKey,
+            ]));
         }
 
         #endregion
 
         #region Hashfile
 
-        // TODO: Write Hashfile format tests
-
         [Fact]
         public void SfvFile_SupportedTypes()
         {
             var datFile = new SfvFile(null);
             var actual = datFile.SupportedTypes;
             Assert.True(actual.SequenceEqual([
-                ItemType.Disk,
-                ItemType.Media,
                 ItemType.Rom,
             ]));
         }
 
+        [Fact]
+        public void SfvFile_GetMissingRequiredFields_Rom()
+        {
+            var datItem = new Rom();
+            var datFile = new SfvFile(null);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.Rom.NameKey,
+                Models.Metadata.Rom.CRCKey,
+            ]));
+        }
+
         [Fact]
         public void Md2File_SupportedTypes()
         {
             var datFile = new Md2File(null);
             var actual = datFile.SupportedTypes;
             Assert.True(actual.SequenceEqual([
-                ItemType.Disk,
-                ItemType.Media,
                 ItemType.Rom,
             ]));
         }
 
+        [Fact]
+        public void Md2File_GetMissingRequiredFields_Rom()
+        {
+            var datItem = new Rom();
+            var datFile = new Md2File(null);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.Rom.NameKey,
+                Models.Metadata.Rom.MD2Key,
+            ]));
+        }
+
         [Fact]
         public void Md4File_SupportedTypes()
         {
             var datFile = new Md4File(null);
             var actual = datFile.SupportedTypes;
             Assert.True(actual.SequenceEqual([
-                ItemType.Disk,
-                ItemType.Media,
                 ItemType.Rom,
             ]));
         }
 
+        [Fact]
+        public void Md4File_GetMissingRequiredFields_Rom()
+        {
+            var datItem = new Rom();
+            var datFile = new Md4File(null);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.Rom.NameKey,
+                Models.Metadata.Rom.MD4Key,
+            ]));
+        }
+
         [Fact]
         public void Md5File_SupportedTypes()
         {
@@ -154,6 +417,51 @@ namespace SabreTools.DatFiles.Test
             ]));
         }
 
+        [Fact]
+        public void Md5File_GetMissingRequiredFields_Disk()
+        {
+            var datItem = new Disk();
+            var datFile = new Md5File(null);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.Disk.NameKey,
+                Models.Metadata.Disk.MD5Key,
+            ]));
+        }
+
+        [Fact]
+        public void Md5File_GetMissingRequiredFields_Media()
+        {
+            var datItem = new Media();
+            var datFile = new Md5File(null);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.Media.NameKey,
+                Models.Metadata.Media.MD5Key,
+            ]));
+        }
+
+        [Fact]
+        public void Md5File_GetMissingRequiredFields_Rom()
+        {
+            var datItem = new Rom();
+            var datFile = new Md5File(null);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.Rom.NameKey,
+                Models.Metadata.Rom.MD5Key,
+            ]));
+        }
+
         [Fact]
         public void Sha1File_SupportedTypes()
         {
@@ -166,60 +474,187 @@ namespace SabreTools.DatFiles.Test
             ]));
         }
 
+        [Fact]
+        public void Sha1File_GetMissingRequiredFields_Disk()
+        {
+            var datItem = new Disk();
+            var datFile = new Sha1File(null);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.Disk.NameKey,
+                Models.Metadata.Disk.SHA1Key,
+            ]));
+        }
+
+        [Fact]
+        public void Sha1File_GetMissingRequiredFields_Media()
+        {
+            var datItem = new Media();
+            var datFile = new Sha1File(null);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.Media.NameKey,
+                Models.Metadata.Media.SHA1Key,
+            ]));
+        }
+
+        [Fact]
+        public void Sha1File_GetMissingRequiredFields_Rom()
+        {
+            var datItem = new Rom();
+            var datFile = new Sha1File(null);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.Rom.NameKey,
+                Models.Metadata.Rom.SHA1Key,
+            ]));
+        }
+
         [Fact]
         public void Sha256File_SupportedTypes()
         {
             var datFile = new Sha256File(null);
             var actual = datFile.SupportedTypes;
             Assert.True(actual.SequenceEqual([
-                ItemType.Disk,
                 ItemType.Media,
                 ItemType.Rom,
             ]));
         }
 
+        [Fact]
+        public void Sha256File_GetMissingRequiredFields_Media()
+        {
+            var datItem = new Media();
+            var datFile = new Sha256File(null);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.Media.NameKey,
+                Models.Metadata.Media.SHA256Key,
+            ]));
+        }
+
+        [Fact]
+        public void Sha256File_GetMissingRequiredFields_Rom()
+        {
+            var datItem = new Rom();
+            var datFile = new Sha256File(null);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.Rom.NameKey,
+                Models.Metadata.Rom.SHA256Key,
+            ]));
+        }
+
         [Fact]
         public void Sha384File_SupportedTypes()
         {
             var datFile = new Sha384File(null);
             var actual = datFile.SupportedTypes;
             Assert.True(actual.SequenceEqual([
-                ItemType.Disk,
-                ItemType.Media,
                 ItemType.Rom,
             ]));
         }
 
+        [Fact]
+        public void Sha384File_GetMissingRequiredFields_Rom()
+        {
+            var datItem = new Rom();
+            var datFile = new Sha384File(null);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.Rom.NameKey,
+                Models.Metadata.Rom.SHA384Key,
+            ]));
+        }
+
         [Fact]
         public void Sha512File_SupportedTypes()
         {
             var datFile = new Sha512File(null);
             var actual = datFile.SupportedTypes;
             Assert.True(actual.SequenceEqual([
-                ItemType.Disk,
-                ItemType.Media,
                 ItemType.Rom,
             ]));
         }
 
+        [Fact]
+        public void Sha512File_GetMissingRequiredFields_Rom()
+        {
+            var datItem = new Rom();
+            var datFile = new Sha512File(null);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.Rom.NameKey,
+                Models.Metadata.Rom.SHA512Key,
+            ]));
+        }
+
         [Fact]
         public void SpamSumFile_SupportedTypes()
         {
             var datFile = new SpamSumFile(null);
             var actual = datFile.SupportedTypes;
             Assert.True(actual.SequenceEqual([
-                ItemType.Disk,
                 ItemType.Media,
                 ItemType.Rom,
             ]));
         }
 
+        [Fact]
+        public void SpamSumFile_GetMissingRequiredFields_Media()
+        {
+            var datItem = new Media();
+            var datFile = new SpamSumFile(null);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.Media.NameKey,
+                Models.Metadata.Media.SpamSumKey,
+            ]));
+        }
+
+        [Fact]
+        public void SpamSumFile_GetMissingRequiredFields_Rom()
+        {
+            var datItem = new Rom();
+            var datFile = new SpamSumFile(null);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.Rom.NameKey,
+                Models.Metadata.Rom.SpamSumKey,
+            ]));
+        }
+
         #endregion
 
         #region Listrom
 
-        // TODO: Write Listrom format tests
-
         [Fact]
         public void Listrom_SupportedTypes()
         {
@@ -231,12 +666,42 @@ namespace SabreTools.DatFiles.Test
             ]));
         }
 
+        [Fact]
+        public void Listrom_GetMissingRequiredFields_Disk()
+        {
+            var datItem = new Disk();
+            var datFile = new Listrom(null);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.Disk.NameKey,
+                Models.Metadata.Disk.SHA1Key,
+            ]));
+        }
+
+        [Fact]
+        public void Listrom_GetMissingRequiredFields_Rom()
+        {
+            var datItem = new Rom();
+            var datFile = new Listrom(null);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.Rom.NameKey,
+                Models.Metadata.Rom.SizeKey,
+                Models.Metadata.Rom.CRCKey,
+                Models.Metadata.Rom.SHA1Key,
+            ]));
+        }
+
         #endregion
 
         #region Listxml
 
-        // TODO: Write Listxml format tests
-
         [Fact]
         public void Listxml_SupportedTypes()
         {
@@ -266,12 +731,289 @@ namespace SabreTools.DatFiles.Test
             ]));
         }
 
+        [Fact]
+        public void Listxml_GetMissingRequiredFields_BiosSet()
+        {
+            var datItem = new BiosSet();
+            var datFile = new Listxml(null);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.BiosSet.NameKey,
+                Models.Metadata.BiosSet.DescriptionKey,
+            ]));
+        }
+
+        [Fact]
+        public void Listxml_GetMissingRequiredFields_Rom()
+        {
+            var datItem = new Rom();
+            var datFile = new Listxml(null);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.Rom.NameKey,
+                Models.Metadata.Rom.SizeKey,
+                Models.Metadata.Rom.SHA1Key,
+            ]));
+        }
+
+        [Fact]
+        public void Listxml_GetMissingRequiredFields_Disk()
+        {
+            var datItem = new Disk();
+            var datFile = new Listxml(null);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.Disk.NameKey,
+                Models.Metadata.Disk.SHA1Key,
+            ]));
+        }
+
+        [Fact]
+        public void Listxml_GetMissingRequiredFields_DeviceRef()
+        {
+            var datItem = new DeviceRef();
+            var datFile = new Listxml(null);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.DeviceRef.NameKey,
+            ]));
+        }
+
+        [Fact]
+        public void Listxml_GetMissingRequiredFields_Sample()
+        {
+            var datItem = new Sample();
+            var datFile = new Listxml(null);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.Sample.NameKey,
+            ]));
+        }
+
+        [Fact]
+        public void Listxml_GetMissingRequiredFields_Chip()
+        {
+            var datItem = new Chip();
+            var datFile = new Listxml(null);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.Chip.NameKey,
+                Models.Metadata.Chip.ChipTypeKey,
+            ]));
+        }
+
+        [Fact]
+        public void Listxml_GetMissingRequiredFields_Display()
+        {
+            var datItem = new Display();
+            var datFile = new Listxml(null);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.Display.DisplayTypeKey,
+                Models.Metadata.Display.RefreshKey,
+            ]));
+        }
+
+        [Fact]
+        public void Listxml_GetMissingRequiredFields_Sound()
+        {
+            var datItem = new Sound();
+            var datFile = new Listxml(null);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.Sound.ChannelsKey,
+            ]));
+        }
+
+        [Fact]
+        public void Listxml_GetMissingRequiredFields_Input()
+        {
+            var datItem = new Input();
+            var datFile = new Listxml(null);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.Input.PlayersKey,
+            ]));
+        }
+
+        [Fact]
+        public void Listxml_GetMissingRequiredFields_DipSwitch()
+        {
+            var datItem = new DipSwitch();
+            var datFile = new Listxml(null);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.DipSwitch.NameKey,
+                Models.Metadata.DipSwitch.TagKey,
+            ]));
+        }
+
+        [Fact]
+        public void Listxml_GetMissingRequiredFields_Configuration()
+        {
+            var datItem = new Configuration();
+            var datFile = new Listxml(null);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.Configuration.NameKey,
+                Models.Metadata.Configuration.TagKey,
+            ]));
+        }
+
+        [Fact]
+        public void Listxml_GetMissingRequiredFields_Port()
+        {
+            var datItem = new Port();
+            var datFile = new Listxml(null);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.Port.TagKey,
+            ]));
+        }
+
+        [Fact]
+        public void Listxml_GetMissingRequiredFields_Adjuster()
+        {
+            var datItem = new Adjuster();
+            var datFile = new Listxml(null);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.Adjuster.NameKey,
+            ]));
+        }
+
+        [Fact]
+        public void Listxml_GetMissingRequiredFields_Driver()
+        {
+            var datItem = new Driver();
+            var datFile = new Listxml(null);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.Driver.StatusKey,
+                Models.Metadata.Driver.EmulationKey,
+                Models.Metadata.Driver.CocktailKey,
+                Models.Metadata.Driver.SaveStateKey,
+            ]));
+        }
+
+        [Fact]
+        public void Listxml_GetMissingRequiredFields_Feature()
+        {
+            var datItem = new Feature();
+            var datFile = new Listxml(null);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.Feature.FeatureTypeKey,
+            ]));
+        }
+
+        [Fact]
+        public void Listxml_GetMissingRequiredFields_Device()
+        {
+            var datItem = new Device();
+            var datFile = new Listxml(null);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.Device.DeviceTypeKey,
+            ]));
+        }
+
+        [Fact]
+        public void Listxml_GetMissingRequiredFields_Slot()
+        {
+            var datItem = new Slot();
+            var datFile = new Listxml(null);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.Slot.NameKey,
+            ]));
+        }
+
+        [Fact]
+        public void Listxml_GetMissingRequiredFields_SoftwareList()
+        {
+            var datItem = new DatItems.Formats.SoftwareList();
+            var datFile = new Listxml(null);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.SoftwareList.TagKey,
+                Models.Metadata.SoftwareList.NameKey,
+                Models.Metadata.SoftwareList.StatusKey,
+            ]));
+        }
+
+        [Fact]
+        public void Listxml_GetMissingRequiredFields_RamOption()
+        {
+            var datItem = new RamOption();
+            var datFile = new Listxml(null);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.RamOption.NameKey,
+            ]));
+        }
+
         #endregion
 
         #region Logiqx
 
-        // TODO: Write Logiqx format tests
-
         [Fact]
         public void Logiqx_SupportedTypes()
         {
@@ -280,11 +1022,165 @@ namespace SabreTools.DatFiles.Test
             Assert.True(actual.SequenceEqual([
                 ItemType.Archive,
                 ItemType.BiosSet,
+                ItemType.DeviceRef,
                 ItemType.Disk,
+                ItemType.Driver,
                 ItemType.Media,
                 ItemType.Release,
                 ItemType.Rom,
                 ItemType.Sample,
+                ItemType.SoftwareList,
+            ]));
+        }
+
+        [Fact]
+        public void Logiqx_GetMissingRequiredFields_Release()
+        {
+            var datItem = new Release();
+            var datFile = new Logiqx(null, false);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.Release.NameKey,
+                Models.Metadata.Release.RegionKey,
+            ]));
+        }
+
+        [Fact]
+        public void Logiqx_GetMissingRequiredFields_BiosSet()
+        {
+            var datItem = new BiosSet();
+            var datFile = new Logiqx(null, false);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.BiosSet.NameKey,
+                Models.Metadata.BiosSet.DescriptionKey,
+            ]));
+        }
+
+        [Fact]
+        public void Logiqx_GetMissingRequiredFields_Rom()
+        {
+            var datItem = new Rom();
+            var datFile = new Logiqx(null, false);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.Rom.NameKey,
+                Models.Metadata.Rom.SizeKey,
+                Models.Metadata.Rom.SHA1Key,
+            ]));
+        }
+
+        [Fact]
+        public void Logiqx_GetMissingRequiredFields_Disk()
+        {
+            var datItem = new Disk();
+            var datFile = new Logiqx(null, false);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.Disk.NameKey,
+                Models.Metadata.Disk.SHA1Key,
+            ]));
+        }
+
+        [Fact]
+        public void Logiqx_GetMissingRequiredFields_Media()
+        {
+            var datItem = new Media();
+            var datFile = new Logiqx(null, false);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.Media.NameKey,
+                Models.Metadata.Media.SHA1Key,
+            ]));
+        }
+
+        [Fact]
+        public void Logiqx_GetMissingRequiredFields_DeviceRef()
+        {
+            var datItem = new DeviceRef();
+            var datFile = new Logiqx(null, false);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.DeviceRef.NameKey,
+            ]));
+        }
+
+        [Fact]
+        public void Logiqx_GetMissingRequiredFields_Sample()
+        {
+            var datItem = new Sample();
+            var datFile = new Logiqx(null, false);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.Sample.NameKey,
+            ]));
+        }
+
+        [Fact]
+        public void Logiqx_GetMissingRequiredFields_Archive()
+        {
+            var datItem = new Archive();
+            var datFile = new Logiqx(null, false);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.Archive.NameKey,
+            ]));
+        }
+
+        [Fact]
+        public void Logiqx_GetMissingRequiredFields_Driver()
+        {
+            var datItem = new Driver();
+            var datFile = new Logiqx(null, false);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.Driver.StatusKey,
+                Models.Metadata.Driver.EmulationKey,
+                Models.Metadata.Driver.CocktailKey,
+                Models.Metadata.Driver.SaveStateKey,
+            ]));
+        }
+
+        [Fact]
+        public void Logiqx_GetMissingRequiredFields_SoftwareList()
+        {
+            var datItem = new DatItems.Formats.SoftwareList();
+            var datFile = new Logiqx(null, false);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.SoftwareList.TagKey,
+                Models.Metadata.SoftwareList.NameKey,
+                Models.Metadata.SoftwareList.StatusKey,
             ]));
         }
 
@@ -292,8 +1188,6 @@ namespace SabreTools.DatFiles.Test
 
         #region Missfile
 
-        // TODO: Write Missfile format tests
-
         [Fact]
         public void Missfile_SupportedTypes()
         {
@@ -306,50 +1200,94 @@ namespace SabreTools.DatFiles.Test
 
         #region OfflineList
 
-        // TODO: Write OfflineList format tests
-
         [Fact]
         public void OfflineList_SupportedTypes()
         {
             var datFile = new OfflineList(null);
             var actual = datFile.SupportedTypes;
-            Assert.True(actual.SequenceEqual([ItemType.Rom]));
+            Assert.True(actual.SequenceEqual([
+                ItemType.Rom,
+            ]));
+        }
+
+        [Fact]
+        public void OfflineList_GetMissingRequiredFields_Rom()
+        {
+            var datItem = new Rom();
+            var datFile = new OfflineList(null);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.Rom.SizeKey,
+                Models.Metadata.Rom.CRCKey,
+            ]));
         }
 
         #endregion
 
         #region OpenMSX
 
-        // TODO: Write OpenMSX format tests
-
         [Fact]
         public void OpenMSX_SupportedTypes()
         {
             var datFile = new OpenMSX(null);
             var actual = datFile.SupportedTypes;
-            Assert.True(actual.SequenceEqual([ItemType.Rom]));
+            Assert.True(actual.SequenceEqual([
+                ItemType.Rom,
+            ]));
+        }
+
+        [Fact]
+        public void OpenMSX_GetMissingRequiredFields_Rom()
+        {
+            var datItem = new Rom();
+            var datFile = new OpenMSX(null);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.Rom.NameKey,
+                Models.Metadata.Rom.SHA1Key,
+            ]));
         }
 
         #endregion
 
         #region RomCenter
 
-        // TODO: Write RomCenter format tests
-
         [Fact]
         public void RomCenter_SupportedTypes()
         {
             var datFile = new RomCenter(null);
             var actual = datFile.SupportedTypes;
-            Assert.True(actual.SequenceEqual([ItemType.Rom]));
+            Assert.True(actual.SequenceEqual([
+                ItemType.Rom,
+            ]));
+        }
+
+        [Fact]
+        public void RomCenter_GetMissingRequiredFields_Rom()
+        {
+            var datItem = new Rom();
+            var datFile = new RomCenter(null);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.Rom.NameKey,
+                Models.Metadata.Rom.CRCKey,
+                Models.Metadata.Rom.SizeKey,
+            ]));
         }
 
         #endregion
 
         #region SabreJSON
 
-        // TODO: Write SabreJSON format tests
-
         [Fact]
         public void SabreJSON_SupportedTypes()
         {
@@ -362,8 +1300,6 @@ namespace SabreTools.DatFiles.Test
 
         #region SabreXML
 
-        // TODO: Write SabreXML format tests
-
         [Fact]
         public void SabreXML_SupportedTypes()
         {
@@ -376,8 +1312,6 @@ namespace SabreTools.DatFiles.Test
 
         #region SeparatedValue
 
-        // TODO: Write SeparatedValue format tests
-
         [Fact]
         public void CommaSeparatedValue_SupportedTypes()
         {
@@ -390,6 +1324,52 @@ namespace SabreTools.DatFiles.Test
             ]));
         }
 
+        [Fact]
+        public void CommaSeparatedValue_GetMissingRequiredFields_Disk()
+        {
+            var datItem = new Disk();
+            var datFile = new CommaSeparatedValue(null);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.Disk.NameKey,
+                Models.Metadata.Disk.SHA1Key,
+            ]));
+        }
+
+        [Fact]
+        public void CommaSeparatedValue_GetMissingRequiredFields_Media()
+        {
+            var datItem = new Media();
+            var datFile = new CommaSeparatedValue(null);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.Media.NameKey,
+                Models.Metadata.Media.SHA1Key,
+            ]));
+        }
+
+        [Fact]
+        public void CommaSeparatedValue_GetMissingRequiredFields_Rom()
+        {
+            var datItem = new Rom();
+            var datFile = new CommaSeparatedValue(null);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.Rom.NameKey,
+                Models.Metadata.Rom.SizeKey,
+                Models.Metadata.Rom.SHA1Key,
+            ]));
+        }
+
         [Fact]
         public void SemicolonSeparatedValue_SupportedTypes()
         {
@@ -402,6 +1382,52 @@ namespace SabreTools.DatFiles.Test
             ]));
         }
 
+        [Fact]
+        public void SemicolonSeparatedValue_GetMissingRequiredFields_Disk()
+        {
+            var datItem = new Disk();
+            var datFile = new SemicolonSeparatedValue(null);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.Disk.NameKey,
+                Models.Metadata.Disk.SHA1Key,
+            ]));
+        }
+
+        [Fact]
+        public void SemicolonSeparatedValue_GetMissingRequiredFields_Media()
+        {
+            var datItem = new Media();
+            var datFile = new SemicolonSeparatedValue(null);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.Media.NameKey,
+                Models.Metadata.Media.SHA1Key,
+            ]));
+        }
+
+        [Fact]
+        public void SemicolonSeparatedValue_GetMissingRequiredFields_Rom()
+        {
+            var datItem = new Rom();
+            var datFile = new SemicolonSeparatedValue(null);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.Rom.NameKey,
+                Models.Metadata.Rom.SizeKey,
+                Models.Metadata.Rom.SHA1Key,
+            ]));
+        }
+
         [Fact]
         public void TabSeparatedValue_SupportedTypes()
         {
@@ -414,16 +1440,60 @@ namespace SabreTools.DatFiles.Test
             ]));
         }
 
+        [Fact]
+        public void TabSeparatedValue_GetMissingRequiredFields_Disk()
+        {
+            var datItem = new Disk();
+            var datFile = new TabSeparatedValue(null);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.Disk.NameKey,
+                Models.Metadata.Disk.SHA1Key,
+            ]));
+        }
+
+        [Fact]
+        public void TabSeparatedValue_GetMissingRequiredFields_Media()
+        {
+            var datItem = new Media();
+            var datFile = new TabSeparatedValue(null);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.Media.NameKey,
+                Models.Metadata.Media.SHA1Key,
+            ]));
+        }
+
+        [Fact]
+        public void TabSeparatedValue_GetMissingRequiredFields_Rom()
+        {
+            var datItem = new Rom();
+            var datFile = new TabSeparatedValue(null);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.Rom.NameKey,
+                Models.Metadata.Rom.SizeKey,
+                Models.Metadata.Rom.SHA1Key,
+            ]));
+        }
+
         #endregion
 
         #region SoftwareList
 
-        // TODO: Write SoftwareList format tests
-
         [Fact]
         public void SoftwareList_SupportedTypes()
         {
-            var datFile = new SoftwareList(null);
+            var datFile = new Formats.SoftwareList(null);
             var actual = datFile.SupportedTypes;
             Assert.True(actual.SequenceEqual([
                 ItemType.DipSwitch,
@@ -435,6 +1505,86 @@ namespace SabreTools.DatFiles.Test
             ]));
         }
 
+        [Fact]
+        public void SoftwareList_GetMissingRequiredFields_DipSwitch()
+        {
+            var datItem = new DipSwitch();
+            var datFile = new Formats.SoftwareList(null);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.Part.NameKey,
+                Models.Metadata.Part.InterfaceKey,
+                Models.Metadata.DipSwitch.NameKey,
+                Models.Metadata.DipSwitch.TagKey,
+                Models.Metadata.DipSwitch.MaskKey,
+            ]));
+        }
+
+        [Fact]
+        public void SoftwareList_GetMissingRequiredFields_Disk()
+        {
+            var datItem = new Disk();
+            var datFile = new Formats.SoftwareList(null);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.Part.NameKey,
+                Models.Metadata.Part.InterfaceKey,
+                Models.Metadata.DiskArea.NameKey,
+                Models.Metadata.Disk.NameKey,
+            ]));
+        }
+
+        [Fact]
+        public void SoftwareList_GetMissingRequiredFields_Info()
+        {
+            var datItem = new Info();
+            var datFile = new Formats.SoftwareList(null);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.Info.NameKey,
+            ]));
+        }
+
+        [Fact]
+        public void SoftwareList_GetMissingRequiredFields_Rom()
+        {
+            var datItem = new Rom();
+            var datFile = new Formats.SoftwareList(null);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.Part.NameKey,
+                Models.Metadata.Part.InterfaceKey,
+                Models.Metadata.DataArea.NameKey,
+                Models.Metadata.DataArea.SizeKey,
+            ]));
+        }
+
+        [Fact]
+        public void SoftwareList_GetMissingRequiredFields_SharedFeat()
+        {
+            var datItem = new SharedFeat();
+            var datFile = new Formats.SoftwareList(null);
+
+            var actual = datFile.GetMissingRequiredFields(datItem);
+
+            Assert.NotNull(actual);
+            Assert.True(actual.SequenceEqual([
+                Models.Metadata.SharedFeat.NameKey,
+            ]));
+        }
+
         #endregion
     }
 }
\ No newline at end of file
diff --git a/SabreTools.DatFiles/Formats/Hashfile.cs b/SabreTools.DatFiles/Formats/Hashfile.cs
index 00b7a370..33010261 100644
--- a/SabreTools.DatFiles/Formats/Hashfile.cs
+++ b/SabreTools.DatFiles/Formats/Hashfile.cs
@@ -13,14 +13,6 @@ namespace SabreTools.DatFiles.Formats
     {
         #region Fields
 
-        /// <inheritdoc/>
-        public override ItemType[] SupportedTypes
-            => [
-                ItemType.Disk,
-                ItemType.Media,
-                ItemType.Rom,
-            ];
-
         // Private instance variables specific to Hashfile DATs
         protected HashType _hash;
 
@@ -53,167 +45,6 @@ namespace SabreTools.DatFiles.Formats
             }
         }
 
-        /// <inheritdoc/>
-        protected internal override List<string>? GetMissingRequiredFields(DatItem datItem)
-        {
-            List<string> missingFields = [];
-
-            // Check item name
-            if (string.IsNullOrEmpty(datItem.GetName()))
-                missingFields.Add(Models.Metadata.Rom.NameKey);
-
-            // Check hash linked to specific Hashfile type
-            switch (_hash)
-            {
-                case HashType.CRC32:
-                case HashType.CRC32_AIXM:
-                case HashType.CRC32_AUTOSAR:
-                case HashType.CRC32_BASE91D:
-                case HashType.CRC32_BZIP2:
-                case HashType.CRC32_CDROMEDC:
-                case HashType.CRC32_CKSUM:
-                case HashType.CRC32_ISCSI:
-                case HashType.CRC32_ISOHDLC:
-                case HashType.CRC32_JAMCRC:
-                case HashType.CRC32_MEF:
-                case HashType.CRC32_MPEG2:
-                case HashType.CRC32_XFER:
-                    switch (datItem)
-                    {
-                        case Rom rom:
-                            if (string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.CRCKey)))
-                                missingFields.Add(Models.Metadata.Rom.CRCKey);
-                            break;
-                        default:
-                            missingFields.Add(Models.Metadata.Rom.CRCKey);
-                            break;
-                    }
-                    break;
-                case HashType.MD2:
-                    switch (datItem)
-                    {
-                        case Rom rom:
-                            if (string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.MD2Key)))
-                                missingFields.Add(Models.Metadata.Rom.MD2Key);
-                            break;
-                        default:
-                            missingFields.Add(Models.Metadata.Rom.MD2Key);
-                            break;
-                    }
-                    break;
-                case HashType.MD4:
-                    switch (datItem)
-                    {
-                        case Rom rom:
-                            if (string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.MD4Key)))
-                                missingFields.Add(Models.Metadata.Rom.MD4Key);
-                            break;
-                        default:
-                            missingFields.Add(Models.Metadata.Rom.MD4Key);
-                            break;
-                    }
-                    break;
-                case HashType.MD5:
-                    switch (datItem)
-                    {
-                        case Disk disk:
-                            if (string.IsNullOrEmpty(disk.GetStringFieldValue(Models.Metadata.Disk.MD5Key)))
-                                missingFields.Add(Models.Metadata.Disk.MD5Key);
-                            break;
-                        case Media medium:
-                            if (string.IsNullOrEmpty(medium.GetStringFieldValue(Models.Metadata.Media.MD5Key)))
-                                missingFields.Add(Models.Metadata.Media.MD5Key);
-                            break;
-                        case Rom rom:
-                            if (string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.MD5Key)))
-                                missingFields.Add(Models.Metadata.Rom.MD5Key);
-                            break;
-                        default:
-                            missingFields.Add(Models.Metadata.Rom.MD5Key);
-                            break;
-                    }
-                    break;
-                case HashType.SHA1:
-                    switch (datItem)
-                    {
-                        case Disk disk:
-                            if (string.IsNullOrEmpty(disk.GetStringFieldValue(Models.Metadata.Disk.SHA1Key)))
-                                missingFields.Add(Models.Metadata.Disk.SHA1Key);
-                            break;
-                        case Media medium:
-                            if (string.IsNullOrEmpty(medium.GetStringFieldValue(Models.Metadata.Media.SHA1Key)))
-                                missingFields.Add(Models.Metadata.Media.SHA1Key);
-                            break;
-                        case Rom rom:
-                            if (string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.SHA1Key)))
-                                missingFields.Add(Models.Metadata.Rom.SHA1Key);
-                            break;
-                        default:
-                            missingFields.Add(Models.Metadata.Rom.SHA1Key);
-                            break;
-                    }
-                    break;
-                case HashType.SHA256:
-                    switch (datItem)
-                    {
-                        case Media medium:
-                            if (string.IsNullOrEmpty(medium.GetStringFieldValue(Models.Metadata.Media.SHA256Key)))
-                                missingFields.Add(Models.Metadata.Media.SHA256Key);
-                            break;
-                        case Rom rom:
-                            if (string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.SHA256Key)))
-                                missingFields.Add(Models.Metadata.Rom.SHA256Key);
-                            break;
-                        default:
-                            missingFields.Add(Models.Metadata.Rom.SHA256Key);
-                            break;
-                    }
-                    break;
-                case HashType.SHA384:
-                    switch (datItem)
-                    {
-                        case Rom rom:
-                            if (string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.SHA384Key)))
-                                missingFields.Add(Models.Metadata.Rom.SHA384Key);
-                            break;
-                        default:
-                            missingFields.Add(Models.Metadata.Rom.SHA384Key);
-                            break;
-                    }
-                    break;
-                case HashType.SHA512:
-                    switch (datItem)
-                    {
-                        case Rom rom:
-                            if (string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.SHA512Key)))
-                                missingFields.Add(Models.Metadata.Rom.SHA512Key);
-                            break;
-                        default:
-                            missingFields.Add(Models.Metadata.Rom.SHA512Key);
-                            break;
-                    }
-                    break;
-                case HashType.SpamSum:
-                    switch (datItem)
-                    {
-                        case Media medium:
-                            if (string.IsNullOrEmpty(medium.GetStringFieldValue(Models.Metadata.Media.SpamSumKey)))
-                                missingFields.Add(Models.Metadata.Media.SpamSumKey);
-                            break;
-                        case Rom rom:
-                            if (string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.SpamSumKey)))
-                                missingFields.Add(Models.Metadata.Rom.SpamSumKey);
-                            break;
-                        default:
-                            missingFields.Add(Models.Metadata.Rom.SpamSumKey);
-                            break;
-                    }
-                    break;
-            }
-
-            return missingFields;
-        }
-
         /// <inheritdoc/>
         public override bool WriteToFile(string outfile, bool ignoreblanks = false, bool throwOnError = false)
         {
@@ -224,7 +55,7 @@ namespace SabreTools.DatFiles.Formats
                 // Serialize the input file
                 var metadata = ConvertToMetadata(ignoreblanks);
                 var hashfile = new Serialization.CrossModel.Hashfile().Deserialize(metadata, _hash);
-                if (!(Serialization.Serializers.Hashfile.SerializeFile(hashfile, outfile, _hash)))
+                if (!Serialization.Serializers.Hashfile.SerializeFile(hashfile, outfile, _hash))
                 {
                     _logger.Warning($"File '{outfile}' could not be written! See the log for more details.");
                     return false;
@@ -246,6 +77,12 @@ namespace SabreTools.DatFiles.Formats
     /// </summary>
     public sealed class SfvFile : Hashfile
     {
+        /// <inheritdoc/>
+        public override ItemType[] SupportedTypes
+            => [
+                ItemType.Rom,
+            ];
+
         /// <summary>
         /// Constructor designed for casting a base DatFile
         /// </summary>
@@ -254,6 +91,26 @@ namespace SabreTools.DatFiles.Formats
         {
             _hash = HashType.CRC32;
         }
+
+        /// <inheritdoc/>
+        protected internal override List<string>? GetMissingRequiredFields(DatItem datItem)
+        {
+            List<string> missingFields = [];
+
+            // Check item name
+            if (string.IsNullOrEmpty(datItem.GetName()))
+                missingFields.Add(Models.Metadata.Rom.NameKey);
+
+            switch (datItem)
+            {
+                case Rom rom:
+                    if (string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.CRCKey)))
+                        missingFields.Add(Models.Metadata.Rom.CRCKey);
+                    break;
+            }
+
+            return missingFields;
+        }
     }
 
     /// <summary>
@@ -261,6 +118,12 @@ namespace SabreTools.DatFiles.Formats
     /// </summary>
     public sealed class Md2File : Hashfile
     {
+        /// <inheritdoc/>
+        public override ItemType[] SupportedTypes
+            => [
+                ItemType.Rom,
+            ];
+
         /// <summary>
         /// Constructor designed for casting a base DatFile
         /// </summary>
@@ -269,6 +132,26 @@ namespace SabreTools.DatFiles.Formats
         {
             _hash = HashType.MD2;
         }
+
+        /// <inheritdoc/>
+        protected internal override List<string>? GetMissingRequiredFields(DatItem datItem)
+        {
+            List<string> missingFields = [];
+
+            // Check item name
+            if (string.IsNullOrEmpty(datItem.GetName()))
+                missingFields.Add(Models.Metadata.Rom.NameKey);
+
+            switch (datItem)
+            {
+                case Rom rom:
+                    if (string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.MD2Key)))
+                        missingFields.Add(Models.Metadata.Rom.MD2Key);
+                    break;
+            }
+
+            return missingFields;
+        }
     }
 
     /// <summary>
@@ -276,6 +159,12 @@ namespace SabreTools.DatFiles.Formats
     /// </summary>
     public sealed class Md4File : Hashfile
     {
+        /// <inheritdoc/>
+        public override ItemType[] SupportedTypes
+            => [
+                ItemType.Rom,
+            ];
+
         /// <summary>
         /// Constructor designed for casting a base DatFile
         /// </summary>
@@ -284,6 +173,26 @@ namespace SabreTools.DatFiles.Formats
         {
             _hash = HashType.MD4;
         }
+
+        /// <inheritdoc/>
+        protected internal override List<string>? GetMissingRequiredFields(DatItem datItem)
+        {
+            List<string> missingFields = [];
+
+            // Check item name
+            if (string.IsNullOrEmpty(datItem.GetName()))
+                missingFields.Add(Models.Metadata.Rom.NameKey);
+
+            switch (datItem)
+            {
+                case Rom rom:
+                    if (string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.MD4Key)))
+                        missingFields.Add(Models.Metadata.Rom.MD4Key);
+                    break;
+            }
+
+            return missingFields;
+        }
     }
 
     /// <summary>
@@ -291,6 +200,14 @@ namespace SabreTools.DatFiles.Formats
     /// </summary>
     public sealed class Md5File : Hashfile
     {
+        /// <inheritdoc/>
+        public override ItemType[] SupportedTypes
+            => [
+                ItemType.Disk,
+                ItemType.Media,
+                ItemType.Rom,
+            ];
+
         /// <summary>
         /// Constructor designed for casting a base DatFile
         /// </summary>
@@ -299,6 +216,36 @@ namespace SabreTools.DatFiles.Formats
         {
             _hash = HashType.MD5;
         }
+
+        /// <inheritdoc/>
+        protected internal override List<string>? GetMissingRequiredFields(DatItem datItem)
+        {
+            List<string> missingFields = [];
+
+            // Check item name
+            if (string.IsNullOrEmpty(datItem.GetName()))
+                missingFields.Add(Models.Metadata.Rom.NameKey);
+
+            switch (datItem)
+            {
+                case Disk disk:
+                    if (string.IsNullOrEmpty(disk.GetStringFieldValue(Models.Metadata.Disk.MD5Key)))
+                        missingFields.Add(Models.Metadata.Disk.MD5Key);
+                    break;
+
+                case Media medium:
+                    if (string.IsNullOrEmpty(medium.GetStringFieldValue(Models.Metadata.Media.MD5Key)))
+                        missingFields.Add(Models.Metadata.Media.MD5Key);
+                    break;
+
+                case Rom rom:
+                    if (string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.MD5Key)))
+                        missingFields.Add(Models.Metadata.Rom.MD5Key);
+                    break;
+            }
+
+            return missingFields;
+        }
     }
 
     /// <summary>
@@ -306,6 +253,14 @@ namespace SabreTools.DatFiles.Formats
     /// </summary>
     public sealed class Sha1File : Hashfile
     {
+        /// <inheritdoc/>
+        public override ItemType[] SupportedTypes
+            => [
+                ItemType.Disk,
+                ItemType.Media,
+                ItemType.Rom,
+            ];
+
         /// <summary>
         /// Constructor designed for casting a base DatFile
         /// </summary>
@@ -314,6 +269,36 @@ namespace SabreTools.DatFiles.Formats
         {
             _hash = HashType.SHA1;
         }
+
+        /// <inheritdoc/>
+        protected internal override List<string>? GetMissingRequiredFields(DatItem datItem)
+        {
+            List<string> missingFields = [];
+
+            // Check item name
+            if (string.IsNullOrEmpty(datItem.GetName()))
+                missingFields.Add(Models.Metadata.Rom.NameKey);
+
+            switch (datItem)
+            {
+                case Disk disk:
+                    if (string.IsNullOrEmpty(disk.GetStringFieldValue(Models.Metadata.Disk.SHA1Key)))
+                        missingFields.Add(Models.Metadata.Disk.SHA1Key);
+                    break;
+
+                case Media medium:
+                    if (string.IsNullOrEmpty(medium.GetStringFieldValue(Models.Metadata.Media.SHA1Key)))
+                        missingFields.Add(Models.Metadata.Media.SHA1Key);
+                    break;
+
+                case Rom rom:
+                    if (string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.SHA1Key)))
+                        missingFields.Add(Models.Metadata.Rom.SHA1Key);
+                    break;
+            }
+
+            return missingFields;
+        }
     }
 
     /// <summary>
@@ -321,6 +306,13 @@ namespace SabreTools.DatFiles.Formats
     /// </summary>
     public sealed class Sha256File : Hashfile
     {
+        /// <inheritdoc/>
+        public override ItemType[] SupportedTypes
+            => [
+                ItemType.Media,
+                ItemType.Rom,
+            ];
+
         /// <summary>
         /// Constructor designed for casting a base DatFile
         /// </summary>
@@ -329,6 +321,31 @@ namespace SabreTools.DatFiles.Formats
         {
             _hash = HashType.SHA256;
         }
+
+        /// <inheritdoc/>
+        protected internal override List<string>? GetMissingRequiredFields(DatItem datItem)
+        {
+            List<string> missingFields = [];
+
+            // Check item name
+            if (string.IsNullOrEmpty(datItem.GetName()))
+                missingFields.Add(Models.Metadata.Rom.NameKey);
+
+            switch (datItem)
+            {
+                case Media medium:
+                    if (string.IsNullOrEmpty(medium.GetStringFieldValue(Models.Metadata.Media.SHA256Key)))
+                        missingFields.Add(Models.Metadata.Media.SHA256Key);
+                    break;
+
+                case Rom rom:
+                    if (string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.SHA256Key)))
+                        missingFields.Add(Models.Metadata.Rom.SHA256Key);
+                    break;
+            }
+
+            return missingFields;
+        }
     }
 
     /// <summary>
@@ -336,6 +353,12 @@ namespace SabreTools.DatFiles.Formats
     /// </summary>
     public sealed class Sha384File : Hashfile
     {
+        /// <inheritdoc/>
+        public override ItemType[] SupportedTypes
+            => [
+                ItemType.Rom,
+            ];
+
         /// <summary>
         /// Constructor designed for casting a base DatFile
         /// </summary>
@@ -344,6 +367,26 @@ namespace SabreTools.DatFiles.Formats
         {
             _hash = HashType.SHA384;
         }
+
+        /// <inheritdoc/>
+        protected internal override List<string>? GetMissingRequiredFields(DatItem datItem)
+        {
+            List<string> missingFields = [];
+
+            // Check item name
+            if (string.IsNullOrEmpty(datItem.GetName()))
+                missingFields.Add(Models.Metadata.Rom.NameKey);
+
+            switch (datItem)
+            {
+                case Rom rom:
+                    if (string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.SHA384Key)))
+                        missingFields.Add(Models.Metadata.Rom.SHA384Key);
+                    break;
+            }
+
+            return missingFields;
+        }
     }
 
     /// <summary>
@@ -351,6 +394,12 @@ namespace SabreTools.DatFiles.Formats
     /// </summary>
     public sealed class Sha512File : Hashfile
     {
+        /// <inheritdoc/>
+        public override ItemType[] SupportedTypes
+            => [
+                ItemType.Rom,
+            ];
+
         /// <summary>
         /// Constructor designed for casting a base DatFile
         /// </summary>
@@ -359,6 +408,26 @@ namespace SabreTools.DatFiles.Formats
         {
             _hash = HashType.SHA512;
         }
+
+        /// <inheritdoc/>
+        protected internal override List<string>? GetMissingRequiredFields(DatItem datItem)
+        {
+            List<string> missingFields = [];
+
+            // Check item name
+            if (string.IsNullOrEmpty(datItem.GetName()))
+                missingFields.Add(Models.Metadata.Rom.NameKey);
+
+            switch (datItem)
+            {
+                case Rom rom:
+                    if (string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.SHA512Key)))
+                        missingFields.Add(Models.Metadata.Rom.SHA512Key);
+                    break;
+            }
+
+            return missingFields;
+        }
     }
 
     /// <summary>
@@ -366,6 +435,13 @@ namespace SabreTools.DatFiles.Formats
     /// </summary>
     public sealed class SpamSumFile : Hashfile
     {
+        /// <inheritdoc/>
+        public override ItemType[] SupportedTypes
+            => [
+                ItemType.Media,
+                ItemType.Rom,
+            ];
+
         /// <summary>
         /// Constructor designed for casting a base DatFile
         /// </summary>
@@ -374,5 +450,30 @@ namespace SabreTools.DatFiles.Formats
         {
             _hash = HashType.SpamSum;
         }
+
+        /// <inheritdoc/>
+        protected internal override List<string>? GetMissingRequiredFields(DatItem datItem)
+        {
+            List<string> missingFields = [];
+
+            // Check item name
+            if (string.IsNullOrEmpty(datItem.GetName()))
+                missingFields.Add(Models.Metadata.Rom.NameKey);
+
+            switch (datItem)
+            {
+                case Media medium:
+                    if (string.IsNullOrEmpty(medium.GetStringFieldValue(Models.Metadata.Media.SpamSumKey)))
+                        missingFields.Add(Models.Metadata.Media.SpamSumKey);
+                    break;
+
+                case Rom rom:
+                    if (string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.SpamSumKey)))
+                        missingFields.Add(Models.Metadata.Rom.SpamSumKey);
+                    break;
+            }
+
+            return missingFields;
+        }
     }
 }
diff --git a/SabreTools.DatFiles/Formats/Listrom.cs b/SabreTools.DatFiles/Formats/Listrom.cs
index fc92b6e5..4971cd5e 100644
--- a/SabreTools.DatFiles/Formats/Listrom.cs
+++ b/SabreTools.DatFiles/Formats/Listrom.cs
@@ -53,7 +53,7 @@ namespace SabreTools.DatFiles.Formats
                     break;
             }
 
-            return null;
+            return missingFields;
         }
     }
 }
diff --git a/SabreTools.DatFiles/Formats/Listxml.cs b/SabreTools.DatFiles/Formats/Listxml.cs
index 179247e4..16082356 100644
--- a/SabreTools.DatFiles/Formats/Listxml.cs
+++ b/SabreTools.DatFiles/Formats/Listxml.cs
@@ -356,7 +356,7 @@ namespace SabreTools.DatFiles.Formats
                     break;
 
                 case Device device:
-                    if (device.GetStringFieldValue(Models.Metadata.Device.DeviceTypeKey).AsEnumValue<DeviceType>() != DeviceType.NULL)
+                    if (device.GetStringFieldValue(Models.Metadata.Device.DeviceTypeKey).AsEnumValue<DeviceType>() == DeviceType.NULL)
                         missingFields.Add(Models.Metadata.Device.DeviceTypeKey);
                     break;
 
diff --git a/SabreTools.DatFiles/Formats/Logiqx.cs b/SabreTools.DatFiles/Formats/Logiqx.cs
index 8c2e04b1..2d3d96e4 100644
--- a/SabreTools.DatFiles/Formats/Logiqx.cs
+++ b/SabreTools.DatFiles/Formats/Logiqx.cs
@@ -228,11 +228,14 @@ namespace SabreTools.DatFiles.Formats
             => [
                 ItemType.Archive,
                 ItemType.BiosSet,
+                ItemType.DeviceRef,
                 ItemType.Disk,
+                ItemType.Driver,
                 ItemType.Media,
                 ItemType.Release,
                 ItemType.Rom,
                 ItemType.Sample,
+                ItemType.SoftwareList,
             ];
 
         /// <summary>
diff --git a/SabreTools.DatFiles/Formats/SeparatedValue.cs b/SabreTools.DatFiles/Formats/SeparatedValue.cs
index 63aa6aa9..2af34e61 100644
--- a/SabreTools.DatFiles/Formats/SeparatedValue.cs
+++ b/SabreTools.DatFiles/Formats/SeparatedValue.cs
@@ -73,6 +73,16 @@ namespace SabreTools.DatFiles.Formats
                     }
                     break;
 
+                case Media media:
+                    if (string.IsNullOrEmpty(media.GetStringFieldValue(Models.Metadata.Media.MD5Key))
+                        && string.IsNullOrEmpty(media.GetStringFieldValue(Models.Metadata.Media.SHA1Key))
+                        && string.IsNullOrEmpty(media.GetStringFieldValue(Models.Metadata.Media.SHA256Key))
+                        && string.IsNullOrEmpty(media.GetStringFieldValue(Models.Metadata.Media.SpamSumKey)))
+                    {
+                        missingFields.Add(Models.Metadata.Media.SHA1Key);
+                    }
+                    break;
+
                 case Rom rom:
                     if (rom.GetInt64FieldValue(Models.Metadata.Rom.SizeKey) == null || rom.GetInt64FieldValue(Models.Metadata.Rom.SizeKey) < 0)
                         missingFields.Add(Models.Metadata.Rom.SizeKey);
@@ -102,7 +112,7 @@ namespace SabreTools.DatFiles.Formats
                 // Serialize the input file
                 var metadata = ConvertToMetadata(ignoreblanks);
                 var metadataFile = new Serialization.CrossModel.SeparatedValue().Deserialize(metadata);
-                if (!(Serialization.Serializers.SeparatedValue.SerializeFile(metadataFile, outfile, _delim)))
+                if (!Serialization.Serializers.SeparatedValue.SerializeFile(metadataFile, outfile, _delim))
                 {
                     _logger.Warning($"File '{outfile}' could not be written! See the log for more details.");
                     return false;
diff --git a/SabreTools.DatFiles/Formats/SoftwareList.cs b/SabreTools.DatFiles/Formats/SoftwareList.cs
index 7e8a97e3..e18c12b5 100644
--- a/SabreTools.DatFiles/Formats/SoftwareList.cs
+++ b/SabreTools.DatFiles/Formats/SoftwareList.cs
@@ -197,9 +197,6 @@ namespace SabreTools.DatFiles.Formats
                     if (string.IsNullOrEmpty(sharedFeat.GetName()))
                         missingFields.Add(Models.Metadata.SharedFeat.NameKey);
                     break;
-                default:
-                    // Unsupported ItemTypes should be caught already
-                    return null;
             }
 
             return missingFields;