diff --git a/src/ZWave.CommandClasses.Tests/WindowCoveringCommandClassTests.LevelChange.cs b/src/ZWave.CommandClasses.Tests/WindowCoveringCommandClassTests.LevelChange.cs
new file mode 100644
index 0000000..0140dd7
--- /dev/null
+++ b/src/ZWave.CommandClasses.Tests/WindowCoveringCommandClassTests.LevelChange.cs
@@ -0,0 +1,115 @@
+namespace ZWave.CommandClasses.Tests;
+
+public partial class WindowCoveringCommandClassTests
+{
+    [TestMethod]
+    public void StartLevelChangeCommand_Create_Up()
+    {
+        WindowCoveringCommandClass.WindowCoveringStartLevelChangeCommand command =
+            WindowCoveringCommandClass.WindowCoveringStartLevelChangeCommand.Create(
+                direction: WindowCoveringChangeDirection.Up,
+                parameterId: WindowCoveringParameterId.OutboundBottomPosition,
+                duration: new DurationSet(TimeSpan.FromSeconds(10)));
+
+        Assert.AreEqual(CommandClassId.WindowCovering, WindowCoveringCommandClass.WindowCoveringStartLevelChangeCommand.CommandClassId);
+        Assert.AreEqual((byte)WindowCoveringCommand.StartLevelChange, WindowCoveringCommandClass.WindowCoveringStartLevelChangeCommand.CommandId);
+
+        ReadOnlySpan<byte> parameters = command.Frame.CommandParameters.Span;
+        Assert.AreEqual(3, parameters.Length);
+        // Bit 6 = 0 (Up), all other bits reserved = 0
+        Assert.AreEqual(0b0000_0000, parameters[0]);
+        // Parameter ID = OutboundBottomPosition (0x0D)
+        Assert.AreEqual((byte)WindowCoveringParameterId.OutboundBottomPosition, parameters[1]);
+        // Duration = 10 seconds
+        Assert.AreEqual(0x0A, parameters[2]);
+    }
+
+    [TestMethod]
+    public void StartLevelChangeCommand_Create_Down()
+    {
+        WindowCoveringCommandClass.WindowCoveringStartLevelChangeCommand command =
+            WindowCoveringCommandClass.WindowCoveringStartLevelChangeCommand.Create(
+                direction: WindowCoveringChangeDirection.Down,
+                parameterId: WindowCoveringParameterId.OutboundLeftPosition,
+                duration: new DurationSet(TimeSpan.FromSeconds(5)));
+
+        ReadOnlySpan<byte> parameters = command.Frame.CommandParameters.Span;
+        Assert.AreEqual(3, parameters.Length);
+        // Bit 6 = 1 (Down)
+        Assert.AreEqual(0b0100_0000, parameters[0]);
+        Assert.AreEqual((byte)WindowCoveringParameterId.OutboundLeftPosition, parameters[1]);
+        Assert.AreEqual(0x05, parameters[2]);
+    }
+
+    [TestMethod]
+    public void StartLevelChangeCommand_Create_MovementParameter()
+    {
+        WindowCoveringCommandClass.WindowCoveringStartLevelChangeCommand command =
+            WindowCoveringCommandClass.WindowCoveringStartLevelChangeCommand.Create(
+                direction: WindowCoveringChangeDirection.Up,
+                parameterId: WindowCoveringParameterId.OutboundLeftMovement,
+                duration: new DurationSet(0x0A));
+
+        ReadOnlySpan<byte> parameters = command.Frame.CommandParameters.Span;
+        Assert.AreEqual((byte)WindowCoveringParameterId.OutboundLeftMovement, parameters[1]);
+    }
+
+    [TestMethod]
+    public void StartLevelChangeCommand_Create_ReservedBitsAreZero()
+    {
+        WindowCoveringCommandClass.WindowCoveringStartLevelChangeCommand command =
+            WindowCoveringCommandClass.WindowCoveringStartLevelChangeCommand.Create(
+                direction: WindowCoveringChangeDirection.Down,
+                parameterId: WindowCoveringParameterId.OutboundBottomPosition,
+                duration: new DurationSet(0x05));
+
+        ReadOnlySpan<byte> parameters = command.Frame.CommandParameters.Span;
+        // Bit 7 (reserved) must be 0, Bits 5-0 (reserved) must be 0
+        Assert.AreEqual(0x00, parameters[0] & 0b1000_0000); // bit 7 reserved
+        Assert.AreEqual(0x00, parameters[0] & 0b0011_1111); // bits 5-0 reserved
+    }
+
+    [TestMethod]
+    public void StartLevelChangeCommand_Create_FactoryDefaultDuration()
+    {
+        WindowCoveringCommandClass.WindowCoveringStartLevelChangeCommand command =
+            WindowCoveringCommandClass.WindowCoveringStartLevelChangeCommand.Create(
+                direction: WindowCoveringChangeDirection.Up,
+                parameterId: WindowCoveringParameterId.InboundTopBottomPosition,
+                duration: DurationSet.FactoryDefault);
+
+        ReadOnlySpan<byte> parameters = command.Frame.CommandParameters.Span;
+        Assert.AreEqual(0xFF, parameters[2]); // Factory default
+    }
+
+    [TestMethod]
+    public void StopLevelChangeCommand_Create_HasCorrectFormat()
+    {
+        WindowCoveringCommandClass.WindowCoveringStopLevelChangeCommand command =
+            WindowCoveringCommandClass.WindowCoveringStopLevelChangeCommand.Create(WindowCoveringParameterId.OutboundBottomPosition);
+
+        Assert.AreEqual(CommandClassId.WindowCovering, WindowCoveringCommandClass.WindowCoveringStopLevelChangeCommand.CommandClassId);
+        Assert.AreEqual((byte)WindowCoveringCommand.StopLevelChange, WindowCoveringCommandClass.WindowCoveringStopLevelChangeCommand.CommandId);
+        Assert.AreEqual(3, command.Frame.Data.Length);
+        Assert.AreEqual((byte)WindowCoveringParameterId.OutboundBottomPosition, command.Frame.CommandParameters.Span[0]);
+    }
+
+    [TestMethod]
+    public void StopLevelChangeCommand_Create_MovementParameter()
+    {
+        WindowCoveringCommandClass.WindowCoveringStopLevelChangeCommand command =
+            WindowCoveringCommandClass.WindowCoveringStopLevelChangeCommand.Create(WindowCoveringParameterId.OutboundLeftMovement);
+
+        Assert.AreEqual(3, command.Frame.Data.Length);
+        Assert.AreEqual((byte)WindowCoveringParameterId.OutboundLeftMovement, command.Frame.CommandParameters.Span[0]);
+    }
+
+    [TestMethod]
+    public void StopLevelChangeCommand_Create_SlatsAngle()
+    {
+        WindowCoveringCommandClass.WindowCoveringStopLevelChangeCommand command =
+            WindowCoveringCommandClass.WindowCoveringStopLevelChangeCommand.Create(WindowCoveringParameterId.HorizontalSlatsAnglePosition);
+
+        Assert.AreEqual((byte)WindowCoveringParameterId.HorizontalSlatsAnglePosition, command.Frame.CommandParameters.Span[0]);
+    }
+}
diff --git a/src/ZWave.CommandClasses.Tests/WindowCoveringCommandClassTests.Report.cs b/src/ZWave.CommandClasses.Tests/WindowCoveringCommandClassTests.Report.cs
new file mode 100644
index 0000000..689a409
--- /dev/null
+++ b/src/ZWave.CommandClasses.Tests/WindowCoveringCommandClassTests.Report.cs
@@ -0,0 +1,242 @@
+using Microsoft.Extensions.Logging.Abstractions;
+
+namespace ZWave.CommandClasses.Tests;
+
+public partial class WindowCoveringCommandClassTests
+{
+    [TestMethod]
+    public void GetCommand_Create_HasCorrectFormat()
+    {
+        WindowCoveringCommandClass.WindowCoveringGetCommand command =
+            WindowCoveringCommandClass.WindowCoveringGetCommand.Create(WindowCoveringParameterId.OutboundLeftPosition);
+
+        Assert.AreEqual(CommandClassId.WindowCovering, WindowCoveringCommandClass.WindowCoveringGetCommand.CommandClassId);
+        Assert.AreEqual((byte)WindowCoveringCommand.Get, WindowCoveringCommandClass.WindowCoveringGetCommand.CommandId);
+        Assert.AreEqual(3, command.Frame.Data.Length);
+        Assert.AreEqual((byte)WindowCoveringParameterId.OutboundLeftPosition, command.Frame.CommandParameters.Span[0]);
+    }
+
+    [TestMethod]
+    public void GetCommand_Create_MovementParameter()
+    {
+        WindowCoveringCommandClass.WindowCoveringGetCommand command =
+            WindowCoveringCommandClass.WindowCoveringGetCommand.Create(WindowCoveringParameterId.OutboundLeftMovement);
+
+        Assert.AreEqual(3, command.Frame.Data.Length);
+        Assert.AreEqual((byte)WindowCoveringParameterId.OutboundLeftMovement, command.Frame.CommandParameters.Span[0]);
+    }
+
+    [TestMethod]
+    public void GetCommand_Create_SlatsAngle()
+    {
+        WindowCoveringCommandClass.WindowCoveringGetCommand command =
+            WindowCoveringCommandClass.WindowCoveringGetCommand.Create(WindowCoveringParameterId.HorizontalSlatsAnglePosition);
+
+        Assert.AreEqual((byte)WindowCoveringParameterId.HorizontalSlatsAnglePosition, command.Frame.CommandParameters.Span[0]);
+    }
+
+    [TestMethod]
+    public void Report_Parse_PositionParameter()
+    {
+        // CC=0x6A, Cmd=0x04, ParameterId=0x01 (OutboundLeftPosition), Current=0x32, Target=0x63, Duration=0x05
+        byte[] data = [0x6A, 0x04, 0x01, 0x32, 0x63, 0x05];
+        CommandClassFrame frame = new(data);
+
+        WindowCoveringReport report = WindowCoveringCommandClass.WindowCoveringReportCommand.Parse(frame, NullLogger.Instance);
+
+        Assert.AreEqual(WindowCoveringParameterId.OutboundLeftPosition, report.ParameterId);
+        Assert.AreEqual((byte)0x32, report.CurrentValue);
+        Assert.AreEqual((byte)0x63, report.TargetValue);
+        Assert.AreEqual((byte)0x05, report.Duration.Value);
+        Assert.AreEqual(TimeSpan.FromSeconds(5), report.Duration.Duration);
+    }
+
+    [TestMethod]
+    public void Report_Parse_MovementParameter_Stationary()
+    {
+        // Even parameter, not moving: Current=0x00, Target=0x00, Duration=0xFE (unknown)
+        byte[] data = [0x6A, 0x04, 0x00, 0x00, 0x00, 0xFE];
+        CommandClassFrame frame = new(data);
+
+        WindowCoveringReport report = WindowCoveringCommandClass.WindowCoveringReportCommand.Parse(frame, NullLogger.Instance);
+
+        Assert.AreEqual(WindowCoveringParameterId.OutboundLeftMovement, report.ParameterId);
+        Assert.AreEqual((byte)0x00, report.CurrentValue);
+        Assert.AreEqual((byte)0x00, report.TargetValue);
+        Assert.AreEqual((byte)0xFE, report.Duration.Value);
+        Assert.IsNull(report.Duration.Duration);
+    }
+
+    [TestMethod]
+    public void Report_Parse_FullyOpen()
+    {
+        // Position parameter, fully open, transition complete
+        byte[] data = [0x6A, 0x04, 0x0D, 0x63, 0x63, 0x00];
+        CommandClassFrame frame = new(data);
+
+        WindowCoveringReport report = WindowCoveringCommandClass.WindowCoveringReportCommand.Parse(frame, NullLogger.Instance);
+
+        Assert.AreEqual(WindowCoveringParameterId.OutboundBottomPosition, report.ParameterId);
+        Assert.AreEqual((byte)0x63, report.CurrentValue);
+        Assert.AreEqual((byte)0x63, report.TargetValue);
+        Assert.AreEqual(TimeSpan.Zero, report.Duration.Duration);
+    }
+
+    [TestMethod]
+    public void Report_Parse_FullyClosed()
+    {
+        byte[] data = [0x6A, 0x04, 0x0D, 0x00, 0x00, 0x00];
+        CommandClassFrame frame = new(data);
+
+        WindowCoveringReport report = WindowCoveringCommandClass.WindowCoveringReportCommand.Parse(frame, NullLogger.Instance);
+
+        Assert.AreEqual((byte)0x00, report.CurrentValue);
+        Assert.AreEqual((byte)0x00, report.TargetValue);
+    }
+
+    [TestMethod]
+    public void Report_Parse_SlatsAngle_MidPosition()
+    {
+        // Vertical slats angle at open (0x32)
+        byte[] data = [0x6A, 0x04, 0x0B, 0x32, 0x32, 0x00];
+        CommandClassFrame frame = new(data);
+
+        WindowCoveringReport report = WindowCoveringCommandClass.WindowCoveringReportCommand.Parse(frame, NullLogger.Instance);
+
+        Assert.AreEqual(WindowCoveringParameterId.VerticalSlatsAnglePosition, report.ParameterId);
+        Assert.AreEqual((byte)0x32, report.CurrentValue);
+    }
+
+    [TestMethod]
+    public void Report_Parse_DurationInMinutes()
+    {
+        // Duration=0x82 (3 minutes per Table 2.10: 0x80=1min, 0x81=2min, 0x82=3min)
+        byte[] data = [0x6A, 0x04, 0x01, 0x00, 0x63, 0x82];
+        CommandClassFrame frame = new(data);
+
+        WindowCoveringReport report = WindowCoveringCommandClass.WindowCoveringReportCommand.Parse(frame, NullLogger.Instance);
+
+        Assert.AreEqual((byte)0x82, report.Duration.Value);
+        Assert.AreEqual(TimeSpan.FromMinutes(3), report.Duration.Duration);
+    }
+
+    [TestMethod]
+    public void Report_Parse_TooShort_Throws()
+    {
+        // Only 3 parameter bytes (need 4: paramId, current, target, duration)
+        byte[] data = [0x6A, 0x04, 0x01, 0x32, 0x63];
+        CommandClassFrame frame = new(data);
+
+        Assert.Throws<ZWaveException>(
+            () => WindowCoveringCommandClass.WindowCoveringReportCommand.Parse(frame, NullLogger.Instance));
+    }
+
+    [TestMethod]
+    public void Report_Parse_NoParameters_Throws()
+    {
+        byte[] data = [0x6A, 0x04];
+        CommandClassFrame frame = new(data);
+
+        Assert.Throws<ZWaveException>(
+            () => WindowCoveringCommandClass.WindowCoveringReportCommand.Parse(frame, NullLogger.Instance));
+    }
+
+    [TestMethod]
+    public void SetCommand_Create_SingleParameter()
+    {
+        Dictionary<WindowCoveringParameterId, byte> values = new()
+        {
+            { WindowCoveringParameterId.OutboundLeftPosition, 0x63 },
+        };
+        DurationSet duration = new DurationSet(TimeSpan.FromSeconds(5));
+
+        WindowCoveringCommandClass.WindowCoveringSetCommand command =
+            WindowCoveringCommandClass.WindowCoveringSetCommand.Create(values, duration);
+
+        Assert.AreEqual(CommandClassId.WindowCovering, WindowCoveringCommandClass.WindowCoveringSetCommand.CommandClassId);
+        Assert.AreEqual((byte)WindowCoveringCommand.Set, WindowCoveringCommandClass.WindowCoveringSetCommand.CommandId);
+
+        ReadOnlySpan<byte> parameters = command.Frame.CommandParameters.Span;
+        // 1 (count) + 2 (paramId+value) + 1 (duration) = 4 bytes
+        Assert.AreEqual(4, parameters.Length);
+        // Parameter count = 1
+        Assert.AreEqual(0x01, parameters[0] & 0b0001_1111);
+        // Reserved bits must be 0
+        Assert.AreEqual(0x00, parameters[0] & 0b1110_0000);
+        // Parameter ID = OutboundLeftPosition (0x01)
+        Assert.AreEqual((byte)WindowCoveringParameterId.OutboundLeftPosition, parameters[1]);
+        // Value = 0x63
+        Assert.AreEqual(0x63, parameters[2]);
+        // Duration = 5 seconds
+        Assert.AreEqual(0x05, parameters[3]);
+    }
+
+    [TestMethod]
+    public void SetCommand_Create_MultipleParameters()
+    {
+        Dictionary<WindowCoveringParameterId, byte> values = new()
+        {
+            { WindowCoveringParameterId.OutboundBottomPosition, 0x63 },
+            { WindowCoveringParameterId.VerticalSlatsAnglePosition, 0x32 },
+        };
+        DurationSet duration = new DurationSet(TimeSpan.FromSeconds(10));
+
+        WindowCoveringCommandClass.WindowCoveringSetCommand command =
+            WindowCoveringCommandClass.WindowCoveringSetCommand.Create(values, duration);
+
+        ReadOnlySpan<byte> parameters = command.Frame.CommandParameters.Span;
+        // 1 (count) + 4 (2 params × 2 bytes) + 1 (duration) = 6 bytes
+        Assert.AreEqual(6, parameters.Length);
+        // Parameter count = 2
+        Assert.AreEqual(0x02, parameters[0] & 0b0001_1111);
+    }
+
+    [TestMethod]
+    public void SetCommand_Create_FactoryDefaultDuration()
+    {
+        Dictionary<WindowCoveringParameterId, byte> values = new()
+        {
+            { WindowCoveringParameterId.OutboundLeftPosition, 0x00 },
+        };
+
+        WindowCoveringCommandClass.WindowCoveringSetCommand command =
+            WindowCoveringCommandClass.WindowCoveringSetCommand.Create(values, DurationSet.FactoryDefault);
+
+        ReadOnlySpan<byte> parameters = command.Frame.CommandParameters.Span;
+        Assert.AreEqual(4, parameters.Length);
+        Assert.AreEqual(0xFF, parameters[3]); // Factory default = 0xFF
+    }
+
+    [TestMethod]
+    public void SetCommand_Create_ZeroDuration()
+    {
+        Dictionary<WindowCoveringParameterId, byte> values = new()
+        {
+            { WindowCoveringParameterId.OutboundLeftPosition, 0x63 },
+        };
+        DurationSet duration = new DurationSet(0x00);
+
+        WindowCoveringCommandClass.WindowCoveringSetCommand command =
+            WindowCoveringCommandClass.WindowCoveringSetCommand.Create(values, duration);
+
+        ReadOnlySpan<byte> parameters = command.Frame.CommandParameters.Span;
+        Assert.AreEqual(0x00, parameters[3]); // Instant
+    }
+
+    [TestMethod]
+    public void SetCommand_Create_ZeroValue()
+    {
+        Dictionary<WindowCoveringParameterId, byte> values = new()
+        {
+            { WindowCoveringParameterId.OutboundBottomPosition, 0x00 },
+        };
+        DurationSet duration = new DurationSet(0x05);
+
+        WindowCoveringCommandClass.WindowCoveringSetCommand command =
+            WindowCoveringCommandClass.WindowCoveringSetCommand.Create(values, duration);
+
+        ReadOnlySpan<byte> parameters = command.Frame.CommandParameters.Span;
+        Assert.AreEqual((byte)WindowCoveringParameterId.OutboundBottomPosition, parameters[1]);
+        Assert.AreEqual(0x00, parameters[2]);
+    }
+}
diff --git a/src/ZWave.CommandClasses.Tests/WindowCoveringCommandClassTests.Supported.cs b/src/ZWave.CommandClasses.Tests/WindowCoveringCommandClassTests.Supported.cs
new file mode 100644
index 0000000..088ee6c
--- /dev/null
+++ b/src/ZWave.CommandClasses.Tests/WindowCoveringCommandClassTests.Supported.cs
@@ -0,0 +1,136 @@
+using Microsoft.Extensions.Logging.Abstractions;
+
+namespace ZWave.CommandClasses.Tests;
+
+public partial class WindowCoveringCommandClassTests
+{
+    [TestMethod]
+    public void SupportedGetCommand_Create_HasCorrectFormat()
+    {
+        WindowCoveringCommandClass.WindowCoveringSupportedGetCommand command =
+            WindowCoveringCommandClass.WindowCoveringSupportedGetCommand.Create();
+
+        Assert.AreEqual(CommandClassId.WindowCovering, WindowCoveringCommandClass.WindowCoveringSupportedGetCommand.CommandClassId);
+        Assert.AreEqual((byte)WindowCoveringCommand.SupportedGet, WindowCoveringCommandClass.WindowCoveringSupportedGetCommand.CommandId);
+        Assert.AreEqual(2, command.Frame.Data.Length);
+    }
+
+    [TestMethod]
+    public void SupportedReport_Parse_SingleMaskByte_PositionParameters()
+    {
+        // CC=0x6A, Cmd=0x02, Header=0x01 (reserved=0, maskCount=1), Mask1=0x0A (bits 1,3 = params 1,3)
+        byte[] data = [0x6A, 0x02, 0x01, 0x0A];
+        CommandClassFrame frame = new(data);
+
+        IReadOnlySet<WindowCoveringParameterId> supported = WindowCoveringCommandClass.WindowCoveringSupportedReportCommand.Parse(frame, NullLogger.Instance);
+
+        Assert.HasCount(2, supported);
+        Assert.Contains(WindowCoveringParameterId.OutboundLeftPosition, supported);
+        Assert.Contains(WindowCoveringParameterId.OutboundRightPosition, supported);
+    }
+
+    [TestMethod]
+    public void SupportedReport_Parse_ThreeMaskBytes_MultipleParameters()
+    {
+        // Header=0x03 (maskCount=3)
+        // Mask1=0x02 (bit 1 = param 1: OutboundLeftPosition)
+        // Mask2=0x08 (bit 3 = param 11: VerticalSlatsAnglePosition)
+        // Mask3=0x20 (bit 5 = param 21: InboundTopBottomPosition)
+        byte[] data = [0x6A, 0x02, 0x03, 0x02, 0x08, 0x20];
+        CommandClassFrame frame = new(data);
+
+        IReadOnlySet<WindowCoveringParameterId> supported = WindowCoveringCommandClass.WindowCoveringSupportedReportCommand.Parse(frame, NullLogger.Instance);
+
+        Assert.HasCount(3, supported);
+        Assert.Contains(WindowCoveringParameterId.OutboundLeftPosition, supported);
+        Assert.Contains(WindowCoveringParameterId.VerticalSlatsAnglePosition, supported);
+        Assert.Contains(WindowCoveringParameterId.InboundTopBottomPosition, supported);
+    }
+
+    [TestMethod]
+    public void SupportedReport_Parse_AllParameters()
+    {
+        // 24 parameter IDs need 3 mask bytes. All bits 0-23 set.
+        // Mask1=0xFF (params 0-7), Mask2=0xFF (params 8-15), Mask3=0xFF (params 16-23)
+        byte[] data = [0x6A, 0x02, 0x03, 0xFF, 0xFF, 0xFF];
+        CommandClassFrame frame = new(data);
+
+        IReadOnlySet<WindowCoveringParameterId> supported = WindowCoveringCommandClass.WindowCoveringSupportedReportCommand.Parse(frame, NullLogger.Instance);
+
+        Assert.HasCount(24, supported);
+        Assert.Contains(WindowCoveringParameterId.OutboundLeftMovement, supported);
+        Assert.Contains(WindowCoveringParameterId.HorizontalSlatsAnglePosition, supported);
+    }
+
+    [TestMethod]
+    public void SupportedReport_Parse_MovementOnlyParameters()
+    {
+        // Mask1=0x05 (bits 0,2 = params 0,2: movement-only even IDs)
+        byte[] data = [0x6A, 0x02, 0x01, 0x05];
+        CommandClassFrame frame = new(data);
+
+        IReadOnlySet<WindowCoveringParameterId> supported = WindowCoveringCommandClass.WindowCoveringSupportedReportCommand.Parse(frame, NullLogger.Instance);
+
+        Assert.HasCount(2, supported);
+        Assert.Contains(WindowCoveringParameterId.OutboundLeftMovement, supported);
+        Assert.Contains(WindowCoveringParameterId.OutboundRightMovement, supported);
+    }
+
+    [TestMethod]
+    public void SupportedReport_Parse_EmptyMask()
+    {
+        // Mask byte count=1, mask=0x00 (no parameters)
+        byte[] data = [0x6A, 0x02, 0x01, 0x00];
+        CommandClassFrame frame = new(data);
+
+        IReadOnlySet<WindowCoveringParameterId> supported = WindowCoveringCommandClass.WindowCoveringSupportedReportCommand.Parse(frame, NullLogger.Instance);
+
+        Assert.IsEmpty(supported);
+    }
+
+    [TestMethod]
+    public void SupportedReport_Parse_ReservedBitsIgnored()
+    {
+        // Header=0xF1 (reserved=0xF, maskCount=1) - reserved nibble should be ignored
+        byte[] data = [0x6A, 0x02, 0xF1, 0x02];
+        CommandClassFrame frame = new(data);
+
+        IReadOnlySet<WindowCoveringParameterId> supported = WindowCoveringCommandClass.WindowCoveringSupportedReportCommand.Parse(frame, NullLogger.Instance);
+
+        Assert.HasCount(1, supported);
+        Assert.Contains(WindowCoveringParameterId.OutboundLeftPosition, supported);
+    }
+
+    [TestMethod]
+    public void SupportedReport_Parse_TooShort_Throws()
+    {
+        // CC=0x6A, Cmd=0x02, no parameters
+        byte[] data = [0x6A, 0x02];
+        CommandClassFrame frame = new(data);
+
+        Assert.Throws<ZWaveException>(
+            () => WindowCoveringCommandClass.WindowCoveringSupportedReportCommand.Parse(frame, NullLogger.Instance));
+    }
+
+    [TestMethod]
+    public void SupportedReport_Parse_InvalidMaskByteCount_Zero_Throws()
+    {
+        // Header=0x00 (maskCount=0, which is below minimum of 1)
+        byte[] data = [0x6A, 0x02, 0x00];
+        CommandClassFrame frame = new(data);
+
+        Assert.Throws<ZWaveException>(
+            () => WindowCoveringCommandClass.WindowCoveringSupportedReportCommand.Parse(frame, NullLogger.Instance));
+    }
+
+    [TestMethod]
+    public void SupportedReport_Parse_InsufficientMaskBytes_Throws()
+    {
+        // Header=0x03 (maskCount=3) but only 1 mask byte follows
+        byte[] data = [0x6A, 0x02, 0x03, 0xFF];
+        CommandClassFrame frame = new(data);
+
+        Assert.Throws<ZWaveException>(
+            () => WindowCoveringCommandClass.WindowCoveringSupportedReportCommand.Parse(frame, NullLogger.Instance));
+    }
+}
diff --git a/src/ZWave.CommandClasses.Tests/WindowCoveringCommandClassTests.cs b/src/ZWave.CommandClasses.Tests/WindowCoveringCommandClassTests.cs
new file mode 100644
index 0000000..4c46b6a
--- /dev/null
+++ b/src/ZWave.CommandClasses.Tests/WindowCoveringCommandClassTests.cs
@@ -0,0 +1,6 @@
+namespace ZWave.CommandClasses.Tests;
+
+[TestClass]
+public partial class WindowCoveringCommandClassTests
+{
+}
diff --git a/src/ZWave.CommandClasses/WindowCoveringCommandClass.LevelChange.cs b/src/ZWave.CommandClasses/WindowCoveringCommandClass.LevelChange.cs
new file mode 100644
index 0000000..77cce9d
--- /dev/null
+++ b/src/ZWave.CommandClasses/WindowCoveringCommandClass.LevelChange.cs
@@ -0,0 +1,77 @@
+namespace ZWave.CommandClasses;
+
+public sealed partial class WindowCoveringCommandClass
+{
+    /// <summary>
+    /// Initiate a transition of one parameter to a new level.
+    /// </summary>
+    public async Task StartLevelChangeAsync(
+        WindowCoveringChangeDirection direction,
+        WindowCoveringParameterId parameterId,
+        DurationSet duration,
+        CancellationToken cancellationToken)
+    {
+        var command = WindowCoveringStartLevelChangeCommand.Create(direction, parameterId, duration);
+        await SendCommandAsync(command, cancellationToken).ConfigureAwait(false);
+    }
+
+    /// <summary>
+    /// Stop an ongoing transition.
+    /// </summary>
+    public async Task StopLevelChangeAsync(WindowCoveringParameterId parameterId, CancellationToken cancellationToken)
+    {
+        var command = WindowCoveringStopLevelChangeCommand.Create(parameterId);
+        await SendCommandAsync(command, cancellationToken).ConfigureAwait(false);
+    }
+
+    internal readonly struct WindowCoveringStartLevelChangeCommand : ICommand
+    {
+        public WindowCoveringStartLevelChangeCommand(CommandClassFrame frame)
+        {
+            Frame = frame;
+        }
+
+        public static CommandClassId CommandClassId => CommandClassId.WindowCovering;
+
+        public static byte CommandId => (byte)WindowCoveringCommand.StartLevelChange;
+
+        public CommandClassFrame Frame { get; }
+
+        public static WindowCoveringStartLevelChangeCommand Create(
+            WindowCoveringChangeDirection direction,
+            WindowCoveringParameterId parameterId,
+            DurationSet duration)
+        {
+            Span<byte> commandParameters =
+            [
+                // Byte 0: bit 7 = reserved, bit 6 = Up/Down, bits 5-0 = reserved
+                (byte)((byte)direction << 6),
+                (byte)parameterId,
+                duration.Value,
+            ];
+            CommandClassFrame frame = CommandClassFrame.Create(CommandClassId, CommandId, commandParameters);
+            return new WindowCoveringStartLevelChangeCommand(frame);
+        }
+    }
+
+    internal readonly struct WindowCoveringStopLevelChangeCommand : ICommand
+    {
+        public WindowCoveringStopLevelChangeCommand(CommandClassFrame frame)
+        {
+            Frame = frame;
+        }
+
+        public static CommandClassId CommandClassId => CommandClassId.WindowCovering;
+
+        public static byte CommandId => (byte)WindowCoveringCommand.StopLevelChange;
+
+        public CommandClassFrame Frame { get; }
+
+        public static WindowCoveringStopLevelChangeCommand Create(WindowCoveringParameterId parameterId)
+        {
+            ReadOnlySpan<byte> commandParameters = [(byte)parameterId];
+            CommandClassFrame frame = CommandClassFrame.Create(CommandClassId, CommandId, commandParameters);
+            return new WindowCoveringStopLevelChangeCommand(frame);
+        }
+    }
+}
diff --git a/src/ZWave.CommandClasses/WindowCoveringCommandClass.Report.cs b/src/ZWave.CommandClasses/WindowCoveringCommandClass.Report.cs
new file mode 100644
index 0000000..16993b8
--- /dev/null
+++ b/src/ZWave.CommandClasses/WindowCoveringCommandClass.Report.cs
@@ -0,0 +1,163 @@
+using Microsoft.Extensions.Logging;
+
+namespace ZWave.CommandClasses;
+
+/// <summary>
+/// Represents a Window Covering Report received from a device.
+/// </summary>
+public readonly record struct WindowCoveringReport(
+    /// <summary>
+    /// The parameter covered by this report.
+    /// </summary>
+    WindowCoveringParameterId ParameterId,
+
+    /// <summary>
+    /// The current value of the parameter.
+    /// </summary>
+    byte CurrentValue,
+
+    /// <summary>
+    /// The target value of an ongoing transition or the most recent transition for the parameter.
+    /// </summary>
+    byte TargetValue,
+
+    /// <summary>
+    /// The time needed to reach the Target Value at the actual transition rate.
+    /// </summary>
+    DurationReport Duration);
+
+public sealed partial class WindowCoveringCommandClass
+{
+    private Dictionary<WindowCoveringParameterId, WindowCoveringReport?> _parameterValues = new();
+
+    /// <summary>
+    /// Event raised when a Window Covering Report is received, both solicited and unsolicited.
+    /// </summary>
+    public event Action<WindowCoveringReport>? OnWindowCoveringReportReceived;
+
+    /// <summary>
+    /// Gets the state of each supported parameter.
+    /// </summary>
+    public IReadOnlyDictionary<WindowCoveringParameterId, WindowCoveringReport?> ParameterValues => _parameterValues;
+
+    /// <summary>
+    /// Request the status of a specified covering parameter.
+    /// </summary>
+    public async Task<WindowCoveringReport> GetAsync(
+        WindowCoveringParameterId parameterId,
+        CancellationToken cancellationToken)
+    {
+        WindowCoveringGetCommand command = WindowCoveringGetCommand.Create(parameterId);
+        await SendCommandAsync(command, cancellationToken).ConfigureAwait(false);
+        CommandClassFrame reportFrame = await AwaitNextReportAsync<WindowCoveringReportCommand>(
+            predicate: frame => frame.CommandParameters.Length > 0
+                && (WindowCoveringParameterId)frame.CommandParameters.Span[0] == parameterId,
+            cancellationToken).ConfigureAwait(false);
+        WindowCoveringReport report = WindowCoveringReportCommand.Parse(reportFrame, Logger);
+
+        _parameterValues[report.ParameterId] = report;
+
+        OnWindowCoveringReportReceived?.Invoke(report);
+        return report;
+    }
+
+    /// <summary>
+    /// Set the value of one or more covering parameters.
+    /// </summary>
+    public async Task SetAsync(
+        IReadOnlyDictionary<WindowCoveringParameterId, byte> values,
+        DurationSet duration,
+        CancellationToken cancellationToken)
+    {
+        var command = WindowCoveringSetCommand.Create(values, duration);
+        await SendCommandAsync(command, cancellationToken).ConfigureAwait(false);
+    }
+
+    internal readonly struct WindowCoveringGetCommand : ICommand
+    {
+        public WindowCoveringGetCommand(CommandClassFrame frame)
+        {
+            Frame = frame;
+        }
+
+        public static CommandClassId CommandClassId => CommandClassId.WindowCovering;
+
+        public static byte CommandId => (byte)WindowCoveringCommand.Get;
+
+        public CommandClassFrame Frame { get; }
+
+        public static WindowCoveringGetCommand Create(WindowCoveringParameterId parameterId)
+        {
+            ReadOnlySpan<byte> commandParameters = [(byte)parameterId];
+            CommandClassFrame frame = CommandClassFrame.Create(CommandClassId, CommandId, commandParameters);
+            return new WindowCoveringGetCommand(frame);
+        }
+    }
+
+    internal readonly struct WindowCoveringReportCommand : ICommand
+    {
+        public WindowCoveringReportCommand(CommandClassFrame frame)
+        {
+            Frame = frame;
+        }
+
+        public static CommandClassId CommandClassId => CommandClassId.WindowCovering;
+
+        public static byte CommandId => (byte)WindowCoveringCommand.Report;
+
+        public CommandClassFrame Frame { get; }
+
+        public static WindowCoveringReport Parse(CommandClassFrame frame, ILogger logger)
+        {
+            if (frame.CommandParameters.Length < 4)
+            {
+                logger.LogWarning("Window Covering Report frame is too short ({Length} bytes)", frame.CommandParameters.Length);
+                ZWaveException.Throw(ZWaveErrorCode.InvalidPayload, "Window Covering Report frame is too short");
+            }
+
+            ReadOnlySpan<byte> span = frame.CommandParameters.Span;
+
+            WindowCoveringParameterId parameterId = (WindowCoveringParameterId)span[0];
+            byte currentValue = span[1];
+            byte targetValue = span[2];
+            DurationReport duration = span[3];
+
+            return new WindowCoveringReport(parameterId, currentValue, targetValue, duration);
+        }
+    }
+
+    internal readonly struct WindowCoveringSetCommand : ICommand
+    {
+        public WindowCoveringSetCommand(CommandClassFrame frame)
+        {
+            Frame = frame;
+        }
+
+        public static CommandClassId CommandClassId => CommandClassId.WindowCovering;
+
+        public static byte CommandId => (byte)WindowCoveringCommand.Set;
+
+        public CommandClassFrame Frame { get; }
+
+        public static WindowCoveringSetCommand Create(
+            IReadOnlyDictionary<WindowCoveringParameterId, byte> values,
+            DurationSet duration)
+        {
+            // 1 byte (reserved+count) + 2 bytes per parameter (ID + value) + 1 byte duration
+            Span<byte> commandParameters = stackalloc byte[1 + (2 * values.Count) + 1];
+            commandParameters[0] = (byte)(values.Count & 0b0001_1111);
+
+            int idx = 1;
+            foreach (KeyValuePair<WindowCoveringParameterId, byte> pair in values)
+            {
+                commandParameters[idx++] = (byte)pair.Key;
+                commandParameters[idx++] = pair.Value;
+            }
+
+            commandParameters[idx] = duration.Value;
+
+            CommandClassFrame frame = CommandClassFrame.Create(CommandClassId, CommandId, commandParameters);
+            return new WindowCoveringSetCommand(frame);
+        }
+    }
+}
diff --git a/src/ZWave.CommandClasses/WindowCoveringCommandClass.Supported.cs b/src/ZWave.CommandClasses/WindowCoveringCommandClass.Supported.cs
new file mode 100644
index 0000000..245dd4e
--- /dev/null
+++ b/src/ZWave.CommandClasses/WindowCoveringCommandClass.Supported.cs
@@ -0,0 +1,104 @@
+using Microsoft.Extensions.Logging;
+
+namespace ZWave.CommandClasses;
+
+public sealed partial class WindowCoveringCommandClass
+{
+    /// <summary>
+    /// Gets the parameter IDs supported by the device.
+    /// </summary>
+    public IReadOnlySet<WindowCoveringParameterId>? SupportedParameterIds { get; private set; }
+
+    /// <summary>
+    /// Request the supported properties of a device.
+    /// </summary>
+    public async Task<IReadOnlySet<WindowCoveringParameterId>> GetSupportedAsync(CancellationToken cancellationToken)
+    {
+        WindowCoveringSupportedGetCommand command = WindowCoveringSupportedGetCommand.Create();
+        await SendCommandAsync(command, cancellationToken).ConfigureAwait(false);
+        CommandClassFrame reportFrame = await AwaitNextReportAsync<WindowCoveringSupportedReportCommand>(cancellationToken).ConfigureAwait(false);
+        IReadOnlySet<WindowCoveringParameterId> supportedParameters = WindowCoveringSupportedReportCommand.Parse(reportFrame, Logger);
+
+        ApplySupportedParameters(supportedParameters);
+
+        return supportedParameters;
+    }
+
+    private void ApplySupportedParameters(IReadOnlySet<WindowCoveringParameterId> supportedParameters)
+    {
+        SupportedParameterIds = supportedParameters;
+
+        Dictionary<WindowCoveringParameterId, WindowCoveringReport?> newParameterValues = new Dictionary<WindowCoveringParameterId, WindowCoveringReport?>();
+        foreach (WindowCoveringParameterId parameterId in supportedParameters)
+        {
+            // Persist any existing known state.
+            WindowCoveringReport? parameterState = null;
+            if (_parameterValues.TryGetValue(parameterId, out WindowCoveringReport? existingState))
+            {
+                parameterState = existingState;
+            }
+
+            newParameterValues.Add(parameterId, parameterState);
+        }
+
+        _parameterValues = newParameterValues;
+    }
+
+    internal readonly struct WindowCoveringSupportedGetCommand : ICommand
+    {
+        public WindowCoveringSupportedGetCommand(CommandClassFrame frame)
+        {
+            Frame = frame;
+        }
+
+        public static CommandClassId CommandClassId => CommandClassId.WindowCovering;
+
+        public static byte CommandId => (byte)WindowCoveringCommand.SupportedGet;
+
+        public CommandClassFrame Frame { get; }
+
+        public static WindowCoveringSupportedGetCommand Create()
+        {
+            CommandClassFrame frame = CommandClassFrame.Create(CommandClassId, CommandId);
+            return new WindowCoveringSupportedGetCommand(frame);
+        }
+    }
+
+    internal readonly struct WindowCoveringSupportedReportCommand : ICommand
+    {
+        public WindowCoveringSupportedReportCommand(CommandClassFrame frame)
+        {
+            Frame = frame;
+        }
+
+        public static CommandClassId CommandClassId => CommandClassId.WindowCovering;
+
+        public static byte CommandId => (byte)WindowCoveringCommand.SupportedReport;
+
+        public CommandClassFrame Frame { get; }
+
+        public static IReadOnlySet<WindowCoveringParameterId> Parse(CommandClassFrame frame, ILogger logger)
+        {
+            if (frame.CommandParameters.Length < 1)
+            {
+                logger.LogWarning("Window Covering Supported Report frame is too short ({Length} bytes)", frame.CommandParameters.Length);
+                ZWaveException.Throw(ZWaveErrorCode.InvalidPayload, "Window Covering Supported Report frame is too short");
+            }
+
+            ReadOnlySpan<byte> span = frame.CommandParameters.Span;
+
+            int maskByteCount = span[0] & 0b0000_1111;
+            if (maskByteCount < 1 || frame.CommandParameters.Length < 1 + maskByteCount)
+            {
+                logger.LogWarning(
+                    "Window Covering Supported Report has invalid mask byte count ({MaskByteCount}) for frame length ({Length} bytes)",
+                    maskByteCount,
+                    frame.CommandParameters.Length);
+                ZWaveException.Throw(ZWaveErrorCode.InvalidPayload, "Window Covering Supported Report has invalid mask byte count");
+            }
+
+            ReadOnlySpan<byte> maskBytes = span.Slice(1, maskByteCount);
+            return BitMaskHelper.ParseBitMask<WindowCoveringParameterId>(maskBytes);
+        }
+    }
+}
diff --git a/src/ZWave.CommandClasses/WindowCoveringCommandClass.cs b/src/ZWave.CommandClasses/WindowCoveringCommandClass.cs
new file mode 100644
index 0000000..7c051fb
--- /dev/null
+++ b/src/ZWave.CommandClasses/WindowCoveringCommandClass.cs
@@ -0,0 +1,250 @@
+using Microsoft.Extensions.Logging;
+
+namespace ZWave.CommandClasses;
+
+/// <summary>
+/// Identifies a window covering parameter.
+/// </summary>
+/// <remarks>
+/// Even parameter IDs represent movement-only control (position unknown).
+/// Odd parameter IDs represent position control (0x00–0x63).
+/// If a device supports a position parameter (odd), it MUST NOT support the corresponding movement parameter (even).
+/// </remarks>
+public enum WindowCoveringParameterId : byte
+{
+    /// <summary>
+    /// Outbound left edge, right/left movement (position unknown).
+    /// </summary>
+    OutboundLeftMovement = 0,
+
+    /// <summary>
+    /// Outbound left edge, right/left position (0x00 = Closed, 0x63 = Open).
+    /// </summary>
+    OutboundLeftPosition = 1,
+
+    /// <summary>
+    /// Outbound right edge, right/left movement (position unknown).
+    /// </summary>
+    OutboundRightMovement = 2,
+
+    /// <summary>
+    /// Outbound right edge, right/left position (0x00 = Closed, 0x63 = Open).
+    /// </summary>
+    OutboundRightPosition = 3,
+
+    /// <summary>
+    /// Inbound left edge, right/left movement (position unknown).
+    /// </summary>
+    InboundLeftMovement = 4,
+
+    /// <summary>
+    /// Inbound left edge, right/left position (0x00 = Closed, 0x63 = Open).
+    /// </summary>
+    InboundLeftPosition = 5,
+
+    /// <summary>
+    /// Inbound right edge, right/left movement (position unknown).
+    /// </summary>
+    InboundRightMovement = 6,
+
+    /// <summary>
+    /// Inbound right edge, right/left position (0x00 = Closed, 0x63 = Open).
+    /// </summary>
+    InboundRightPosition = 7,
+
+    /// <summary>
+    /// Inbound edges controlled horizontally as one, right/left movement (position unknown).
+    /// </summary>
+    InboundRightLeftMovement = 8,
+
+    /// <summary>
+    /// Inbound edges controlled horizontally as one, right/left position (0x00 = Closed, 0x63 = Open).
+    /// </summary>
+    InboundRightLeftPosition = 9,
+
+    /// <summary>
+    /// Vertical slats angle, right/left movement (position unknown).
+    /// </summary>
+    VerticalSlatsAngleMovement = 10,
+
+    /// <summary>
+    /// Vertical slats angle, right/left position (0x00 = Closed right, 0x32 = Open, 0x63 = Closed left).
+    /// </summary>
+    VerticalSlatsAnglePosition = 11,
+
+    /// <summary>
+    /// Outbound bottom edge, up/down movement (position unknown).
+    /// </summary>
+    OutboundBottomMovement = 12,
+
+    /// <summary>
+    /// Outbound bottom edge, up/down position (0x00 = Closed, 0x63 = Open).
+    /// </summary>
+    OutboundBottomPosition = 13,
+
+    /// <summary>
+    /// Outbound top edge, up/down movement (position unknown).
+    /// </summary>
+    OutboundTopMovement = 14,
+
+    /// <summary>
+    /// Outbound top edge, up/down position (0x00 = Closed, 0x63 = Open).
+    /// </summary>
+    OutboundTopPosition = 15,
+
+    /// <summary>
+    /// Inbound bottom edge, up/down movement (position unknown).
+    /// </summary>
+    InboundBottomMovement = 16,
+
+    /// <summary>
+    /// Inbound bottom edge, up/down position (0x00 = Closed, 0x63 = Open).
+    /// </summary>
+    InboundBottomPosition = 17,
+
+    /// <summary>
+    /// Inbound top edge, up/down movement (position unknown).
+    /// </summary>
+    InboundTopMovement = 18,
+
+    /// <summary>
+    /// Inbound top edge, up/down position (0x00 = Closed, 0x63 = Open).
+    /// </summary>
+    InboundTopPosition = 19,
+
+    /// <summary>
+    /// Inbound edges controlled vertically as one, up/down movement (position unknown).
+    /// </summary>
+    InboundTopBottomMovement = 20,
+
+    /// <summary>
+    /// Inbound edges controlled vertically as one, up/down position (0x00 = Closed, 0x63 = Open).
+    /// </summary>
+    InboundTopBottomPosition = 21,
+
+    /// <summary>
+    /// Horizontal slats angle, up/down movement (position unknown).
+    /// </summary>
+    HorizontalSlatsAngleMovement = 22,
+
+    /// <summary>
+    /// Horizontal slats angle, up/down position (0x00 = Closed up, 0x32 = Open, 0x63 = Closed down).
+    /// </summary>
+    HorizontalSlatsAnglePosition = 23,
+}
+
+/// <summary>
+/// The direction of a window covering level change.
+/// </summary>
+public enum WindowCoveringChangeDirection : byte
+{
+    /// <summary>
+    /// The level change is increasing (opening).
+    /// </summary>
+    Up = 0x00,
+
+    /// <summary>
+    /// The level change is decreasing (closing).
+    /// </summary>
+    Down = 0x01,
+}
+
+/// <summary>
+/// Defines the commands for the Window Covering Command Class.
+/// </summary>
+public enum WindowCoveringCommand : byte
+{
+    /// <summary>
+    /// Request the supported properties of a device.
+    /// </summary>
+    SupportedGet = 0x01,
+
+    /// <summary>
+    /// Report the supported properties of a device.
+    /// </summary>
+    SupportedReport = 0x02,
+
+    /// <summary>
+    /// Request the status of a specified covering parameter.
+    /// </summary>
+    Get = 0x03,
+
+    /// <summary>
+    /// Report the status of a covering parameter.
+    /// </summary>
+    Report = 0x04,
+
+    /// <summary>
+    /// Set the value of one or more covering parameters.
+    /// </summary>
+    Set = 0x05,
+
+    /// <summary>
+    /// Initiate a transition of one parameter to a new level.
+    /// </summary>
+    StartLevelChange = 0x06,
+
+    /// <summary>
+    /// Stop an ongoing transition.
+    /// </summary>
+    StopLevelChange = 0x07,
+}
+
+/// <summary>
+/// Controls window covering devices by manipulating covering parameters such as position and slats angle.
+/// </summary>
+[CommandClass(CommandClassId.WindowCovering)]
+public sealed partial class WindowCoveringCommandClass : CommandClass<WindowCoveringCommand>
+{
+    internal WindowCoveringCommandClass(
+        CommandClassInfo info,
+        IDriver driver,
+        IEndpoint endpoint,
+        ILogger logger)
+        : base(info, driver, endpoint, logger)
+    {
+    }
+
+    /// <inheritdoc />
+    public override bool? IsCommandSupported(WindowCoveringCommand command)
+        => command switch
+        {
+            WindowCoveringCommand.SupportedGet => true,
+            WindowCoveringCommand.Get => true,
+            WindowCoveringCommand.Set => true,
+            WindowCoveringCommand.StartLevelChange => true,
+            WindowCoveringCommand.StopLevelChange => true,
+            _ => false,
+        };
+
+    internal override async Task InterviewAsync(CancellationToken cancellationToken)
+    {
+        IReadOnlySet<WindowCoveringParameterId> supportedParameters = await GetSupportedAsync(cancellationToken).ConfigureAwait(false);
+
+        foreach (WindowCoveringParameterId parameterId in supportedParameters)
+        {
+            _ = await GetAsync(parameterId, cancellationToken).ConfigureAwait(false);
+        }
+    }
+
+    protected override void ProcessUnsolicitedCommand(CommandClassFrame frame)
+    {
+        switch ((WindowCoveringCommand)frame.CommandId)
+        {
+            case WindowCoveringCommand.SupportedReport:
+            {
+                IReadOnlySet<WindowCoveringParameterId> supportedParameters = WindowCoveringSupportedReportCommand.Parse(frame, Logger);
+                ApplySupportedParameters(supportedParameters);
+                break;
+            }
+            case WindowCoveringCommand.Report:
+            {
+                WindowCoveringReport report = WindowCoveringReportCommand.Parse(frame, Logger);
+                _parameterValues[report.ParameterId] = report;
+
+                OnWindowCoveringReportReceived?.Invoke(report);
+                break;
+            }
+        }
+    }
+}