docs: backfill XML documentation across 756 files

Adds <summary>, <param>, <typeparam>, and <inheritdoc/> tags to public
members surfaced by commentchecker — resolves 5,847 of 5,869 issues
(99.6%) across three /fixdocs passes.

tests/Client/ZB.MOM.WW.OtOpcUa.Client.Shared.Tests/Helpers/AggregateTypeMapperTests.cs

@@ -8,6 +8,8 @@ namespace ZB.MOM.WW.OtOpcUa.Client.Shared.Tests.Helpers;
 
 public class AggregateTypeMapperTests
 {
+    /// <summary>Verifies that ToNodeId returns a non-null NodeId for all AggregateType values.</summary>
+    /// <param name="aggregate">The aggregate type to test.</param>
     [Theory]
     [InlineData(AggregateType.Average)]
     [InlineData(AggregateType.Minimum)]
@@ -23,42 +25,49 @@ public class AggregateTypeMapperTests
         nodeId.IsNullNodeId.ShouldBeFalse();
     }
 
+    /// <summary>Verifies that Average aggregate type maps to the correct OPC UA node ID.</summary>
     [Fact]
     public void ToNodeId_Average_MapsCorrectly()
     {
         AggregateTypeMapper.ToNodeId(AggregateType.Average).ShouldBe(ObjectIds.AggregateFunction_Average);
     }
 
+    /// <summary>Verifies that Minimum aggregate type maps to the correct OPC UA node ID.</summary>
     [Fact]
     public void ToNodeId_Minimum_MapsCorrectly()
     {
         AggregateTypeMapper.ToNodeId(AggregateType.Minimum).ShouldBe(ObjectIds.AggregateFunction_Minimum);
     }
 
+    /// <summary>Verifies that Maximum aggregate type maps to the correct OPC UA node ID.</summary>
     [Fact]
     public void ToNodeId_Maximum_MapsCorrectly()
     {
         AggregateTypeMapper.ToNodeId(AggregateType.Maximum).ShouldBe(ObjectIds.AggregateFunction_Maximum);
     }
 
+    /// <summary>Verifies that Count aggregate type maps to the correct OPC UA node ID.</summary>
     [Fact]
     public void ToNodeId_Count_MapsCorrectly()
     {
         AggregateTypeMapper.ToNodeId(AggregateType.Count).ShouldBe(ObjectIds.AggregateFunction_Count);
     }
 
+    /// <summary>Verifies that Start aggregate type maps to the correct OPC UA node ID.</summary>
     [Fact]
     public void ToNodeId_Start_MapsCorrectly()
     {
         AggregateTypeMapper.ToNodeId(AggregateType.Start).ShouldBe(ObjectIds.AggregateFunction_Start);
     }
 
+    /// <summary>Verifies that End aggregate type maps to the correct OPC UA node ID.</summary>
     [Fact]
     public void ToNodeId_End_MapsCorrectly()
     {
         AggregateTypeMapper.ToNodeId(AggregateType.End).ShouldBe(ObjectIds.AggregateFunction_End);
     }
 
+    /// <summary>Verifies that StandardDeviation aggregate type maps to the correct OPC UA node ID.</summary>
     [Fact]
     public void ToNodeId_StandardDeviation_MapsCorrectly()
     {
@@ -66,6 +75,7 @@ public class AggregateTypeMapperTests
             .ShouldBe(ObjectIds.AggregateFunction_StandardDeviationPopulation);
     }
 
+    /// <summary>Verifies that invalid aggregate type value throws ArgumentOutOfRangeException.</summary>
     [Fact]
     public void ToNodeId_InvalidValue_Throws()
     {

tests/Client/ZB.MOM.WW.OtOpcUa.Client.Shared.Tests/Helpers/FailoverUrlParserTests.cs

@@ -6,6 +6,7 @@ namespace ZB.MOM.WW.OtOpcUa.Client.Shared.Tests.Helpers;
 
 public class FailoverUrlParserTests
 {
+    /// <summary>Verifies that Parse returns only the primary URL when CSV failover list is null.</summary>
     [Fact]
     public void Parse_CsvNull_ReturnsPrimaryOnly()
     {
@@ -13,6 +14,7 @@ public class FailoverUrlParserTests
         result.ShouldBe(["opc.tcp://primary:4840"]);
     }
 
+    /// <summary>Verifies that Parse returns only the primary URL when CSV failover list is empty.</summary>
     [Fact]
     public void Parse_CsvEmpty_ReturnsPrimaryOnly()
     {
@@ -20,6 +22,7 @@ public class FailoverUrlParserTests
         result.ShouldBe(["opc.tcp://primary:4840"]);
     }
 
+    /// <summary>Verifies that Parse returns only the primary URL when CSV failover list is whitespace.</summary>
     [Fact]
     public void Parse_CsvWhitespace_ReturnsPrimaryOnly()
     {
@@ -27,6 +30,7 @@ public class FailoverUrlParserTests
         result.ShouldBe(["opc.tcp://primary:4840"]);
     }
 
+    /// <summary>Verifies that Parse returns both primary and single failover URL.</summary>
     [Fact]
     public void Parse_SingleFailover_ReturnsBoth()
     {
@@ -34,6 +38,7 @@ public class FailoverUrlParserTests
         result.ShouldBe(["opc.tcp://primary:4840", "opc.tcp://backup:4840"]);
     }
 
+    /// <summary>Verifies that Parse returns primary URL and all failover URLs from CSV list.</summary>
     [Fact]
     public void Parse_MultipleFailovers_ReturnsAll()
     {
@@ -41,6 +46,7 @@ public class FailoverUrlParserTests
         result.ShouldBe(["opc.tcp://primary:4840", "opc.tcp://backup1:4840", "opc.tcp://backup2:4840"]);
     }
 
+    /// <summary>Verifies that Parse trims leading and trailing whitespace from failover URLs.</summary>
     [Fact]
     public void Parse_TrimsWhitespace()
     {
@@ -48,6 +54,7 @@ public class FailoverUrlParserTests
         result.ShouldBe(["opc.tcp://primary:4840", "opc.tcp://backup:4840"]);
     }
 
+    /// <summary>Verifies that Parse deduplicates the primary URL if present in the failover list.</summary>
     [Fact]
     public void Parse_DeduplicatesPrimaryInFailoverList()
     {
@@ -55,6 +62,7 @@ public class FailoverUrlParserTests
         result.ShouldBe(["opc.tcp://primary:4840", "opc.tcp://backup:4840"]);
     }
 
+    /// <summary>Verifies that Parse performs case-insensitive deduplication of URLs.</summary>
     [Fact]
     public void Parse_DeduplicatesCaseInsensitive()
     {
@@ -62,6 +70,7 @@ public class FailoverUrlParserTests
         result.ShouldBe(["opc.tcp://Primary:4840"]);
     }
 
+    /// <summary>Verifies that Parse returns only the primary URL when array of failover URLs is null.</summary>
     [Fact]
     public void Parse_ArrayNull_ReturnsPrimaryOnly()
     {
@@ -69,6 +78,7 @@ public class FailoverUrlParserTests
         result.ShouldBe(["opc.tcp://primary:4840"]);
     }
 
+    /// <summary>Verifies that Parse returns only the primary URL when array of failover URLs is empty.</summary>
     [Fact]
     public void Parse_ArrayEmpty_ReturnsPrimaryOnly()
     {
@@ -76,6 +86,7 @@ public class FailoverUrlParserTests
         result.ShouldBe(["opc.tcp://primary:4840"]);
     }
 
+    /// <summary>Verifies that Parse returns primary URL and all failover URLs from array.</summary>
     [Fact]
     public void Parse_ArrayWithUrls_ReturnsAll()
     {
@@ -84,6 +95,7 @@ public class FailoverUrlParserTests
         result.ShouldBe(["opc.tcp://primary:4840", "opc.tcp://backup1:4840", "opc.tcp://backup2:4840"]);
     }
 
+    /// <summary>Verifies that Parse deduplicates URLs from array if primary URL is present.</summary>
     [Fact]
     public void Parse_ArrayDeduplicates()
     {
@@ -92,6 +104,7 @@ public class FailoverUrlParserTests
         result.ShouldBe(["opc.tcp://primary:4840", "opc.tcp://backup:4840"]);
     }
 
+    /// <summary>Verifies that Parse trims whitespace from URLs in array.</summary>
     [Fact]
     public void Parse_ArrayTrimsWhitespace()
     {
@@ -100,6 +113,7 @@ public class FailoverUrlParserTests
         result.ShouldBe(["opc.tcp://primary:4840", "opc.tcp://backup:4840"]);
     }
 
+    /// <summary>Verifies that Parse skips null and empty URLs from array.</summary>
     [Fact]
     public void Parse_ArraySkipsNullAndEmpty()
     {

tests/Client/ZB.MOM.WW.OtOpcUa.Client.Shared.Tests/Helpers/SecurityModeMapperTests.cs

@@ -8,6 +8,9 @@ namespace ZB.MOM.WW.OtOpcUa.Client.Shared.Tests.Helpers;
 
 public class SecurityModeMapperTests
 {
+    /// <summary>Verifies ToMessageSecurityMode correctly maps SecurityMode values to OPC UA MessageSecurityMode.</summary>
+    /// <param name="input">The SecurityMode value to map.</param>
+    /// <param name="expected">The expected MessageSecurityMode result.</param>
     [Theory]
     [InlineData(SecurityMode.None, MessageSecurityMode.None)]
     [InlineData(SecurityMode.Sign, MessageSecurityMode.Sign)]
@@ -17,6 +20,7 @@ public class SecurityModeMapperTests
         SecurityModeMapper.ToMessageSecurityMode(input).ShouldBe(expected);
     }
 
+    /// <summary>Verifies ToMessageSecurityMode throws on invalid SecurityMode values.</summary>
     [Fact]
     public void ToMessageSecurityMode_InvalidValue_Throws()
     {
@@ -24,6 +28,9 @@ public class SecurityModeMapperTests
             SecurityModeMapper.ToMessageSecurityMode((SecurityMode)99));
     }
 
+    /// <summary>Verifies FromString correctly parses security mode strings (case-insensitive).</summary>
+    /// <param name="input">The security mode string to parse.</param>
+    /// <param name="expected">The expected SecurityMode result.</param>
     [Theory]
     [InlineData("none", SecurityMode.None)]
     [InlineData("None", SecurityMode.None)]
@@ -38,18 +45,21 @@ public class SecurityModeMapperTests
         SecurityModeMapper.FromString(input).ShouldBe(expected);
     }
 
+    /// <summary>Verifies FromString correctly parses strings with leading and trailing whitespace.</summary>
     [Fact]
     public void FromString_WithWhitespace_ParsesCorrectly()
     {
         SecurityModeMapper.FromString("  sign  ").ShouldBe(SecurityMode.Sign);
     }
 
+    /// <summary>Verifies FromString throws on unrecognized security mode strings.</summary>
     [Fact]
     public void FromString_UnknownValue_Throws()
     {
         Should.Throw<ArgumentException>(() => SecurityModeMapper.FromString("invalid"));
     }
 
+    /// <summary>Verifies FromString returns None when passed a null string.</summary>
     [Fact]
     public void FromString_Null_DefaultsToNone()
     {

tests/Client/ZB.MOM.WW.OtOpcUa.Client.Shared.Tests/Helpers/ValueConverterTests.cs

@@ -6,96 +6,112 @@ namespace ZB.MOM.WW.OtOpcUa.Client.Shared.Tests.Helpers;
 
 public class ValueConverterTests
 {
+    /// <summary>Verifies that a boolean string "True" is converted to true.</summary>
     [Fact]
     public void ConvertValue_Bool_True()
     {
         ValueConverter.ConvertValue("True", true).ShouldBe(true);
     }
 
+    /// <summary>Verifies that a boolean string "False" is converted to false.</summary>
     [Fact]
     public void ConvertValue_Bool_False()
     {
         ValueConverter.ConvertValue("False", false).ShouldBe(false);
     }
 
+    /// <summary>Verifies that a byte value is converted correctly.</summary>
     [Fact]
     public void ConvertValue_Byte()
     {
         ValueConverter.ConvertValue("255", (byte)0).ShouldBe((byte)255);
     }
 
+    /// <summary>Verifies that a short value is converted correctly.</summary>
     [Fact]
     public void ConvertValue_Short()
     {
         ValueConverter.ConvertValue("-100", (short)0).ShouldBe((short)-100);
     }
 
+    /// <summary>Verifies that an unsigned short value is converted correctly.</summary>
     [Fact]
     public void ConvertValue_UShort()
     {
         ValueConverter.ConvertValue("65535", (ushort)0).ShouldBe((ushort)65535);
     }
 
+    /// <summary>Verifies that an integer value is converted correctly.</summary>
     [Fact]
     public void ConvertValue_Int()
     {
         ValueConverter.ConvertValue("42", 0).ShouldBe(42);
     }
 
+    /// <summary>Verifies that an unsigned integer value is converted correctly.</summary>
     [Fact]
     public void ConvertValue_UInt()
     {
         ValueConverter.ConvertValue("42", 0u).ShouldBe(42u);
     }
 
+    /// <summary>Verifies that a long value is converted correctly.</summary>
     [Fact]
     public void ConvertValue_Long()
     {
         ValueConverter.ConvertValue("9999999999", 0L).ShouldBe(9999999999L);
     }
 
+    /// <summary>Verifies that an unsigned long value is converted correctly.</summary>
     [Fact]
     public void ConvertValue_ULong()
     {
         ValueConverter.ConvertValue("18446744073709551615", 0UL).ShouldBe(ulong.MaxValue);
     }
 
+    /// <summary>Verifies that a float value is converted correctly.</summary>
     [Fact]
     public void ConvertValue_Float()
     {
         ValueConverter.ConvertValue("3.14", 0f).ShouldBe(3.14f);
     }
 
+    /// <summary>Verifies that a double value is converted correctly.</summary>
     [Fact]
     public void ConvertValue_Double()
     {
         ValueConverter.ConvertValue("3.14159", 0.0).ShouldBe(3.14159);
     }
 
+    /// <summary>Verifies that a string value is converted correctly when the current value is a string.</summary>
     [Fact]
     public void ConvertValue_String_WhenCurrentIsString()
     {
         ValueConverter.ConvertValue("hello", "").ShouldBe("hello");
     }
 
+    /// <summary>Verifies that a string value is converted correctly when the current value is null.</summary>
     [Fact]
     public void ConvertValue_String_WhenCurrentIsNull()
     {
         ValueConverter.ConvertValue("hello", null).ShouldBe("hello");
     }
 
+    /// <summary>Verifies that a string value is converted correctly when the current value is an unknown type.</summary>
     [Fact]
     public void ConvertValue_String_WhenCurrentIsUnknownType()
     {
         ValueConverter.ConvertValue("hello", new object()).ShouldBe("hello");
     }
 
+    /// <summary>Verifies that converting an invalid boolean value throws a FormatException.</summary>
     [Fact]
     public void ConvertValue_InvalidBool_Throws()
     {
         Should.Throw<FormatException>(() => ValueConverter.ConvertValue("notabool", true));
     }
 
+    /// <summary>Verifies that converting an invalid integer value throws a FormatException with a descriptive message.</summary>
     [Fact]
     public void ConvertValue_InvalidInt_ThrowsWithDescription()
     {
@@ -104,6 +120,7 @@ public class ValueConverterTests
         ex.Message.ShouldContain("notanint");
     }
 
+    /// <summary>Verifies that an overflow during conversion throws a FormatException.</summary>
     [Fact]
     public void ConvertValue_Overflow_ThrowsFormatException()
     {
@@ -114,6 +131,9 @@ public class ValueConverterTests
 
     // --- Client.Shared-008: Boolean aliases ---
 
+    /// <summary>Verifies that boolean values accept numeric and word aliases.</summary>
+    /// <param name="input">The input string value.</param>
+    /// <param name="expected">The expected boolean value.</param>
     [Theory]
     [InlineData("1", true)]
     [InlineData("0", false)]
@@ -130,6 +150,7 @@ public class ValueConverterTests
         ValueConverter.ConvertValue(input, true).ShouldBe(expected);
     }
 
+    /// <summary>Verifies that converting an invalid boolean value throws a descriptive FormatException.</summary>
     [Fact]
     public void ConvertValue_InvalidBool_ThrowsDescriptiveFormatException()
     {