Index: Ringtoets/Revetment/src/Ringtoets.Revetment.IO/Configurations/Helpers/ConfigurationWaveConditionsInputStepSizeConverter.cs
===================================================================
diff -u -r2057d3372084602a2d959db2e33dcf81de971a73 -rdda73aa7eb61a8f10e66b94b0b276351049b1cb4
--- Ringtoets/Revetment/src/Ringtoets.Revetment.IO/Configurations/Helpers/ConfigurationWaveConditionsInputStepSizeConverter.cs	(.../ConfigurationWaveConditionsInputStepSizeConverter.cs)	(revision 2057d3372084602a2d959db2e33dcf81de971a73)
+++ Ringtoets/Revetment/src/Ringtoets.Revetment.IO/Configurations/Helpers/ConfigurationWaveConditionsInputStepSizeConverter.cs	(.../ConfigurationWaveConditionsInputStepSizeConverter.cs)	(revision dda73aa7eb61a8f10e66b94b0b276351049b1cb4)
@@ -22,6 +22,7 @@
 using System;
 using System.ComponentModel;
 using System.Globalization;
+using Ringtoets.Revetment.Data;
 
 namespace Ringtoets.Revetment.IO.Configurations.Helpers
 {
@@ -30,34 +31,72 @@
     /// </summary>
     public class ConfigurationWaveConditionsInputStepSizeConverter : TypeConverter
     {
+        public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
+        {
+            return destinationType == typeof(WaveConditionsInputStepSize)
+                   || base.CanConvertTo(context, destinationType);
+        }
+
         public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
         {
+            var stepSize = (ConfigurationWaveConditionsInputStepSize) value;
+
+            if (destinationType == typeof(WaveConditionsInputStepSize))
+            {
+                switch (stepSize)
+                {
+                    case ConfigurationWaveConditionsInputStepSize.Half:
+                        return WaveConditionsInputStepSize.Half;
+                    case ConfigurationWaveConditionsInputStepSize.One:
+                        return WaveConditionsInputStepSize.One;
+                    case ConfigurationWaveConditionsInputStepSize.Two:
+                        return WaveConditionsInputStepSize.Two;
+                    default:
+                        throw new NotSupportedException();
+                }
+            }
+
             if (destinationType == typeof(string))
             {
-                switch ((ConfigurationWaveConditionsInputStepSize) value)
+                switch (stepSize)
                 {
                     case ConfigurationWaveConditionsInputStepSize.Half:
                         return FormatStepSizeValue(culture, 0.5);
                     case ConfigurationWaveConditionsInputStepSize.One:
                         return FormatStepSizeValue(culture, 1.0);
                     case ConfigurationWaveConditionsInputStepSize.Two:
                         return FormatStepSizeValue(culture, 2.0);
+                    default:
+                        throw new NotSupportedException();
                 }
             }
             return base.ConvertTo(context, culture, value, destinationType);
         }
 
         public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
         {
-            if (sourceType == typeof(double?))
-            {
-                return true;
-            }
-            return base.CanConvertFrom(context, sourceType);
+            return sourceType == typeof(double?)
+                   || sourceType == typeof(WaveConditionsInputStepSize)
+                   || base.CanConvertFrom(context, sourceType);
         }
 
         public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
         {
+            if (value is WaveConditionsInputStepSize)
+            {
+                switch ((WaveConditionsInputStepSize) value)
+                {
+                    case WaveConditionsInputStepSize.Half:
+                        return ConfigurationWaveConditionsInputStepSize.Half;
+                    case WaveConditionsInputStepSize.One:
+                        return ConfigurationWaveConditionsInputStepSize.One;
+                    case WaveConditionsInputStepSize.Two:
+                        return ConfigurationWaveConditionsInputStepSize.Two;
+                    default:
+                        throw new NotSupportedException();
+                }
+            }
+
             var doubleValue = value as double?;
             if (doubleValue != null)
             {
Index: Ringtoets/Revetment/test/Ringtoets.Revetment.IO.Test/Configurations/Helpers/ConfigurationWaveConditionsInputStepSizeConverterTest.cs
===================================================================
diff -u -r2057d3372084602a2d959db2e33dcf81de971a73 -rdda73aa7eb61a8f10e66b94b0b276351049b1cb4
--- Ringtoets/Revetment/test/Ringtoets.Revetment.IO.Test/Configurations/Helpers/ConfigurationWaveConditionsInputStepSizeConverterTest.cs	(.../ConfigurationWaveConditionsInputStepSizeConverterTest.cs)	(revision 2057d3372084602a2d959db2e33dcf81de971a73)
+++ Ringtoets/Revetment/test/Ringtoets.Revetment.IO.Test/Configurations/Helpers/ConfigurationWaveConditionsInputStepSizeConverterTest.cs	(.../ConfigurationWaveConditionsInputStepSizeConverterTest.cs)	(revision dda73aa7eb61a8f10e66b94b0b276351049b1cb4)
@@ -23,6 +23,7 @@
 using System.ComponentModel;
 using System.Globalization;
 using NUnit.Framework;
+using Ringtoets.Revetment.Data;
 using Ringtoets.Revetment.IO.Configurations;
 using Ringtoets.Revetment.IO.Configurations.Helpers;
 
@@ -55,12 +56,25 @@
         }
 
         [Test]
-        public void CanConvertTo_OtherTypeThanString_ReturnFalse()
+        public void CanConvertTo_WaveConditionsInputStepSize_ReturnTrue()
         {
             // Setup
             var converter = new ConfigurationWaveConditionsInputStepSizeConverter();
 
             // Call
+            bool canConvertToString = converter.CanConvertTo(typeof(WaveConditionsInputStepSize));
+
+            // Assert
+            Assert.IsTrue(canConvertToString);
+        }
+
+        [Test]
+        public void CanConvertTo_OtherType_ReturnFalse()
+        {
+            // Setup
+            var converter = new ConfigurationWaveConditionsInputStepSizeConverter();
+
+            // Call
             bool canConvertToNonString = converter.CanConvertTo(typeof(object));
 
             // Assert
@@ -72,8 +86,8 @@
         [TestCase(ConfigurationWaveConditionsInputStepSize.Half, "0,5")]
         [TestCase(ConfigurationWaveConditionsInputStepSize.One, "1,0")]
         [TestCase(ConfigurationWaveConditionsInputStepSize.Two, "2,0")]
-        public void ConvertTo_ForAllEnumValues_ReturnExpectedText(ConfigurationWaveConditionsInputStepSize value,
-                                                                  string expectedText)
+        public void ConvertTo_StringForAllEnumValues_ReturnExpectedText(ConfigurationWaveConditionsInputStepSize value,
+                                                                        string expectedText)
         {
             // Setup
             var converter = new ConfigurationWaveConditionsInputStepSizeConverter();
@@ -86,6 +100,50 @@
         }
 
         [Test]
+        public void ConvertTo_StringInvalidConfigurationWaveConditionsInputStepSize_ThrowNotSupportedException()
+        {
+            // Setup
+            var converter = new ConfigurationWaveConditionsInputStepSizeConverter();
+
+            // Call
+            TestDelegate call = () => converter.ConvertTo((ConfigurationWaveConditionsInputStepSize) 9999, typeof(string));
+
+            // Assert
+            Assert.Throws<NotSupportedException>(call);
+        }
+
+        [Test]
+        [SetCulture("nl-NL")]
+        [TestCase(ConfigurationWaveConditionsInputStepSize.Half, WaveConditionsInputStepSize.Half)]
+        [TestCase(ConfigurationWaveConditionsInputStepSize.One, WaveConditionsInputStepSize.One)]
+        [TestCase(ConfigurationWaveConditionsInputStepSize.Two, WaveConditionsInputStepSize.Two)]
+        public void ConvertTo_WaveConditionsInputStepSizeForAllEnumValues_ReturnExpectedText(ConfigurationWaveConditionsInputStepSize value,
+                                                                                             WaveConditionsInputStepSize expectedText)
+        {
+            // Setup
+            var converter = new ConfigurationWaveConditionsInputStepSizeConverter();
+
+            // Call
+            object result = converter.ConvertTo(null, CultureInfo.CurrentCulture, value, typeof(WaveConditionsInputStepSize));
+
+            // Assert
+            Assert.AreEqual(expectedText, result);
+        }
+
+        [Test]
+        public void ConvertTo_WaveConditionsInputStepSizeInvalidConfigurationWaveConditionsInputStepSize_ThrowNotSupportedException()
+        {
+            // Setup
+            var converter = new ConfigurationWaveConditionsInputStepSizeConverter();
+
+            // Call
+            TestDelegate call = () => converter.ConvertTo((ConfigurationWaveConditionsInputStepSize) 9999, typeof(WaveConditionsInputStepSize));
+
+            // Assert
+            Assert.Throws<NotSupportedException>(call);
+        }
+
+        [Test]
         public void ConvertTo_Object_ThrowNotSupportedException()
         {
             // Setup
@@ -112,12 +170,25 @@
         }
 
         [Test]
-        public void CanConvertFrom_NonNullableDouble_ReturnFalse()
+        public void CanConvertFrom_WaveConditionsInputStepSize_ReturnTrue()
         {
             // Setup
             var converter = new ConfigurationWaveConditionsInputStepSizeConverter();
 
             // Call
+            bool canConvertFromNullableDouble = converter.CanConvertFrom(typeof(WaveConditionsInputStepSize));
+
+            // Assert
+            Assert.IsTrue(canConvertFromNullableDouble);
+        }
+
+        [Test]
+        public void CanConvertFrom_OtherType_ReturnFalse()
+        {
+            // Setup
+            var converter = new ConfigurationWaveConditionsInputStepSizeConverter();
+
+            // Call
             bool canConvertFromString = converter.CanConvertFrom(typeof(object));
 
             // Assert
@@ -174,6 +245,23 @@
         }
 
         [Test]
+        [TestCase(WaveConditionsInputStepSize.Half, ConfigurationWaveConditionsInputStepSize.Half)]
+        [TestCase(WaveConditionsInputStepSize.One, ConfigurationWaveConditionsInputStepSize.One)]
+        [TestCase(WaveConditionsInputStepSize.Two, ConfigurationWaveConditionsInputStepSize.Two)]
+        public void ConvertFrom_VariousWaveConditionsInputStepSize_ReturnWaveConditionsInputStepSize(WaveConditionsInputStepSize value,
+                                                                                                     ConfigurationWaveConditionsInputStepSize expectedResult)
+        {
+            // Setup
+            var converter = new ConfigurationWaveConditionsInputStepSizeConverter();
+
+            // Call
+            object result = converter.ConvertFrom(value);
+
+            // Assert
+            Assert.AreEqual(expectedResult, result);
+        }
+
+        [Test]
         public void ConvertFrom_Null_ThrowNotSupportedException()
         {
             // Setup