Index: Ringtoets/Integration/src/Ringtoets.Integration.IO/Assembly/ExportableAssessmentSection.cs
===================================================================
diff -u
--- Ringtoets/Integration/src/Ringtoets.Integration.IO/Assembly/ExportableAssessmentSection.cs	(revision 0)
+++ Ringtoets/Integration/src/Ringtoets.Integration.IO/Assembly/ExportableAssessmentSection.cs	(revision 719d0e6a2b96f912e844a16cfc96c4f7c8da62b7)
@@ -0,0 +1,102 @@
+using System;
+using System.Collections.Generic;
+using Core.Common.Base.Geometry;
+
+namespace Ringtoets.Integration.IO.Assembly
+{
+    /// <summary>
+    /// Class that holds all the information to export the assembly results
+    /// of an assessment section.
+    /// </summary>
+    public class ExportableAssessmentSection
+    {
+        /// <summary>
+        /// Creates an instance of <see cref="ExportableAssessmentSection"/>.
+        /// </summary>
+        /// <param name="name">The name of the assessment section.</param>
+        /// <param name="geometry">The geometry of the assessment section.</param>
+        /// <param name="assessmentSectionAssembly">The assembly result of the assessment section.</param>
+        /// <param name="failureMechanismsWithProbability">The assembly results with probability of failure
+        /// mechanisms belonging to this assessment section.</param>
+        /// <param name="failureMechanismsWithoutProbability">The assembly results without probability
+        /// of failure mechanisms belonging to this assessment section.</param>
+        /// <param name="combinedSectionAssemblyResults">The combined section assembly results
+        /// of this assessment section.</param>
+        /// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
+        public ExportableAssessmentSection(
+            string name,
+            IEnumerable<Point2D> geometry,
+            ExportableAssessmentSectionAssemblyResult assessmentSectionAssembly,
+            IEnumerable<ExportableFailureMechanism<ExportableFailureMechanismAssemblyResultWithProbability>> failureMechanismsWithProbability,
+            IEnumerable<ExportableFailureMechanism<ExportableFailureMechanismAssemblyResult>> failureMechanismsWithoutProbability,
+            IEnumerable<ExportableCombinedSectionAssembly> combinedSectionAssemblyResults)
+        {
+            if (name == null)
+            {
+                throw new ArgumentNullException(nameof(name));
+            }
+
+            if (geometry == null)
+            {
+                throw new ArgumentNullException(nameof(geometry));
+            }
+
+            if (assessmentSectionAssembly == null)
+            {
+                throw new ArgumentNullException(nameof(assessmentSectionAssembly));
+            }
+
+            if (failureMechanismsWithProbability == null)
+            {
+                throw new ArgumentNullException(nameof(failureMechanismsWithProbability));
+            }
+
+            if (failureMechanismsWithoutProbability == null)
+            {
+                throw new ArgumentNullException(nameof(failureMechanismsWithoutProbability));
+            }
+
+            if (combinedSectionAssemblyResults == null)
+            {
+                throw new ArgumentNullException(nameof(combinedSectionAssemblyResults));
+            }
+
+            Name = name;
+            Geometry = geometry;
+            AssessmentSectionAssembly = assessmentSectionAssembly;
+            FailureMechanismsWithProbability = failureMechanismsWithProbability;
+            FailureMechanismsWithoutProbability = failureMechanismsWithoutProbability;
+            CombinedSectionAssemblyResults = combinedSectionAssemblyResults;
+        }
+
+        /// <summary>
+        /// Gets the name of the assessment section.
+        /// </summary>
+        public string Name { get; }
+
+        /// <summary>
+        /// Gets the geometry of the assessment section.
+        /// </summary>
+        public IEnumerable<Point2D> Geometry { get; }
+
+        /// <summary>
+        /// Gets the assembly result of the assessment section.
+        /// </summary>
+        public ExportableAssessmentSectionAssemblyResult AssessmentSectionAssembly { get; }
+
+        /// <summary>
+        /// Gets the collection of assembly results with probability of failure mechanisms belonging to this assessment section.
+        /// </summary>
+        public IEnumerable<ExportableFailureMechanism<ExportableFailureMechanismAssemblyResultWithProbability>> FailureMechanismsWithProbability { get; }
+
+        /// <summary>
+        /// Gets the collection of assembly results without probabiliyt of failure mechanisms belonging to this assessment section.
+        /// </summary>
+        public IEnumerable<ExportableFailureMechanism<ExportableFailureMechanismAssemblyResult>> FailureMechanismsWithoutProbability { get; }
+
+        /// <summary>
+        /// Gets the collection of combined section assembly results of this assessment section.
+        /// </summary>
+        public IEnumerable<ExportableCombinedSectionAssembly> CombinedSectionAssemblyResults { get; }
+    }
+}
\ No newline at end of file
Index: Ringtoets/Integration/src/Ringtoets.Integration.IO/Ringtoets.Integration.IO.csproj
===================================================================
diff -u -rab7637423891ead19190ff8be30751f23c7b31d4 -r719d0e6a2b96f912e844a16cfc96c4f7c8da62b7
--- Ringtoets/Integration/src/Ringtoets.Integration.IO/Ringtoets.Integration.IO.csproj	(.../Ringtoets.Integration.IO.csproj)	(revision ab7637423891ead19190ff8be30751f23c7b31d4)
+++ Ringtoets/Integration/src/Ringtoets.Integration.IO/Ringtoets.Integration.IO.csproj	(.../Ringtoets.Integration.IO.csproj)	(revision 719d0e6a2b96f912e844a16cfc96c4f7c8da62b7)
@@ -17,6 +17,7 @@
   <ItemGroup>
     <Compile Include="Assembly\ExportableAggregatedFailureMechanismSectionAssemblyResultBase.cs" />
     <Compile Include="Assembly\ExportableAggregatedFailureMechanismSectionAssemblyResultWithoutDetailedAssembly.cs" />
+    <Compile Include="Assembly\ExportableAssessmentSection.cs" />
     <Compile Include="Assembly\ExportableAssessmentSectionAssemblyResult.cs" />
     <Compile Include="Assembly\ExportableCombinedFailureMechanismSection.cs" />
     <Compile Include="Assembly\ExportableCombinedSectionAssembly.cs" />
Index: Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Assembly/ExportableAssessmentSectionTest.cs
===================================================================
diff -u
--- Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Assembly/ExportableAssessmentSectionTest.cs	(revision 0)
+++ Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Assembly/ExportableAssessmentSectionTest.cs	(revision 719d0e6a2b96f912e844a16cfc96c4f7c8da62b7)
@@ -0,0 +1,196 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Core.Common.Base.Geometry;
+using Core.Common.TestUtil;
+using NUnit.Framework;
+using Ringtoets.AssemblyTool.Data;
+using Ringtoets.Integration.IO.Assembly;
+
+namespace Ringtoets.Integration.IO.Test.Assembly
+{
+    [TestFixture]
+    public class ExportableAssessmentSectionTest
+    {
+        [Test]
+        public void Constructor_NameNull_ThrowsArgumentNullException()
+        {
+            // Setup
+            IEnumerable<Point2D> geometry = Enumerable.Empty<Point2D>();
+            ExportableAssessmentSectionAssemblyResult assessmentSectionAssembly = CreateAssessmentSectionAssembly();
+            IEnumerable<ExportableFailureMechanism<ExportableFailureMechanismAssemblyResultWithProbability>> failureMechanismsWithProbability =
+                Enumerable.Empty<ExportableFailureMechanism<ExportableFailureMechanismAssemblyResultWithProbability>>();
+            IEnumerable<ExportableFailureMechanism<ExportableFailureMechanismAssemblyResult>> failureMechanismsWithoutProbability =
+                Enumerable.Empty<ExportableFailureMechanism<ExportableFailureMechanismAssemblyResult>>();
+            IEnumerable<ExportableCombinedSectionAssembly> combinedSectionAssemblyResults = Enumerable.Empty<ExportableCombinedSectionAssembly>();
+
+            // Call
+            TestDelegate call = () => new ExportableAssessmentSection(null,
+                                                                      geometry,
+                                                                      assessmentSectionAssembly,
+                                                                      failureMechanismsWithProbability,
+                                                                      failureMechanismsWithoutProbability,
+                                                                      combinedSectionAssemblyResults);
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(call);
+            Assert.AreEqual("name", exception.ParamName);
+        }
+
+        [Test]
+        public void Constructor_GeometryNull_ThrowsArgumentNullException()
+        {
+            // Setup
+            ExportableAssessmentSectionAssemblyResult assessmentSectionAssembly = CreateAssessmentSectionAssembly();
+            IEnumerable<ExportableFailureMechanism<ExportableFailureMechanismAssemblyResultWithProbability>> failureMechanismsWithProbability =
+                Enumerable.Empty<ExportableFailureMechanism<ExportableFailureMechanismAssemblyResultWithProbability>>();
+            IEnumerable<ExportableFailureMechanism<ExportableFailureMechanismAssemblyResult>> failureMechanismsWithoutProbability =
+                Enumerable.Empty<ExportableFailureMechanism<ExportableFailureMechanismAssemblyResult>>();
+            IEnumerable<ExportableCombinedSectionAssembly> combinedSectionAssemblyResults = Enumerable.Empty<ExportableCombinedSectionAssembly>();
+
+            // Call
+            TestDelegate call = () => new ExportableAssessmentSection(string.Empty,
+                                                                      null,
+                                                                      assessmentSectionAssembly,
+                                                                      failureMechanismsWithProbability,
+                                                                      failureMechanismsWithoutProbability,
+                                                                      combinedSectionAssemblyResults);
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(call);
+            Assert.AreEqual("geometry", exception.ParamName);
+        }
+
+        [Test]
+        public void Constructor_AssessmentSectionAssemblyNull_ThrowsArgumentNullException()
+        {
+            // Setup
+            IEnumerable<Point2D> geometry = Enumerable.Empty<Point2D>();
+            IEnumerable<ExportableFailureMechanism<ExportableFailureMechanismAssemblyResultWithProbability>> failureMechanismsWithProbability =
+                Enumerable.Empty<ExportableFailureMechanism<ExportableFailureMechanismAssemblyResultWithProbability>>();
+            IEnumerable<ExportableFailureMechanism<ExportableFailureMechanismAssemblyResult>> failureMechanismsWithoutProbability =
+                Enumerable.Empty<ExportableFailureMechanism<ExportableFailureMechanismAssemblyResult>>();
+            IEnumerable<ExportableCombinedSectionAssembly> combinedSectionAssemblyResults = Enumerable.Empty<ExportableCombinedSectionAssembly>();
+
+            // Call
+            TestDelegate call = () => new ExportableAssessmentSection(string.Empty,
+                                                                      geometry,
+                                                                      null,
+                                                                      failureMechanismsWithProbability,
+                                                                      failureMechanismsWithoutProbability,
+                                                                      combinedSectionAssemblyResults);
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(call);
+            Assert.AreEqual("assessmentSectionAssembly", exception.ParamName);
+        }
+
+        [Test]
+        public void Constructor_FailureMechanismsWithProbabilityNull_ThrowsArgumentNullException()
+        {
+            // Setup
+            IEnumerable<Point2D> geometry = Enumerable.Empty<Point2D>();
+            ExportableAssessmentSectionAssemblyResult assessmentSectionAssembly = CreateAssessmentSectionAssembly();
+            IEnumerable<ExportableFailureMechanism<ExportableFailureMechanismAssemblyResult>> failureMechanismsWithoutProbability =
+                Enumerable.Empty<ExportableFailureMechanism<ExportableFailureMechanismAssemblyResult>>();
+            IEnumerable<ExportableCombinedSectionAssembly> combinedSectionAssemblyResults = Enumerable.Empty<ExportableCombinedSectionAssembly>();
+
+            // Call
+            TestDelegate call = () => new ExportableAssessmentSection(string.Empty,
+                                                                      geometry,
+                                                                      assessmentSectionAssembly,
+                                                                      null,
+                                                                      failureMechanismsWithoutProbability,
+                                                                      combinedSectionAssemblyResults);
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(call);
+            Assert.AreEqual("failureMechanismsWithProbability", exception.ParamName);
+        }
+
+        [Test]
+        public void Constructor_FailureMechanismsWithoutProbabilityNull_ThrowsArgumentNullException()
+        {
+            // Setup
+            IEnumerable<Point2D> geometry = Enumerable.Empty<Point2D>();
+            ExportableAssessmentSectionAssemblyResult assessmentSectionAssembly = CreateAssessmentSectionAssembly();
+            IEnumerable<ExportableFailureMechanism<ExportableFailureMechanismAssemblyResultWithProbability>> failureMechanismsWithProbability =
+                Enumerable.Empty<ExportableFailureMechanism<ExportableFailureMechanismAssemblyResultWithProbability>>();
+            IEnumerable<ExportableCombinedSectionAssembly> combinedSectionAssemblyResults = Enumerable.Empty<ExportableCombinedSectionAssembly>();
+
+            // Call
+            TestDelegate call = () => new ExportableAssessmentSection(string.Empty,
+                                                                      geometry,
+                                                                      assessmentSectionAssembly,
+                                                                      failureMechanismsWithProbability,
+                                                                      null,
+                                                                      combinedSectionAssemblyResults);
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(call);
+            Assert.AreEqual("failureMechanismsWithoutProbability", exception.ParamName);
+        }
+
+        [Test]
+        public void Constructor_CombinedSectionAssemblyResultsNull_ThrowsArgumentNullException()
+        {
+            // Setup
+            IEnumerable<Point2D> geometry = Enumerable.Empty<Point2D>();
+            ExportableAssessmentSectionAssemblyResult assessmentSectionAssembly = CreateAssessmentSectionAssembly();
+            IEnumerable<ExportableFailureMechanism<ExportableFailureMechanismAssemblyResultWithProbability>> failureMechanismsWithProbability =
+                Enumerable.Empty<ExportableFailureMechanism<ExportableFailureMechanismAssemblyResultWithProbability>>();
+            IEnumerable<ExportableFailureMechanism<ExportableFailureMechanismAssemblyResult>> failureMechanismsWithoutProbability =
+                Enumerable.Empty<ExportableFailureMechanism<ExportableFailureMechanismAssemblyResult>>();
+
+            // Call
+            TestDelegate call = () => new ExportableAssessmentSection(string.Empty,
+                                                                      geometry,
+                                                                      assessmentSectionAssembly,
+                                                                      failureMechanismsWithProbability,
+                                                                      failureMechanismsWithoutProbability,
+                                                                      null);
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(call);
+            Assert.AreEqual("combinedSectionAssemblyResults", exception.ParamName);
+        }
+
+        [Test]
+        [TestCase("")]
+        [TestCase("Valid name")]
+        public void Constructor_ExpectedValues(string name)
+        {
+            // Setup
+            IEnumerable<Point2D> geometry = Enumerable.Empty<Point2D>();
+            ExportableAssessmentSectionAssemblyResult assessmentSectionAssembly = CreateAssessmentSectionAssembly();
+            IEnumerable<ExportableFailureMechanism<ExportableFailureMechanismAssemblyResultWithProbability>> failureMechanismsWithProbability =
+                Enumerable.Empty<ExportableFailureMechanism<ExportableFailureMechanismAssemblyResultWithProbability>>();
+            IEnumerable<ExportableFailureMechanism<ExportableFailureMechanismAssemblyResult>> failureMechanismsWithoutProbability =
+                Enumerable.Empty<ExportableFailureMechanism<ExportableFailureMechanismAssemblyResult>>();
+            IEnumerable<ExportableCombinedSectionAssembly> combinedSectionAssemblyResults = Enumerable.Empty<ExportableCombinedSectionAssembly>();
+
+            // Call
+            var assessmentSection = new ExportableAssessmentSection(name,
+                                                                    geometry,
+                                                                    assessmentSectionAssembly,
+                                                                    failureMechanismsWithProbability,
+                                                                    failureMechanismsWithoutProbability,
+                                                                    combinedSectionAssemblyResults);
+
+            // Assert
+            Assert.AreEqual(name, assessmentSection.Name);
+            Assert.AreSame(geometry, assessmentSection.Geometry);
+            Assert.AreSame(assessmentSectionAssembly, assessmentSection.AssessmentSectionAssembly);
+            Assert.AreSame(failureMechanismsWithProbability, assessmentSection.FailureMechanismsWithProbability);
+            Assert.AreSame(failureMechanismsWithoutProbability, assessmentSection.FailureMechanismsWithoutProbability);
+            Assert.AreSame(combinedSectionAssemblyResults, assessmentSection.CombinedSectionAssemblyResults);
+        }
+
+        private static ExportableAssessmentSectionAssemblyResult CreateAssessmentSectionAssembly()
+        {
+            var random = new Random(21);
+            return new ExportableAssessmentSectionAssemblyResult(random.NextEnumValue<ExportableAssemblyMethod>(),
+                                                                 random.NextEnumValue<AssessmentSectionAssemblyCategoryGroup>());
+        }
+    }
+}
\ No newline at end of file
Index: Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Ringtoets.Integration.IO.Test.csproj
===================================================================
diff -u -rab7637423891ead19190ff8be30751f23c7b31d4 -r719d0e6a2b96f912e844a16cfc96c4f7c8da62b7
--- Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Ringtoets.Integration.IO.Test.csproj	(.../Ringtoets.Integration.IO.Test.csproj)	(revision ab7637423891ead19190ff8be30751f23c7b31d4)
+++ Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Ringtoets.Integration.IO.Test.csproj	(.../Ringtoets.Integration.IO.Test.csproj)	(revision 719d0e6a2b96f912e844a16cfc96c4f7c8da62b7)
@@ -22,6 +22,7 @@
     <Compile Include="Assembly\ExportableAggregatedFailureMechanismSectionAssemblyResultWithoutDetailedAssemblyTest.cs" />
     <Compile Include="Assembly\ExportableAggregatedFailureMechanismSectionAssemblyResultWithProbabilityTest.cs" />
     <Compile Include="Assembly\ExportableAssessmentSectionAssemblyResultTest.cs" />
+    <Compile Include="Assembly\ExportableAssessmentSectionTest.cs" />
     <Compile Include="Assembly\ExportableCombinedFailureMechanismSectionTest.cs" />
     <Compile Include="Assembly\ExportableFailureMechanismCombinedSectionAssemblyResultTest.cs" />
     <Compile Include="Assembly\ExportableCombinedSectionAssemblyTest.cs" />