Index: Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.IO/Model/AssemblyXmlIdentifiers.cs
===================================================================
diff -u -r7e15e5a8f543e9951e8a4ce5706dc32e073b1cdf -r5e2248b589fcb4b39e7ff664cd11a200b08daa28
--- Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.IO/Model/AssemblyXmlIdentifiers.cs	(.../AssemblyXmlIdentifiers.cs)	(revision 7e15e5a8f543e9951e8a4ce5706dc32e073b1cdf)
+++ Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.IO/Model/AssemblyXmlIdentifiers.cs	(.../AssemblyXmlIdentifiers.cs)	(revision 5e2248b589fcb4b39e7ff664cd11a200b08daa28)
@@ -113,19 +113,34 @@
         public const string BoundedBy = "boundedBy";
 
         /// <summary>
+        /// Identifier for a combined failure mechanism section assembly element.
+        /// </summary>
+        public const string CombinedFailureMechanismSectionAssembly = "GecombineerdToetsoordeel";
+        
+        /// <summary>
+        /// Identifier for a combined failure mechanism section assembly ID attribute.
+        /// </summary>
+        public const string CombinedFailureMechanismSectionAssemblyId = "GecombineerdToetsoordeelID";
+
+        /// <summary>
         /// Identifier for a combined section result element.
         /// </summary>
+        public const string CombinedCombinedSectionResult = "toetsoordeelGecombineerd";
+        
+        /// <summary>
+        /// Identifier for a combined section result element.
+        /// </summary>
         public const string CombinedSectionResult = "eindtoetsoordeel";
 
         /// <summary>
-        /// Identifier for a coordinate system type attribute.
+        /// Identifier for a combined section failure mechanism result element.
         /// </summary>
-        public const string CoordinateSystem = "srsName";
+        public const string CombinedSectionFailureMechanismResult = "eindtoetsoordeelToetsspoor";
 
         /// <summary>
-        /// Identifier for a description element.
+        /// Identifier for a coordinate system type attribute.
         /// </summary>
-        public const string Description = "omschrijving";
+        public const string CoordinateSystem = "srsName";
 
         /// <summary>
         /// Identifier for a direct failure mechanism element.
@@ -180,12 +195,12 @@
         /// <summary>
         /// Identifier for a failure mechanism section assembly element.
         /// </summary>
-        public const string FailureMechanismSectionAssemblyResult = "Toets";
+        public const string FailureMechanismSectionAssembly = "Toets";
 
         /// <summary>
         /// Identifier for a failure mechanism section assembly element.
         /// </summary>
-        public const string FailureMechanismSectionAssemblyResultId = "ToetsID";
+        public const string FailureMechanismSectionAssemblyId = "ToetsID";
 
         /// <summary>
         /// Identifier for a failure mechanism section category group element.
Index: Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.IO/Model/DataTypes/SerializableCombinedFailureMechanismSectionAssemblyResult.cs
===================================================================
diff -u
--- Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.IO/Model/DataTypes/SerializableCombinedFailureMechanismSectionAssemblyResult.cs	(revision 0)
+++ Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.IO/Model/DataTypes/SerializableCombinedFailureMechanismSectionAssemblyResult.cs	(revision 5e2248b589fcb4b39e7ff664cd11a200b08daa28)
@@ -0,0 +1,80 @@
+// Copyright (C) Stichting Deltares 2017. All rights reserved.
+//
+// This file is part of Ringtoets.
+//
+// Ringtoets is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <http://www.gnu.org/licenses/>.
+//
+// All names, logos, and references to "Deltares" are registered trademarks of
+// Stichting Deltares and remain full property of Stichting Deltares at all times.
+// All rights reserved.
+
+using System.Xml.Serialization;
+using Ringtoets.AssemblyTool.IO.Model.Enums;
+using Ringtoets.AssemblyTool.IO.Properties;
+
+namespace Ringtoets.AssemblyTool.IO.Model.DataTypes
+{
+    /// <summary>
+    /// Class describing a serializable combined failure mechanism section assembly result.
+    /// </summary>
+    public class SerializableCombinedFailureMechanismSectionAssemblyResult
+    {
+        /// <summary>
+        /// Creates a new instance of <see cref="SerializableCombinedFailureMechanismSectionAssemblyResult"/>.
+        /// </summary>
+        public SerializableCombinedFailureMechanismSectionAssemblyResult()
+        {
+            Status = Resources.FullAssembly;
+        }
+
+        /// <summary>
+        /// Creates a new instance of <see cref="SerializableCombinedFailureMechanismSectionAssemblyResult"/>.
+        /// </summary>
+        /// <param name="assemblyMethod">The method used to assemble this result.</param>
+        /// <param name="failureMechanismType">The failure mechanism type this result is assembled for.</param>
+        /// <param name="categoryGroup">The category group of this assembly result.</param>
+        public SerializableCombinedFailureMechanismSectionAssemblyResult(SerializableAssemblyMethod assemblyMethod,
+                                                                         SerializableFailureMechanismType failureMechanismType,
+                                                                         SerializableFailureMechanismSectionCategoryGroup categoryGroup) : this()
+        {
+            CategoryGroup = categoryGroup;
+            AssemblyMethod = assemblyMethod;
+            FailureMechanismType = failureMechanismType;
+        }
+
+        /// <summary>
+        /// Gets or sets the name of the method used to assemble this result.
+        /// </summary>
+        [XmlElement(AssemblyXmlIdentifiers.AssemblyMethod)]
+        public SerializableAssemblyMethod AssemblyMethod { get; set; }
+
+        /// <summary>
+        /// Gets or sets the category group of this assembly result.
+        /// </summary>
+        [XmlElement(AssemblyXmlIdentifiers.FailureMechanismSectionCategoryGroup)]
+        public SerializableFailureMechanismSectionCategoryGroup CategoryGroup { get; set; }
+
+        /// <summary>
+        /// Gets or sets the status of this assembly result.
+        /// </summary>
+        [XmlElement(AssemblyXmlIdentifiers.Status)]
+        public string Status { get; set; }
+
+        /// <summary>
+        /// Gets or sets the failure mechanism type of this assembly result.
+        /// </summary>
+        [XmlElement(AssemblyXmlIdentifiers.FailureMechanismType)]
+        public SerializableFailureMechanismType FailureMechanismType { get; set; }
+    }
+}
\ No newline at end of file
Index: Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.IO/Model/Enums/AssemblyXmlEnumIdentifiers.cs
===================================================================
diff -u -rb53d4c3c4221c2fcbc7b3c679e62d59a165fe8d4 -r5e2248b589fcb4b39e7ff664cd11a200b08daa28
--- Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.IO/Model/Enums/AssemblyXmlEnumIdentifiers.cs	(.../AssemblyXmlEnumIdentifiers.cs)	(revision b53d4c3c4221c2fcbc7b3c679e62d59a165fe8d4)
+++ Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.IO/Model/Enums/AssemblyXmlEnumIdentifiers.cs	(.../AssemblyXmlEnumIdentifiers.cs)	(revision 5e2248b589fcb4b39e7ff664cd11a200b08daa28)
@@ -398,11 +398,6 @@
         /// </summary>
         public const string SerializableAssessmentLevelCombinedSectionAssessment = "GECBNTRDV";
 
-        /// <summary>
-        /// Identifier for <see cref="SerializableAssessmentLevel.CombinedSectionFailureMechanismAssessment"/>.
-        /// </summary>
-        public const string SerializableAssessmentLevelCombinedSectionFailureMechanismAssessment = "GECBNTRDVTS";
-
         #endregion
     }
 }
\ No newline at end of file
Index: Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.IO/Model/Enums/SerializableAssessmentLevel.cs
===================================================================
diff -u -rd25cb785f385ccf9a25b57aeeaf741a2c78ef356 -r5e2248b589fcb4b39e7ff664cd11a200b08daa28
--- Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.IO/Model/Enums/SerializableAssessmentLevel.cs	(.../SerializableAssessmentLevel.cs)	(revision d25cb785f385ccf9a25b57aeeaf741a2c78ef356)
+++ Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.IO/Model/Enums/SerializableAssessmentLevel.cs	(.../SerializableAssessmentLevel.cs)	(revision 5e2248b589fcb4b39e7ff664cd11a200b08daa28)
@@ -56,12 +56,6 @@
         /// Represents the cmbined section assessment level.
         /// </summary>
         [XmlEnum(AssemblyXmlEnumIdentifiers.SerializableAssessmentLevelCombinedSectionAssessment)]
-        CombinedSectionAssessment = 5,
-
-        /// <summary>
-        /// Represents the combined section per failure mechanism assessment level.
-        /// </summary>
-        [XmlEnum(AssemblyXmlEnumIdentifiers.SerializableAssessmentLevelCombinedSectionFailureMechanismAssessment)]
-        CombinedSectionFailureMechanismAssessment = 6
+        CombinedSectionAssessment = 5
     }
 }
\ No newline at end of file
Index: Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.IO/Model/SerializableAssembly.cs
===================================================================
diff -u -r5c59e60cae7bc68b321c0ee187a7d4dd9dd753b2 -r5e2248b589fcb4b39e7ff664cd11a200b08daa28
--- Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.IO/Model/SerializableAssembly.cs	(.../SerializableAssembly.cs)	(revision 5c59e60cae7bc68b321c0ee187a7d4dd9dd753b2)
+++ Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.IO/Model/SerializableAssembly.cs	(.../SerializableAssembly.cs)	(revision 5e2248b589fcb4b39e7ff664cd11a200b08daa28)
@@ -97,6 +97,7 @@
         [XmlArrayItem(typeof(SerializableFailureMechanismSectionAssembly))]
         [XmlArrayItem(typeof(SerializableFailureMechanismSections))]
         [XmlArrayItem(typeof(SerializableFailureMechanismSection))]
+        [XmlArrayItem(typeof(SerializableCombinedFailureMechanismSectionAssembly))]
         public SerializableFeatureMember[] FeatureMembers { get; set; }
     }
 }
\ No newline at end of file
Index: Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.IO/Model/SerializableCombinedFailureMechanismSectionAssembly.cs
===================================================================
diff -u
--- Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.IO/Model/SerializableCombinedFailureMechanismSectionAssembly.cs	(revision 0)
+++ Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.IO/Model/SerializableCombinedFailureMechanismSectionAssembly.cs	(revision 5e2248b589fcb4b39e7ff664cd11a200b08daa28)
@@ -0,0 +1,116 @@
+// Copyright (C) Stichting Deltares 2017. All rights reserved.
+//
+// This file is part of Ringtoets.
+//
+// Ringtoets is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <http://www.gnu.org/licenses/>.
+//
+// All names, logos, and references to "Deltares" are registered trademarks of
+// Stichting Deltares and remain full property of Stichting Deltares at all times.
+// All rights reserved.
+
+using System;
+using System.Xml.Serialization;
+using Ringtoets.AssemblyTool.IO.Model.DataTypes;
+
+namespace Ringtoets.AssemblyTool.IO.Model
+{
+    /// <summary>
+    /// Class describing a serializable combined failure mechanism section assembly.
+    /// </summary>
+    [XmlType(AssemblyXmlIdentifiers.CombinedFailureMechanismSectionAssembly)]
+    public class SerializableCombinedFailureMechanismSectionAssembly : SerializableFeatureMember
+    {
+        /// <summary>
+        /// Creates a new instance of <see cref="SerializableCombinedFailureMechanismSectionAssembly"/>.
+        /// </summary>
+        public SerializableCombinedFailureMechanismSectionAssembly() {}
+
+        /// <summary>
+        /// Creates a new instance of <see cref="SerializableCombinedFailureMechanismSectionAssembly"/>.
+        /// </summary>
+        /// <param name="id">The unique ID of the assembly.</param>
+        /// <param name="totalAssemblyResult">The total assembly result this assembly belongs to.</param>
+        /// <param name="section">The section this assembly belongs to.</param>
+        /// <param name="failureMechanismResults">The collection of assembly results for this assembly per failure mechanism.</param>
+        /// <param name="combinedSectionResult">The combined assembly result for this assembly.</param>
+        /// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
+        public SerializableCombinedFailureMechanismSectionAssembly(string id,
+                                                                   SerializableTotalAssemblyResult totalAssemblyResult,
+                                                                   SerializableFailureMechanismSection section,
+                                                                   SerializableCombinedFailureMechanismSectionAssemblyResult[] failureMechanismResults,
+                                                                   SerializableFailureMechanismSectionAssemblyResult combinedSectionResult) : this()
+        {
+            if (id == null)
+            {
+                throw new ArgumentNullException(nameof(id));
+            }
+
+            if (totalAssemblyResult == null)
+            {
+                throw new ArgumentNullException(nameof(totalAssemblyResult));
+            }
+
+            if (section == null)
+            {
+                throw new ArgumentNullException(nameof(section));
+            }
+
+            if (failureMechanismResults == null)
+            {
+                throw new ArgumentNullException(nameof(failureMechanismResults));
+            }
+
+            if (combinedSectionResult == null)
+            {
+                throw new ArgumentNullException(nameof(combinedSectionResult));
+            }
+
+            Id = id;
+            TotalAssemblyResultId = totalAssemblyResult.Id;
+            FailureMechanismSectionId = section.Id;
+            FailureMechanismResults = failureMechanismResults;
+            CombinedSectionResult = combinedSectionResult;
+        }
+
+        /// <summary>
+        /// Gets or sets the ID.
+        /// </summary>
+        [XmlAttribute(AssemblyXmlIdentifiers.CombinedFailureMechanismSectionAssemblyId)]
+        public string Id { get; set; }
+
+        /// <summary>
+        /// Gets or sets the parent total assembly result ID.
+        /// </summary>
+        [XmlAttribute(AssemblyXmlIdentifiers.TotalAssemblyResultIdRef)]
+        public string TotalAssemblyResultId { get; set; }
+
+        /// <summary>
+        /// Gets or sets the parent failure mechanism section ID.
+        /// </summary>
+        [XmlAttribute(AssemblyXmlIdentifiers.FailureMechanismSectionIdRef)]
+        public string FailureMechanismSectionId { get; set; }
+
+        /// <summary>
+        /// Gets or sets the combined assembly result.
+        /// </summary>
+        [XmlElement(AssemblyXmlIdentifiers.CombinedCombinedSectionResult)]
+        public SerializableFailureMechanismSectionAssemblyResult CombinedSectionResult { get; set; }
+
+        /// <summary>
+        /// Gets or sets the array of results for this section per failure mechanism.
+        /// </summary>
+        [XmlElement(AssemblyXmlIdentifiers.CombinedSectionFailureMechanismResult)]
+        public SerializableCombinedFailureMechanismSectionAssemblyResult[] FailureMechanismResults { get; set; }
+    }
+}
\ No newline at end of file
Index: Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.IO/Model/SerializableFailureMechanismSectionAssembly.cs
===================================================================
diff -u -r24154e2ef651d5deac25c6caf8f143d0348b29ff -r5e2248b589fcb4b39e7ff664cd11a200b08daa28
--- Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.IO/Model/SerializableFailureMechanismSectionAssembly.cs	(.../SerializableFailureMechanismSectionAssembly.cs)	(revision 24154e2ef651d5deac25c6caf8f143d0348b29ff)
+++ Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.IO/Model/SerializableFailureMechanismSectionAssembly.cs	(.../SerializableFailureMechanismSectionAssembly.cs)	(revision 5e2248b589fcb4b39e7ff664cd11a200b08daa28)
@@ -26,9 +26,9 @@
 namespace Ringtoets.AssemblyTool.IO.Model
 {
     /// <summary>
-    /// Class describing a serializable failure mechanism section assembly result.
+    /// Class describing a serializable failure mechanism section assembly.
     /// </summary>
-    [XmlType(AssemblyXmlIdentifiers.FailureMechanismSectionAssemblyResult)]
+    [XmlType(AssemblyXmlIdentifiers.FailureMechanismSectionAssembly)]
     public class SerializableFailureMechanismSectionAssembly : SerializableFeatureMember
     {
         /// <summary>
@@ -39,7 +39,7 @@
         /// <summary>
         /// Creates a new instance of <see cref="SerializableFailureMechanismSectionAssembly"/>.
         /// </summary>
-        /// <param name="id">The unique ID of the assembly result.</param>
+        /// <param name="id">The unique ID of the assembly.</param>
         /// <param name="failureMechanism">The failure mechanism this assembly belongs to.</param>
         /// <param name="section">The section this assembly belongs to.</param>
         /// <param name="sectionResults">The collection of assembly results for this section assembly.</param>
@@ -86,7 +86,7 @@
         /// <summary>
         /// Gets or sets the ID.
         /// </summary>
-        [XmlAttribute(AssemblyXmlIdentifiers.FailureMechanismSectionAssemblyResultId)]
+        [XmlAttribute(AssemblyXmlIdentifiers.FailureMechanismSectionAssemblyId)]
         public string Id { get; set; }
 
         /// <summary>
Index: Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.IO/Ringtoets.AssemblyTool.IO.csproj
===================================================================
diff -u -r908ef4dfa4bb09ceacb29d33bdfe5680b6e50372 -r5e2248b589fcb4b39e7ff664cd11a200b08daa28
--- Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.IO/Ringtoets.AssemblyTool.IO.csproj	(.../Ringtoets.AssemblyTool.IO.csproj)	(revision 908ef4dfa4bb09ceacb29d33bdfe5680b6e50372)
+++ Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.IO/Ringtoets.AssemblyTool.IO.csproj	(.../Ringtoets.AssemblyTool.IO.csproj)	(revision 5e2248b589fcb4b39e7ff664cd11a200b08daa28)
@@ -19,6 +19,7 @@
   <ItemGroup>
     <Compile Include="Model\AssemblyXmlIdentifiers.cs" />
     <Compile Include="Model\DataTypes\SerializableAssessmentSectionAssemblyResult.cs" />
+    <Compile Include="Model\DataTypes\SerializableCombinedFailureMechanismSectionAssemblyResult.cs" />
     <Compile Include="Model\DataTypes\SerializableFailureMechanismSectionAssemblyResult.cs" />
     <Compile Include="Model\Enums\AssemblyXmlEnumIdentifiers.cs" />
     <Compile Include="Model\Enums\SerializableAssessmentLevel.cs" />
@@ -32,6 +33,7 @@
     <Compile Include="Model\Gml\SerializableBoundary.cs" />
     <Compile Include="Model\Helpers\GeometrySerializationFormatter.cs" />
     <Compile Include="Model\SerializableFailureMechanismSection.cs" />
+    <Compile Include="Model\SerializableCombinedFailureMechanismSectionAssembly.cs" />
     <Compile Include="Model\SerializableFailureMechanismSections.cs" />
     <Compile Include="Model\SerializableFailureMechanism.cs" />
     <Compile Include="Model\SerializableFailureMechanismSectionAssembly.cs" />
Index: Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.IO.Test/Model/DataTypes/SerializableCombinedFailureMechanismSectionAssemblyResultTest.cs
===================================================================
diff -u
--- Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.IO.Test/Model/DataTypes/SerializableCombinedFailureMechanismSectionAssemblyResultTest.cs	(revision 0)
+++ Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.IO.Test/Model/DataTypes/SerializableCombinedFailureMechanismSectionAssemblyResultTest.cs	(revision 5e2248b589fcb4b39e7ff664cd11a200b08daa28)
@@ -0,0 +1,75 @@
+// Copyright (C) Stichting Deltares 2017. All rights reserved.
+//
+// This file is part of Ringtoets.
+//
+// Ringtoets is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <http://www.gnu.org/licenses/>.
+//
+// All names, logos, and references to "Deltares" are registered trademarks of
+// Stichting Deltares and remain full property of Stichting Deltares at all times.
+// All rights reserved.
+
+using System;
+using Core.Common.TestUtil;
+using NUnit.Framework;
+using Ringtoets.AssemblyTool.IO.Model.DataTypes;
+using Ringtoets.AssemblyTool.IO.Model.Enums;
+using Ringtoets.AssemblyTool.IO.TestUtil;
+
+namespace Ringtoets.AssemblyTool.IO.Test.Model.DataTypes
+{
+    [TestFixture]
+    public class SerializableCombinedFailureMechanismSectionAssemblyResultTest
+    {
+        [Test]
+        public void DefaultConstructor_ReturnsDefaultValues()
+        {
+            // Call
+            var assemblyResult = new SerializableCombinedFailureMechanismSectionAssemblyResult();
+
+            // Assert
+            Assert.AreEqual((SerializableAssemblyMethod) 0, assemblyResult.AssemblyMethod);
+            Assert.AreEqual((SerializableFailureMechanismType) 0, assemblyResult.FailureMechanismType);
+            Assert.AreEqual((SerializableFailureMechanismSectionCategoryGroup) 0, assemblyResult.CategoryGroup);
+            Assert.AreEqual("VOLLDG", assemblyResult.Status);
+
+            SerializableAttributeTestHelper.AssertXmlElementAttribute<SerializableCombinedFailureMechanismSectionAssemblyResult>(
+                nameof(SerializableCombinedFailureMechanismSectionAssemblyResult.AssemblyMethod), "assemblagemethode");
+            SerializableAttributeTestHelper.AssertXmlElementAttribute<SerializableCombinedFailureMechanismSectionAssemblyResult>(
+                nameof(SerializableCombinedFailureMechanismSectionAssemblyResult.CategoryGroup), "categorieVak");
+            SerializableAttributeTestHelper.AssertXmlElementAttribute<SerializableCombinedFailureMechanismSectionAssemblyResult>(
+                nameof(SerializableCombinedFailureMechanismSectionAssemblyResult.FailureMechanismType), "typeToetsspoor");
+            SerializableAttributeTestHelper.AssertXmlElementAttribute<SerializableCombinedFailureMechanismSectionAssemblyResult>(
+                nameof(SerializableCombinedFailureMechanismSectionAssemblyResult.Status), "status");
+        }
+
+        [Test]
+        public void Constructor_WithValidData_ReturnsExpectedValues()
+        {
+            // Setup
+            var random = new Random(39);
+            var category = random.NextEnumValue<SerializableFailureMechanismSectionCategoryGroup>();
+            var failureMechanismType = random.NextEnumValue<SerializableFailureMechanismType>();
+            var assemblyMethod = random.NextEnumValue<SerializableAssemblyMethod>();
+
+            // Call
+            var assemblyResult = new SerializableCombinedFailureMechanismSectionAssemblyResult(assemblyMethod, failureMechanismType, category);
+
+            // Assert
+            Assert.AreEqual(assemblyMethod, assemblyResult.AssemblyMethod);
+            Assert.AreEqual(category, assemblyResult.CategoryGroup);
+            Assert.AreEqual(failureMechanismType, assemblyResult.FailureMechanismType);
+            Assert.AreEqual("VOLLDG", assemblyResult.Status);
+        }
+    }
+}
\ No newline at end of file
Index: Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.IO.Test/Model/Enums/AssemblyXmlEnumIdentifiersTest.cs
===================================================================
diff -u -rb53d4c3c4221c2fcbc7b3c679e62d59a165fe8d4 -r5e2248b589fcb4b39e7ff664cd11a200b08daa28
--- Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.IO.Test/Model/Enums/AssemblyXmlEnumIdentifiersTest.cs	(.../AssemblyXmlEnumIdentifiersTest.cs)	(revision b53d4c3c4221c2fcbc7b3c679e62d59a165fe8d4)
+++ Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.IO.Test/Model/Enums/AssemblyXmlEnumIdentifiersTest.cs	(.../AssemblyXmlEnumIdentifiersTest.cs)	(revision 5e2248b589fcb4b39e7ff664cd11a200b08daa28)
@@ -106,7 +106,6 @@
             Assert.AreEqual("TOETSOPMT", AssemblyXmlEnumIdentifiers.SerializableAssessmentLevelTailorMadeAssessment);
             Assert.AreEqual("GECBNTR", AssemblyXmlEnumIdentifiers.SerializableAssessmentLevelCombinedAssessment);
             Assert.AreEqual("GECBNTRDV", AssemblyXmlEnumIdentifiers.SerializableAssessmentLevelCombinedSectionAssessment);
-            Assert.AreEqual("GECBNTRDVTS", AssemblyXmlEnumIdentifiers.SerializableAssessmentLevelCombinedSectionFailureMechanismAssessment);
         }
     }
 }
\ No newline at end of file
Index: Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.IO.Test/Model/Enums/SerializableAssessmentLevelTest.cs
===================================================================
diff -u -rd0d416e8cadb9c542bce09ab6d8ce304d651d9b8 -r5e2248b589fcb4b39e7ff664cd11a200b08daa28
--- Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.IO.Test/Model/Enums/SerializableAssessmentLevelTest.cs	(.../SerializableAssessmentLevelTest.cs)	(revision d0d416e8cadb9c542bce09ab6d8ce304d651d9b8)
+++ Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.IO.Test/Model/Enums/SerializableAssessmentLevelTest.cs	(.../SerializableAssessmentLevelTest.cs)	(revision 5e2248b589fcb4b39e7ff664cd11a200b08daa28)
@@ -49,9 +49,6 @@
                     },
                     {
                         SerializableAssessmentLevel.CombinedSectionAssessment, 5
-                    },
-                    {
-                        SerializableAssessmentLevel.CombinedSectionFailureMechanismAssessment, 6
                     }
                 };
             }
@@ -77,9 +74,6 @@
                     },
                     {
                         SerializableAssessmentLevel.CombinedSectionAssessment, "GECBNTRDV"
-                    },
-                    {
-                        SerializableAssessmentLevel.CombinedSectionFailureMechanismAssessment, "GECBNTRDVTS"
                     }
                 };
             }
Index: Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.IO.Test/Model/SerializableAssemblyTest.cs
===================================================================
diff -u -r48a70fa6c4d7f5a73e2b2d10fe074f2ec7321a82 -r5e2248b589fcb4b39e7ff664cd11a200b08daa28
--- Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.IO.Test/Model/SerializableAssemblyTest.cs	(.../SerializableAssemblyTest.cs)	(revision 48a70fa6c4d7f5a73e2b2d10fe074f2ec7321a82)
+++ Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.IO.Test/Model/SerializableAssemblyTest.cs	(.../SerializableAssemblyTest.cs)	(revision 5e2248b589fcb4b39e7ff664cd11a200b08daa28)
@@ -66,14 +66,15 @@
             Assert.AreEqual("featureMember", xmlArrayAttribute.ElementName);
 
             IEnumerable<XmlArrayItemAttribute> xmlArrayItemAttributes = TypeUtils.GetPropertyAttributes<SerializableAssembly, XmlArrayItemAttribute>(nameof(SerializableAssembly.FeatureMembers));
-            Assert.AreEqual(7, xmlArrayItemAttributes.Count());
+            Assert.AreEqual(8, xmlArrayItemAttributes.Count());
             Assert.AreEqual(typeof(SerializableAssessmentProcess), xmlArrayItemAttributes.ElementAt(0).Type);
             Assert.AreEqual(typeof(SerializableAssessmentSection), xmlArrayItemAttributes.ElementAt(1).Type);
             Assert.AreEqual(typeof(SerializableTotalAssemblyResult), xmlArrayItemAttributes.ElementAt(2).Type);
             Assert.AreEqual(typeof(SerializableFailureMechanism), xmlArrayItemAttributes.ElementAt(3).Type);
             Assert.AreEqual(typeof(SerializableFailureMechanismSectionAssembly), xmlArrayItemAttributes.ElementAt(4).Type);
             Assert.AreEqual(typeof(SerializableFailureMechanismSections), xmlArrayItemAttributes.ElementAt(5).Type);
             Assert.AreEqual(typeof(SerializableFailureMechanismSection), xmlArrayItemAttributes.ElementAt(6).Type);
+            Assert.AreEqual(typeof(SerializableCombinedFailureMechanismSectionAssembly), xmlArrayItemAttributes.ElementAt(7).Type);
         }
 
         [Test]
@@ -196,26 +197,26 @@
                 })
             };
 
-            var assessmentProcess = new SerializableAssessmentProcess("process1",
+            var assessmentProcess = new SerializableAssessmentProcess("beoordelingsproces1",
                                                                       assessmentSection,
                                                                       2018,
                                                                       2020);
 
             var totalAssemblyResult = new SerializableTotalAssemblyResult(
-                "total id",
+                "veiligheidsoordeel_1",
                 assessmentProcess,
                 new SerializableFailureMechanismAssemblyResult(SerializableAssemblyMethod.WBI2B1, SerializableFailureMechanismCategoryGroup.IIt),
                 new SerializableFailureMechanismAssemblyResult(SerializableAssemblyMethod.WBI3C1, SerializableFailureMechanismCategoryGroup.NotApplicable, 0.000124),
                 new SerializableAssessmentSectionAssemblyResult(SerializableAssemblyMethod.WBI2C1, SerializableAssessmentSectionCategoryGroup.B));
 
-            var failureMechanism1 = new SerializableFailureMechanism("fm1",
+            var failureMechanism1 = new SerializableFailureMechanism("toetsspoorGABI",
                                                                      totalAssemblyResult,
                                                                      SerializableFailureMechanismType.GABI,
                                                                      SerializableAssemblyGroup.Group4,
                                                                      new SerializableFailureMechanismAssemblyResult(SerializableAssemblyMethod.WBI1A1, SerializableFailureMechanismCategoryGroup.IIt));
 
-            var sections1 = new SerializableFailureMechanismSections("sections1", failureMechanism1);
-            var section1 = new SerializableFailureMechanismSection("s1",
+            var sections1 = new SerializableFailureMechanismSections("vakindelingGABI", failureMechanism1);
+            var section1 = new SerializableFailureMechanismSection("vak_GABI_1",
                                                                    sections1,
                                                                    0.12,
                                                                    10.23,
@@ -226,7 +227,7 @@
                                                                    },
                                                                    SerializableAssemblyMethod.WBI3B1);
 
-            var result1 = new SerializableFailureMechanismSectionAssembly("sr1",
+            var result1 = new SerializableFailureMechanismSectionAssembly("resultaat_GABI_1",
                                                                           failureMechanism1,
                                                                           section1,
                                                                           new[]
@@ -236,7 +237,28 @@
                                                                           },
                                                                           new SerializableFailureMechanismSectionAssemblyResult(SerializableAssemblyMethod.WBI0A1, SerializableAssessmentLevel.CombinedAssessment, SerializableFailureMechanismSectionCategoryGroup.IIIv));
 
-            var assembly = new SerializableAssembly("assembly_1", new Point2D(12.0, 34.0), new Point2D(56.053, 78.0002345),
+            var sections2 = new SerializableFailureMechanismSections("vakindeling_gecombineerd", failureMechanism1);
+            var section2 = new SerializableFailureMechanismSection("vak_gecombineerd_1",
+                                                                   sections2,
+                                                                   0.12,
+                                                                   10.23,
+                                                                   new[]
+                                                                   {
+                                                                       new Point2D(0.23, 0.24),
+                                                                       new Point2D(10.23, 10.24)
+                                                                   },
+                                                                   SerializableAssemblyMethod.WBI3B1);
+            var combinedResult = new SerializableCombinedFailureMechanismSectionAssembly("resultaat_gecombineerd_1",
+                totalAssemblyResult,
+                section2,
+                new[]
+                {
+                    new SerializableCombinedFailureMechanismSectionAssemblyResult(SerializableAssemblyMethod.WBI3C1, SerializableFailureMechanismType.HTKW, SerializableFailureMechanismSectionCategoryGroup.IIIv), 
+                    new SerializableCombinedFailureMechanismSectionAssemblyResult(SerializableAssemblyMethod.WBI3C1, SerializableFailureMechanismType.STPH, SerializableFailureMechanismSectionCategoryGroup.IVv), 
+                },
+                new SerializableFailureMechanismSectionAssemblyResult(SerializableAssemblyMethod.WBI3B1, SerializableAssessmentLevel.CombinedSectionAssessment, SerializableFailureMechanismSectionCategoryGroup.VIv));
+
+            var assembly = new SerializableAssembly("assemblage_1", new Point2D(12.0, 34.0), new Point2D(56.053, 78.0002345),
                                                     new SerializableFeatureMember[]
                                                     {
                                                         assessmentSection,
@@ -245,7 +267,10 @@
                                                         failureMechanism1,
                                                         result1,
                                                         sections1,
-                                                        section1
+                                                        section1,
+                                                        sections2,
+                                                        section2,
+                                                        combinedResult
                                                     });
 
             serializer.Serialize(writer, assembly, xmlns);
Index: Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.IO.Test/Model/SerializableCombinedFailureMechanismSectionAssemblyTest.cs
===================================================================
diff -u
--- Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.IO.Test/Model/SerializableCombinedFailureMechanismSectionAssemblyTest.cs	(revision 0)
+++ Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.IO.Test/Model/SerializableCombinedFailureMechanismSectionAssemblyTest.cs	(revision 5e2248b589fcb4b39e7ff664cd11a200b08daa28)
@@ -0,0 +1,174 @@
+// Copyright (C) Stichting Deltares 2017. All rights reserved.
+//
+// This file is part of Ringtoets.
+//
+// Ringtoets is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <http://www.gnu.org/licenses/>.
+//
+// All names, logos, and references to "Deltares" are registered trademarks of
+// Stichting Deltares and remain full property of Stichting Deltares at all times.
+// All rights reserved.
+
+using System;
+using Core.Common.Base.Geometry;
+using NUnit.Framework;
+using Ringtoets.AssemblyTool.IO.Model;
+using Ringtoets.AssemblyTool.IO.Model.DataTypes;
+using Ringtoets.AssemblyTool.IO.TestUtil;
+
+namespace Ringtoets.AssemblyTool.IO.Test.Model
+{
+    [TestFixture]
+    public class SerializableCombinedFailureMechanismSectionAssemblyTest
+    {
+        [Test]
+        public void DefaultConstructor_ReturnsDefaultValues()
+        {
+            // Call
+            var combinedSectionAssembly = new SerializableCombinedFailureMechanismSectionAssembly();
+
+            // Assert
+            Assert.IsInstanceOf<SerializableFeatureMember>(combinedSectionAssembly);
+            Assert.IsNull(combinedSectionAssembly.Id);
+            Assert.IsNull(combinedSectionAssembly.TotalAssemblyResultId);
+            Assert.IsNull(combinedSectionAssembly.FailureMechanismSectionId);
+            Assert.IsNull(combinedSectionAssembly.CombinedSectionResult);
+            Assert.IsNull(combinedSectionAssembly.FailureMechanismResults);
+
+            SerializableAttributeTestHelper.AssertXmlAttributeAttribute<SerializableCombinedFailureMechanismSectionAssembly>(
+                nameof(SerializableCombinedFailureMechanismSectionAssembly.Id), "GecombineerdToetsoordeelID");
+            SerializableAttributeTestHelper.AssertXmlAttributeAttribute<SerializableCombinedFailureMechanismSectionAssembly>(
+                nameof(SerializableCombinedFailureMechanismSectionAssembly.TotalAssemblyResultId), "VeiligheidsoordeelIDRef");
+            SerializableAttributeTestHelper.AssertXmlAttributeAttribute<SerializableCombinedFailureMechanismSectionAssembly>(
+                nameof(SerializableCombinedFailureMechanismSectionAssembly.FailureMechanismSectionId), "WaterkeringsectieIDRef");
+
+            SerializableAttributeTestHelper.AssertXmlElementAttribute<SerializableCombinedFailureMechanismSectionAssembly>(
+                nameof(SerializableCombinedFailureMechanismSectionAssembly.CombinedSectionResult), "toetsoordeelGecombineerd");
+            SerializableAttributeTestHelper.AssertXmlElementAttribute<SerializableCombinedFailureMechanismSectionAssembly>(
+                nameof(SerializableCombinedFailureMechanismSectionAssembly.FailureMechanismResults), "eindtoetsoordeelToetsspoor");
+        }
+
+        [Test]
+        public void Constructor_IdNull_ThrowsArgumentNullException()
+        {
+            // Call
+            TestDelegate call = () => new SerializableCombinedFailureMechanismSectionAssembly(null,
+                                                                                              new SerializableTotalAssemblyResult(),
+                                                                                              new SerializableFailureMechanismSection(),
+                                                                                              new SerializableCombinedFailureMechanismSectionAssemblyResult[0],
+                                                                                              new SerializableFailureMechanismSectionAssemblyResult());
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(call);
+            Assert.AreEqual("id", exception.ParamName);
+        }
+
+        [Test]
+        public void Constructor_TotalAssemblyResultNull_ThrowsArgumentNullException()
+        {
+            // Call
+            TestDelegate call = () => new SerializableCombinedFailureMechanismSectionAssembly("id",
+                                                                                              null,
+                                                                                              new SerializableFailureMechanismSection(),
+                                                                                              new SerializableCombinedFailureMechanismSectionAssemblyResult[0],
+                                                                                              new SerializableFailureMechanismSectionAssemblyResult());
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(call);
+            Assert.AreEqual("totalAssemblyResult", exception.ParamName);
+        }
+
+        [Test]
+        public void Constructor_SectionNull_ThrowsArgumentNullException()
+        {
+            // Call
+            TestDelegate call = () => new SerializableCombinedFailureMechanismSectionAssembly("id",
+                                                                                              new SerializableTotalAssemblyResult(),
+                                                                                              null,
+                                                                                              new SerializableCombinedFailureMechanismSectionAssemblyResult[0],
+                                                                                              new SerializableFailureMechanismSectionAssemblyResult());
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(call);
+            Assert.AreEqual("section", exception.ParamName);
+        }
+
+        [Test]
+        public void Constructor_FailureMechanismResultsNull_ThrowsArgumentNullException()
+        {
+            // Call
+            TestDelegate call = () => new SerializableCombinedFailureMechanismSectionAssembly("id",
+                                                                                              new SerializableTotalAssemblyResult(),
+                                                                                              new SerializableFailureMechanismSection(),
+                                                                                              null,
+                                                                                              new SerializableFailureMechanismSectionAssemblyResult());
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(call);
+            Assert.AreEqual("failureMechanismResults", exception.ParamName);
+        }
+
+        [Test]
+        public void Constructor_CombinedSectionResultNull_ThrowsArgumentNullException()
+        {
+            // Call
+            TestDelegate call = () => new SerializableCombinedFailureMechanismSectionAssembly("id",
+                                                                                              new SerializableTotalAssemblyResult(),
+                                                                                              new SerializableFailureMechanismSection(),
+                                                                                              new SerializableCombinedFailureMechanismSectionAssemblyResult[0],
+                                                                                              null);
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(call);
+            Assert.AreEqual("combinedSectionResult", exception.ParamName);
+        }
+
+        [Test]
+        public void Constructor_WithValidData_ReturnsExpectedValues()
+        {
+            // Setup
+            const string id = "id";
+
+            var random = new Random(39);
+            var totalAssembly = new SerializableTotalAssemblyResult("total assembly ID",
+                                                                    new SerializableAssessmentProcess(),
+                                                                    new SerializableFailureMechanismAssemblyResult(),
+                                                                    new SerializableFailureMechanismAssemblyResult(),
+                                                                    new SerializableAssessmentSectionAssemblyResult());
+            var section = new SerializableFailureMechanismSection("section ID",
+                                                                  new SerializableFailureMechanismSections(),
+                                                                  random.NextDouble(),
+                                                                  random.NextDouble(),
+                                                                  new[]
+                                                                  {
+                                                                      new Point2D(random.NextDouble(), random.NextDouble())
+                                                                  });
+            var sectionResults = new SerializableCombinedFailureMechanismSectionAssemblyResult[0];
+            var combinedSectionResult = new SerializableFailureMechanismSectionAssemblyResult();
+
+            // Call
+            var combinedSectionAssembly = new SerializableCombinedFailureMechanismSectionAssembly(id,
+                                                                                                  totalAssembly,
+                                                                                                  section,
+                                                                                                  sectionResults,
+                                                                                                  combinedSectionResult);
+
+            // Assert
+            Assert.AreEqual(id, combinedSectionAssembly.Id);
+            Assert.AreEqual(totalAssembly.Id, combinedSectionAssembly.TotalAssemblyResultId);
+            Assert.AreEqual(section.Id, combinedSectionAssembly.FailureMechanismSectionId);
+            Assert.AreSame(sectionResults, combinedSectionAssembly.FailureMechanismResults);
+            Assert.AreSame(combinedSectionResult, combinedSectionAssembly.CombinedSectionResult);
+        }
+    }
+}
\ No newline at end of file
Index: Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.IO.Test/Ringtoets.AssemblyTool.IO.Test.csproj
===================================================================
diff -u -r908ef4dfa4bb09ceacb29d33bdfe5680b6e50372 -r5e2248b589fcb4b39e7ff664cd11a200b08daa28
--- Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.IO.Test/Ringtoets.AssemblyTool.IO.Test.csproj	(.../Ringtoets.AssemblyTool.IO.Test.csproj)	(revision 908ef4dfa4bb09ceacb29d33bdfe5680b6e50372)
+++ Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.IO.Test/Ringtoets.AssemblyTool.IO.Test.csproj	(.../Ringtoets.AssemblyTool.IO.Test.csproj)	(revision 5e2248b589fcb4b39e7ff664cd11a200b08daa28)
@@ -16,6 +16,7 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="Model\DataTypes\SerializableAssessmentSectionAssemblyResultTest.cs" />
+    <Compile Include="Model\DataTypes\SerializableCombinedFailureMechanismSectionAssemblyResultTest.cs" />
     <Compile Include="Model\DataTypes\SerializableFailureMechanismSectionAssemblyResultTest.cs" />
     <Compile Include="Model\DataTypes\SerializableFailureMechanismAssemblyResultTest.cs" />
     <Compile Include="Model\Enums\AssemblyXmlEnumIdentifiersTest.cs" />
@@ -27,6 +28,7 @@
     <Compile Include="Model\Enums\SerializableAssemblyGroupTest.cs" />
     <Compile Include="Model\Enums\SerializableFailureMechanismCategoryGroupTest.cs" />
     <Compile Include="Model\Helpers\GeometrySerializationFormatterTest.cs" />
+    <Compile Include="Model\SerializableCombinedFailureMechanismSectionAssemblyTest.cs" />
     <Compile Include="Model\SerializableFailureMechanismSectionTest.cs" />
     <Compile Include="Model\SerializableFailureMechanismSectionsTest.cs" />
     <Compile Include="Model\SerializableFailureMechanismTest.cs" />