diff --git a/src/GovUk.Education.ExploreEducationStatistics.Common.Tests/Converters/EnumToEnumValueListConverterTests.cs b/src/GovUk.Education.ExploreEducationStatistics.Common.Tests/Converters/EnumToEnumValueListConverterTests.cs
new file mode 100644
index 00000000000..980ea1ee350
--- /dev/null
+++ b/src/GovUk.Education.ExploreEducationStatistics.Common.Tests/Converters/EnumToEnumValueListConverterTests.cs
@@ -0,0 +1,46 @@
+#nullable enable
+using System.Diagnostics.CodeAnalysis;
+using GovUk.Education.ExploreEducationStatistics.Common.Converters;
+using GovUk.Education.ExploreEducationStatistics.Common.Database;
+using Xunit;
+
+namespace GovUk.Education.ExploreEducationStatistics.Common.Tests.Converters;
+
+public abstract class EnumToEnumValueListConverterTests
+{
+    [SuppressMessage("ReSharper", "UnusedMember.Local")]
+    private enum Numbers
+    {
+        [EnumLabelValue("1", "Value-1")] One,
+        [EnumLabelValue("2", "Value-2")] Two,
+        [EnumLabelValue("3", "Value-3")] Three
+    }
+
+    private readonly EnumToEnumValueListConverter<Numbers> _converter = new();
+
+    public class ConvertToProviderTests : EnumToEnumValueListConverterTests
+    {
+        [Fact]
+        public void Success()
+        {
+            var converted = _converter.ConvertToProviderTyped([Numbers.Two, Numbers.Three]);
+
+            Assert.Equal(2, converted.Count);
+            Assert.Equal("Value-2", converted[0]);
+            Assert.Equal("Value-3", converted[1]);
+        }
+    }
+
+    public class ConvertFromProviderTests : EnumToEnumValueListConverterTests
+    {
+        [Fact]
+        public void Success()
+        {
+            var converted = _converter.ConvertFromProviderTyped(["Value-1", "Value-2"]);
+
+            Assert.Equal(2, converted.Count);
+            Assert.Equal(Numbers.One, converted[0]);
+            Assert.Equal(Numbers.Two, converted[1]);
+        }
+    }
+}
diff --git a/src/GovUk.Education.ExploreEducationStatistics.Common/Comparers/ListValueComparer.cs b/src/GovUk.Education.ExploreEducationStatistics.Common/Comparers/ListValueComparer.cs
new file mode 100644
index 00000000000..9d24e604bec
--- /dev/null
+++ b/src/GovUk.Education.ExploreEducationStatistics.Common/Comparers/ListValueComparer.cs
@@ -0,0 +1,19 @@
+#nullable enable
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Microsoft.EntityFrameworkCore.ChangeTracking;
+
+namespace GovUk.Education.ExploreEducationStatistics.Common.Comparers;
+
+public class ListValueComparer<TValue>(IEqualityComparer<TValue>? equalityComparer = null)
+    : ValueComparer<List<TValue>>(
+        equalsExpression: (list, otherList) => list != null
+                                               && otherList != null
+                                               && list.SequenceEqual(otherList, equalityComparer),
+        hashCodeExpression: list => list.Aggregate(0, (acc, value) =>
+            value != null
+                ? HashCode.Combine(acc, value!.GetHashCode())
+                : acc),
+        snapshotExpression: list => list.ToList()
+    );
diff --git a/src/GovUk.Education.ExploreEducationStatistics.Common/Converters/EnumToEnumValueListConverter.cs b/src/GovUk.Education.ExploreEducationStatistics.Common/Converters/EnumToEnumValueListConverter.cs
new file mode 100644
index 00000000000..721a59abf9a
--- /dev/null
+++ b/src/GovUk.Education.ExploreEducationStatistics.Common/Converters/EnumToEnumValueListConverter.cs
@@ -0,0 +1,30 @@
+#nullable enable
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+namespace GovUk.Education.ExploreEducationStatistics.Common.Converters;
+
+public class EnumToEnumValueListConverter<TEnum>(ConverterMappingHints? mappingHints = null)
+    : ValueConverter<List<TEnum>, List<string>>(
+        value => ToProvider(value),
+        value => FromProvider(value),
+        mappingHints
+    )
+    where TEnum : Enum
+{
+    public static List<string> ToProvider(IList<TEnum> values)
+    {
+        return values
+            .Select(EnumToEnumValueConverter<TEnum>.ToProvider)
+            .ToList();
+    }
+
+    public static List<TEnum> FromProvider(IList<string> values)
+    {
+        return values
+            .Select(EnumToEnumValueConverter<TEnum>.FromProvider)
+            .ToList();
+    }
+}
diff --git a/src/GovUk.Education.ExploreEducationStatistics.Public.Data.Model.Tests/Fixtures/DataSetVersionGeneratorExtensions.cs b/src/GovUk.Education.ExploreEducationStatistics.Public.Data.Model.Tests/Fixtures/DataSetVersionGeneratorExtensions.cs
index 02b37912d6b..081d479a86b 100644
--- a/src/GovUk.Education.ExploreEducationStatistics.Public.Data.Model.Tests/Fixtures/DataSetVersionGeneratorExtensions.cs
+++ b/src/GovUk.Education.ExploreEducationStatistics.Public.Data.Model.Tests/Fixtures/DataSetVersionGeneratorExtensions.cs
@@ -150,30 +150,40 @@ public static Generator<DataSetVersion> WithTimePeriodMetas(
         Func<IEnumerable<TimePeriodMeta>> metas)
         => generator.ForInstance(s => s.SetTimePeriodMetas(metas));
 
-    public static Generator<DataSetVersion> WithFilterChanges(
+    public static Generator<DataSetVersion> WithFilterMetaChanges(
         this Generator<DataSetVersion> generator,
-        IEnumerable<ChangeSetFilters> filterChanges)
-        => generator.ForInstance(s => s.SetFilterChanges(filterChanges));
+        IEnumerable<FilterMetaChange> metaChanges)
+        => generator.ForInstance(s => s.SetFilterMetaChanges(metaChanges));
 
-    public static Generator<DataSetVersion> WithFilterOptionChanges(
+    public static Generator<DataSetVersion> WithFilterOptionMetaChanges(
         this Generator<DataSetVersion> generator,
-        IEnumerable<ChangeSetFilterOptions> filterOptionChanges)
-        => generator.ForInstance(s => s.SetFilterOptionChanges(filterOptionChanges));
+        IEnumerable<FilterOptionMetaChange> metaChanges)
+        => generator.ForInstance(s => s.SetFilterOptionMetaChanges(metaChanges));
 
-    public static Generator<DataSetVersion> WithIndicatorChanges(
+    public static Generator<DataSetVersion> WithGeographicLevelMetaChanges(
         this Generator<DataSetVersion> generator,
-        IEnumerable<ChangeSetIndicators> indicatorChanges)
-        => generator.ForInstance(s => s.SetIndicatorChanges(indicatorChanges));
+        GeographicLevelMetaChange metaChange)
+        => generator.ForInstance(s => s.SetGeographicLevelMetaChange(metaChange));
 
-    public static Generator<DataSetVersion> WithLocationChanges(
+    public static Generator<DataSetVersion> WithIndicatorMetaChanges(
         this Generator<DataSetVersion> generator,
-        IEnumerable<ChangeSetLocations> locationChanges)
-        => generator.ForInstance(s => s.SetLocationChanges(locationChanges));
+        IEnumerable<IndicatorMetaChange> metaChanges)
+        => generator.ForInstance(s => s.SetIndicatorMetaChanges(metaChanges));
 
-    public static Generator<DataSetVersion> WithTimePeriodChanges(
+    public static Generator<DataSetVersion> WithLocationMetaChanges(
         this Generator<DataSetVersion> generator,
-        IEnumerable<ChangeSetTimePeriods> timePeriodChanges)
-        => generator.ForInstance(s => s.SetTimePeriodChanges(timePeriodChanges));
+        IEnumerable<LocationMetaChange> metaChanges)
+        => generator.ForInstance(s => s.SetLocationMetaChanges(metaChanges));
+
+    public static Generator<DataSetVersion> WithLocationOptionMetaChanges(
+        this Generator<DataSetVersion> generator,
+        IEnumerable<LocationOptionMetaChange> metaChanges)
+        => generator.ForInstance(s => s.SetLocationOptionMetaChanges(metaChanges));
+    
+    public static Generator<DataSetVersion> WithTimePeriodMetaChanges(
+        this Generator<DataSetVersion> generator,
+        IEnumerable<TimePeriodMetaChange> metaChanges)
+        => generator.ForInstance(s => s.SetTimePeriodMetaChanges(metaChanges));
 
     public static Generator<DataSetVersion> WithPreviewTokens(
         this Generator<DataSetVersion> generator,
@@ -408,81 +418,110 @@ public static InstanceSetters<DataSetVersion> SetTimePeriodMetas(
             }
         );
 
-    public static InstanceSetters<DataSetVersion> SetFilterChanges(
+    public static InstanceSetters<DataSetVersion> SetFilterMetaChanges(
         this InstanceSetters<DataSetVersion> instanceSetter,
-        IEnumerable<ChangeSetFilters> filterChanges)
+        IEnumerable<FilterMetaChange> filterChanges)
         => instanceSetter.Set(
-            dsv => dsv.FilterChanges,
+            dsv => dsv.FilterMetaChanges,
             (_, dsv) => filterChanges.Select(
-                    changeSet =>
+                    change =>
                     {
-                        changeSet.DataSetVersionId = dsv.Id;
-                        changeSet.DataSetVersion = dsv;
-                        return changeSet;
+                        change.DataSetVersion = dsv;
+                        change.DataSetVersionId = dsv.Id;
+                        return change;
                     }
                 )
                 .ToList()
         );
 
-    public static InstanceSetters<DataSetVersion> SetFilterOptionChanges(
+    public static InstanceSetters<DataSetVersion> SetFilterOptionMetaChanges(
         this InstanceSetters<DataSetVersion> instanceSetter,
-        IEnumerable<ChangeSetFilterOptions> filterOptionChanges)
+        IEnumerable<FilterOptionMetaChange> filterOptionChanges)
         => instanceSetter.Set(
-            dsv => dsv.FilterOptionChanges,
+            dsv => dsv.FilterOptionMetaChanges,
             (_, dsv) => filterOptionChanges.Select(
-                    changeSet =>
+                    change =>
                     {
-                        changeSet.DataSetVersionId = dsv.Id;
-                        changeSet.DataSetVersion = dsv;
-                        return changeSet;
+                        change.DataSetVersion = dsv;
+                        change.DataSetVersionId = dsv.Id;
+                        return change;
                     }
                 )
                 .ToList()
         );
+    
+    public static InstanceSetters<DataSetVersion> SetGeographicLevelMetaChange(
+        this InstanceSetters<DataSetVersion> instanceSetter,
+        GeographicLevelMetaChange change)
+        => instanceSetter.Set(
+            dsv => dsv.GeographicLevelMetaChange,
+            (_, dsv) =>
+            {
+                change.DataSetVersion = dsv;
+                change.DataSetVersionId = dsv.Id;
+                return change;
+            }
+        );
 
-    public static InstanceSetters<DataSetVersion> SetIndicatorChanges(
+    public static InstanceSetters<DataSetVersion> SetIndicatorMetaChanges(
         this InstanceSetters<DataSetVersion> instanceSetter,
-        IEnumerable<ChangeSetIndicators> indicatorChanges)
+        IEnumerable<IndicatorMetaChange> indicatorChanges)
         => instanceSetter.Set(
-            dsv => dsv.IndicatorChanges,
+            dsv => dsv.IndicatorMetaChanges,
             (_, dsv) => indicatorChanges.Select(
-                    changeSet =>
+                    change =>
                     {
-                        changeSet.DataSetVersionId = dsv.Id;
-                        changeSet.DataSetVersion = dsv;
-                        return changeSet;
+                        change.DataSetVersion = dsv;
+                        change.DataSetVersionId = dsv.Id;
+                        return change;
                     }
                 )
                 .ToList()
         );
 
-    public static InstanceSetters<DataSetVersion> SetLocationChanges(
+    public static InstanceSetters<DataSetVersion> SetLocationMetaChanges(
         this InstanceSetters<DataSetVersion> instanceSetter,
-        IEnumerable<ChangeSetLocations> locationChanges)
+        IEnumerable<LocationMetaChange> locationChanges)
         => instanceSetter.Set(
-            dsv => dsv.LocationChanges,
+            dsv => dsv.LocationMetaChanges,
             (_, dsv) => locationChanges.Select(
-                    changeSet =>
+                    change =>
+                    {
+                        change.DataSetVersion = dsv;
+                        change.DataSetVersionId = dsv.Id;
+                        return change;
+                    }
+                )
+                .ToList()
+        );
+
+    public static InstanceSetters<DataSetVersion> SetLocationOptionMetaChanges(
+        this InstanceSetters<DataSetVersion> instanceSetter,
+        IEnumerable<LocationOptionMetaChange> locationOptionChanges)
+        => instanceSetter.Set(
+            dsv => dsv.LocationOptionMetaChanges,
+            (_, dsv) => locationOptionChanges.Select(
+                    change =>
                     {
-                        changeSet.DataSetVersionId = dsv.Id;
-                        changeSet.DataSetVersion = dsv;
-                        return changeSet;
+                        change.DataSetVersion = dsv;
+                        change.DataSetVersionId = dsv.Id;
+                        return change;
                     }
                 )
                 .ToList()
         );
 
-    public static InstanceSetters<DataSetVersion> SetTimePeriodChanges(
+    public static InstanceSetters<DataSetVersion> SetTimePeriodMetaChanges(
         this InstanceSetters<DataSetVersion> instanceSetter,
-        IEnumerable<ChangeSetTimePeriods> timePeriodChanges)
+        IEnumerable<TimePeriodMetaChange> timePeriodChanges)
         => instanceSetter.Set(
-            dsv => dsv.TimePeriodChanges,
+            dsv => dsv.TimePeriodMetaChanges,
             (_, dsv) => timePeriodChanges.Select(
-                    changeSet =>
+                    change =>
                     {
-                        changeSet.DataSetVersionId = dsv.Id;
-                        changeSet.DataSetVersion = dsv;
-                        return changeSet;
+                        change.DataSetVersion = dsv;
+                        change.DataSetVersionId = dsv.Id;
+                        return change;
                     }
                 )
                 .ToList()
diff --git a/src/GovUk.Education.ExploreEducationStatistics.Public.Data.Model.Tests/Fixtures/FilterMetaChangeGeneratorExtensions.cs b/src/GovUk.Education.ExploreEducationStatistics.Public.Data.Model.Tests/Fixtures/FilterMetaChangeGeneratorExtensions.cs
new file mode 100644
index 00000000000..286c4e6df12
--- /dev/null
+++ b/src/GovUk.Education.ExploreEducationStatistics.Public.Data.Model.Tests/Fixtures/FilterMetaChangeGeneratorExtensions.cs
@@ -0,0 +1,104 @@
+using GovUk.Education.ExploreEducationStatistics.Common.Tests.Fixtures;
+
+namespace GovUk.Education.ExploreEducationStatistics.Public.Data.Model.Tests.Fixtures;
+
+public static class FilterMetaChangeGeneratorExtensions
+{
+    public static Generator<FilterMetaChange> DefaultFilterMetaChange(this DataFixture fixture)
+        => fixture
+            .Generator<FilterMetaChange>()
+            .WithDefaults();
+
+    public static Generator<FilterMetaChange> WithDefaults(this Generator<FilterMetaChange> generator)
+        => generator.ForInstance(s => s.SetDefaults());
+
+    public static Generator<FilterMetaChange> WithDataSetVersion(
+        this Generator<FilterMetaChange> generator,
+        Func<DataSetVersion> dataSetVersion)
+        => generator.ForInstance(s => s.SetDataSetVersion(dataSetVersion));
+
+    public static Generator<FilterMetaChange> WithDataSetVersionId(
+        this Generator<FilterMetaChange> generator,
+        Guid dataSetVersionId)
+        => generator.ForInstance(s => s.SetDataSetVersionId(dataSetVersionId));
+
+    public static Generator<FilterMetaChange> WithCurrentState(
+        this Generator<FilterMetaChange> generator,
+        FilterMeta? currentState)
+        => generator.ForInstance(s => s.SetCurrentState(currentState));
+
+    public static Generator<FilterMetaChange> WithCurrentState(
+        this Generator<FilterMetaChange> generator,
+        Func<FilterMeta?> currentState)
+        => generator.ForInstance(s => s.SetCurrentState(currentState));
+
+    public static Generator<FilterMetaChange> WithCurrentStateId(
+        this Generator<FilterMetaChange> generator,
+        int? currentStateId)
+        => generator.ForInstance(s => s.SetCurrentStateId(currentStateId));
+
+    public static Generator<FilterMetaChange> WithPreviousState(
+        this Generator<FilterMetaChange> generator,
+        FilterMeta? previousState)
+        => generator.ForInstance(s => s.SetPreviousState(previousState));
+    
+    public static Generator<FilterMetaChange> WithPreviousState(
+        this Generator<FilterMetaChange> generator,
+        Func<FilterMeta?> previousState)
+        => generator.ForInstance(s => s.SetPreviousState(previousState));
+
+    public static Generator<FilterMetaChange> WithPreviousStateId(
+        this Generator<FilterMetaChange> generator,
+        int? previousStateId)
+        => generator.ForInstance(s => s.SetPreviousStateId(previousStateId));
+
+    public static InstanceSetters<FilterMetaChange> SetDefaults(this InstanceSetters<FilterMetaChange> setters)
+        => setters
+            .SetDefault(c => c.DataSetVersionId);
+
+    public static InstanceSetters<FilterMetaChange> SetDataSetVersion(
+        this InstanceSetters<FilterMetaChange> setters,
+        Func<DataSetVersion> dataSetVersion)
+        => setters
+            .Set(c => c.DataSetVersion, dataSetVersion)
+            .Set(c => c.DataSetVersionId, (_, f) => f.DataSetVersion.Id);
+
+    public static InstanceSetters<FilterMetaChange> SetDataSetVersionId(
+        this InstanceSetters<FilterMetaChange> setters,
+        Guid dataSetVersionId)
+        => setters.Set(c => c.DataSetVersionId, dataSetVersionId);
+
+    public static InstanceSetters<FilterMetaChange> SetCurrentState(
+        this InstanceSetters<FilterMetaChange> setters,
+        FilterMeta? currentState)
+        => setters.SetCurrentState(() => currentState);
+
+    public static InstanceSetters<FilterMetaChange> SetCurrentState(
+        this InstanceSetters<FilterMetaChange> setters,
+        Func<FilterMeta?> currentState)
+        => setters
+            .Set(c => c.CurrentState, currentState)
+            .Set(c => c.CurrentStateId, (_, f) => f.CurrentState?.Id);
+
+    public static InstanceSetters<FilterMetaChange> SetCurrentStateId(
+        this InstanceSetters<FilterMetaChange> setters,
+        int? currentStateId)
+        => setters.Set(c => c.CurrentStateId, currentStateId);
+
+    public static InstanceSetters<FilterMetaChange> SetPreviousState(
+        this InstanceSetters<FilterMetaChange> setters,
+        FilterMeta? previousState)
+        => setters.SetPreviousState(() => previousState);
+
+    public static InstanceSetters<FilterMetaChange> SetPreviousState(
+        this InstanceSetters<FilterMetaChange> setters,
+        Func<FilterMeta?> previousState)
+        => setters
+            .Set(c => c.PreviousState, previousState)
+            .Set(c => c.PreviousStateId, (_, f) => f.PreviousState?.Id);
+
+    public static InstanceSetters<FilterMetaChange> SetPreviousStateId(
+        this InstanceSetters<FilterMetaChange> setters,
+        int? previousStateId)
+        => setters.Set(c => c.PreviousStateId, previousStateId);
+}
diff --git a/src/GovUk.Education.ExploreEducationStatistics.Public.Data.Model.Tests/Fixtures/FilterOptionMetaChangeGeneratorExtensions.cs b/src/GovUk.Education.ExploreEducationStatistics.Public.Data.Model.Tests/Fixtures/FilterOptionMetaChangeGeneratorExtensions.cs
new file mode 100644
index 00000000000..b4d6462b1b0
--- /dev/null
+++ b/src/GovUk.Education.ExploreEducationStatistics.Public.Data.Model.Tests/Fixtures/FilterOptionMetaChangeGeneratorExtensions.cs
@@ -0,0 +1,147 @@
+using GovUk.Education.ExploreEducationStatistics.Common.Tests.Fixtures;
+
+namespace GovUk.Education.ExploreEducationStatistics.Public.Data.Model.Tests.Fixtures;
+
+public static class FilterOptionMetaChangeGeneratorExtensions
+{
+    public static Generator<FilterOptionMetaChange> DefaultFilterOptionMetaChange(this DataFixture fixture)
+        => fixture
+            .Generator<FilterOptionMetaChange>()
+            .WithDefaults();
+
+    public static Generator<FilterOptionMetaChange> WithDefaults(this Generator<FilterOptionMetaChange> generator)
+        => generator.ForInstance(s => s.SetDefaults());
+
+    public static Generator<FilterOptionMetaChange> WithDataSetVersion(
+        this Generator<FilterOptionMetaChange> generator,
+        Func<DataSetVersion> dataSetVersion)
+        => generator.ForInstance(s => s.SetDataSetVersion(dataSetVersion));
+
+    public static Generator<FilterOptionMetaChange> WithDataSetVersionId(
+        this Generator<FilterOptionMetaChange> generator,
+        Guid dataSetVersionId)
+        => generator.ForInstance(s => s.SetDataSetVersionId(dataSetVersionId));
+
+    public static Generator<FilterOptionMetaChange> WithCurrentState(
+        this Generator<FilterOptionMetaChange> generator,
+        FilterOptionMetaLink? currentState)
+        => generator.ForInstance(s => s.SetCurrentState(currentState));
+
+    public static Generator<FilterOptionMetaChange> WithCurrentState(
+        this Generator<FilterOptionMetaChange> generator,
+        Func<FilterOptionMetaLink?> currentState)
+        => generator.ForInstance(s => s.SetCurrentState(currentState));
+
+    public static Generator<FilterOptionMetaChange> WithCurrentState(
+        this Generator<FilterOptionMetaChange> generator,
+        FilterOptionMetaChange.State? currentState)
+        => generator.ForInstance(s => s.SetCurrentState(currentState));
+
+    public static Generator<FilterOptionMetaChange> WithCurrentState(
+        this Generator<FilterOptionMetaChange> generator,
+        Func<FilterOptionMetaChange.State?> currentState)
+        => generator.ForInstance(s => s.SetCurrentState(currentState));
+
+    public static Generator<FilterOptionMetaChange> WithPreviousState(
+        this Generator<FilterOptionMetaChange> generator,
+        FilterOptionMetaLink? previousState)
+        => generator.ForInstance(s => s.SetPreviousState(previousState));
+
+    public static Generator<FilterOptionMetaChange> WithPreviousState(
+        this Generator<FilterOptionMetaChange> generator,
+        Func<FilterOptionMetaLink?> previousState)
+        => generator.ForInstance(s => s.SetPreviousState(previousState));
+
+    public static Generator<FilterOptionMetaChange> WithPreviousState(
+        this Generator<FilterOptionMetaChange> generator,
+        FilterOptionMetaChange.State? previousState)
+        => generator.ForInstance(s => s.SetPreviousState(previousState));
+
+    public static Generator<FilterOptionMetaChange> WithPreviousState(
+        this Generator<FilterOptionMetaChange> generator,
+        Func<FilterOptionMetaChange.State?> previousState)
+        => generator.ForInstance(s => s.SetPreviousState(previousState));
+
+    public static InstanceSetters<FilterOptionMetaChange> SetDefaults(
+        this InstanceSetters<FilterOptionMetaChange> setters)
+        => setters
+            .SetDefault(c => c.DataSetVersionId);
+
+    public static InstanceSetters<FilterOptionMetaChange> SetDataSetVersion(
+        this InstanceSetters<FilterOptionMetaChange> setters,
+        Func<DataSetVersion> dataSetVersion)
+        => setters
+            .Set(c => c.DataSetVersion, dataSetVersion)
+            .Set(c => c.DataSetVersionId, (_, f) => f.DataSetVersion.Id);
+
+    public static InstanceSetters<FilterOptionMetaChange> SetDataSetVersionId(
+        this InstanceSetters<FilterOptionMetaChange> setters,
+        Guid dataSetVersionId)
+        => setters.Set(c => c.DataSetVersionId, dataSetVersionId);
+
+    public static InstanceSetters<FilterOptionMetaChange> SetCurrentState(
+        this InstanceSetters<FilterOptionMetaChange> setters,
+        FilterOptionMetaLink? currentState)
+        => setters.SetCurrentState(() => currentState);
+
+    public static InstanceSetters<FilterOptionMetaChange> SetCurrentState(
+        this InstanceSetters<FilterOptionMetaChange> setters,
+        Func<FilterOptionMetaLink?> currentState)
+    {
+        var current = currentState();
+
+        return current is not null
+            ? setters.SetCurrentState(
+                new FilterOptionMetaChange.State
+                {
+                    MetaId = current.MetaId,
+                    OptionId = current.OptionId,
+                    PublicId = current.PublicId
+                }
+            )
+            : setters;
+    }
+
+    public static InstanceSetters<FilterOptionMetaChange> SetCurrentState(
+        this InstanceSetters<FilterOptionMetaChange> setters,
+        FilterOptionMetaChange.State? currentState)
+        => setters.Set(c => c.CurrentState, currentState);
+
+    public static InstanceSetters<FilterOptionMetaChange> SetCurrentState(
+        this InstanceSetters<FilterOptionMetaChange> setters,
+        Func<FilterOptionMetaChange.State?> currentState)
+        => setters.Set(c => c.CurrentState, currentState);
+
+    public static InstanceSetters<FilterOptionMetaChange> SetPreviousState(
+        this InstanceSetters<FilterOptionMetaChange> setters,
+        FilterOptionMetaLink? previousState)
+        => setters.SetPreviousState(() => previousState);
+
+    public static InstanceSetters<FilterOptionMetaChange> SetPreviousState(
+        this InstanceSetters<FilterOptionMetaChange> setters,
+        Func<FilterOptionMetaLink?> previousState)
+    {
+        var previous = previousState();
+
+        return previous is not null
+            ? setters.SetPreviousState(
+                new FilterOptionMetaChange.State
+                {
+                    MetaId = previous.MetaId,
+                    OptionId = previous.OptionId,
+                    PublicId = previous.PublicId
+                }
+            )
+            : setters;
+    }
+
+    public static InstanceSetters<FilterOptionMetaChange> SetPreviousState(
+        this InstanceSetters<FilterOptionMetaChange> setters,
+        FilterOptionMetaChange.State? previousState)
+        => setters.Set(c => c.PreviousState, previousState);
+
+    public static InstanceSetters<FilterOptionMetaChange> SetPreviousState(
+        this InstanceSetters<FilterOptionMetaChange> setters,
+        Func<FilterOptionMetaChange.State?> previousState)
+        => setters.Set(c => c.PreviousState, previousState);
+}
diff --git a/src/GovUk.Education.ExploreEducationStatistics.Public.Data.Model.Tests/Fixtures/GeographicLevelMetaChangeGeneratorExtensions.cs b/src/GovUk.Education.ExploreEducationStatistics.Public.Data.Model.Tests/Fixtures/GeographicLevelMetaChangeGeneratorExtensions.cs
new file mode 100644
index 00000000000..6bbb5b180ac
--- /dev/null
+++ b/src/GovUk.Education.ExploreEducationStatistics.Public.Data.Model.Tests/Fixtures/GeographicLevelMetaChangeGeneratorExtensions.cs
@@ -0,0 +1,106 @@
+using GovUk.Education.ExploreEducationStatistics.Common.Tests.Fixtures;
+
+namespace GovUk.Education.ExploreEducationStatistics.Public.Data.Model.Tests.Fixtures;
+
+public static class GeographicLevelMetaChangeGeneratorExtensions
+{
+    public static Generator<GeographicLevelMetaChange> DefaultGeographicLevelMetaChange(this DataFixture fixture)
+        => fixture
+            .Generator<GeographicLevelMetaChange>()
+            .WithDefaults();
+
+    public static Generator<GeographicLevelMetaChange> WithDefaults(
+        this Generator<GeographicLevelMetaChange> generator)
+        => generator.ForInstance(s => s.SetDefaults());
+
+    public static Generator<GeographicLevelMetaChange> WithDataSetVersion(
+        this Generator<GeographicLevelMetaChange> generator,
+        Func<DataSetVersion> dataSetVersion)
+        => generator.ForInstance(s => s.SetDataSetVersion(dataSetVersion));
+
+    public static Generator<GeographicLevelMetaChange> WithDataSetVersionId(
+        this Generator<GeographicLevelMetaChange> generator,
+        Guid dataSetVersionId)
+        => generator.ForInstance(s => s.SetDataSetVersionId(dataSetVersionId));
+
+    public static Generator<GeographicLevelMetaChange> WithCurrentState(
+        this Generator<GeographicLevelMetaChange> generator,
+        GeographicLevelMeta? currentState)
+        => generator.ForInstance(s => s.SetCurrentState(currentState));
+
+    public static Generator<GeographicLevelMetaChange> WithCurrentState(
+        this Generator<GeographicLevelMetaChange> generator,
+        Func<GeographicLevelMeta?> currentState)
+        => generator.ForInstance(s => s.SetCurrentState(currentState));
+
+    public static Generator<GeographicLevelMetaChange> WithCurrentStateId(
+        this Generator<GeographicLevelMetaChange> generator,
+        int? currentStateId)
+        => generator.ForInstance(s => s.SetCurrentStateId(currentStateId));
+
+    public static Generator<GeographicLevelMetaChange> WithPreviousState(
+        this Generator<GeographicLevelMetaChange> generator,
+        GeographicLevelMeta? previousState)
+        => generator.ForInstance(s => s.SetPreviousState(previousState));
+
+    public static Generator<GeographicLevelMetaChange> WithPreviousState(
+        this Generator<GeographicLevelMetaChange> generator,
+        Func<GeographicLevelMeta?> previousState)
+        => generator.ForInstance(s => s.SetPreviousState(previousState));
+
+    public static Generator<GeographicLevelMetaChange> WithPreviousStateId(
+        this Generator<GeographicLevelMetaChange> generator,
+        int? previousStateId)
+        => generator.ForInstance(s => s.SetPreviousStateId(previousStateId));
+
+    public static InstanceSetters<GeographicLevelMetaChange> SetDefaults(
+        this InstanceSetters<GeographicLevelMetaChange> setters)
+        => setters
+            .SetDefault(c => c.DataSetVersionId);
+
+    public static InstanceSetters<GeographicLevelMetaChange> SetDataSetVersion(
+        this InstanceSetters<GeographicLevelMetaChange> setters,
+        Func<DataSetVersion> dataSetVersion)
+        => setters
+            .Set(c => c.DataSetVersion, dataSetVersion)
+            .Set(c => c.DataSetVersionId, (_, f) => f.DataSetVersion.Id);
+
+    public static InstanceSetters<GeographicLevelMetaChange> SetDataSetVersionId(
+        this InstanceSetters<GeographicLevelMetaChange> setters,
+        Guid dataSetVersionId)
+        => setters.Set(c => c.DataSetVersionId, dataSetVersionId);
+
+    public static InstanceSetters<GeographicLevelMetaChange> SetCurrentState(
+        this InstanceSetters<GeographicLevelMetaChange> setters,
+        GeographicLevelMeta? currentState)
+        => setters.SetCurrentState(() => currentState);
+
+    public static InstanceSetters<GeographicLevelMetaChange> SetCurrentState(
+        this InstanceSetters<GeographicLevelMetaChange> setters,
+        Func<GeographicLevelMeta?> currentState)
+        => setters
+            .Set(c => c.CurrentState, currentState)
+            .Set(c => c.CurrentStateId, (_, f) => f.CurrentState?.Id);
+
+    public static InstanceSetters<GeographicLevelMetaChange> SetCurrentStateId(
+        this InstanceSetters<GeographicLevelMetaChange> setters,
+        int? currentStateId)
+        => setters.Set(c => c.CurrentStateId, currentStateId);
+
+    public static InstanceSetters<GeographicLevelMetaChange> SetPreviousState(
+        this InstanceSetters<GeographicLevelMetaChange> setters,
+        GeographicLevelMeta? currentState)
+        => setters.SetPreviousState(() => currentState);
+
+    public static InstanceSetters<GeographicLevelMetaChange> SetPreviousState(
+        this InstanceSetters<GeographicLevelMetaChange> setters,
+        Func<GeographicLevelMeta?> previousState)
+        => setters
+            .Set(c => c.PreviousState, previousState)
+            .Set(c => c.PreviousStateId, (_, f) => f.PreviousState?.Id);
+
+    public static InstanceSetters<GeographicLevelMetaChange> SetPreviousStateId(
+        this InstanceSetters<GeographicLevelMetaChange> setters,
+        int? previousStateId)
+        => setters.Set(c => c.PreviousStateId, previousStateId);
+}
diff --git a/src/GovUk.Education.ExploreEducationStatistics.Public.Data.Model.Tests/Fixtures/IndicatorMetaChangeGeneratorExtensions.cs b/src/GovUk.Education.ExploreEducationStatistics.Public.Data.Model.Tests/Fixtures/IndicatorMetaChangeGeneratorExtensions.cs
new file mode 100644
index 00000000000..a015fc185ff
--- /dev/null
+++ b/src/GovUk.Education.ExploreEducationStatistics.Public.Data.Model.Tests/Fixtures/IndicatorMetaChangeGeneratorExtensions.cs
@@ -0,0 +1,104 @@
+using GovUk.Education.ExploreEducationStatistics.Common.Tests.Fixtures;
+
+namespace GovUk.Education.ExploreEducationStatistics.Public.Data.Model.Tests.Fixtures;
+
+public static class IndicatorMetaChangeGeneratorExtensions
+{
+    public static Generator<IndicatorMetaChange> DefaultIndicatorMetaChange(this DataFixture fixture)
+        => fixture
+            .Generator<IndicatorMetaChange>()
+            .WithDefaults();
+
+    public static Generator<IndicatorMetaChange> WithDefaults(this Generator<IndicatorMetaChange> generator)
+        => generator.ForInstance(s => s.SetDefaults());
+
+    public static Generator<IndicatorMetaChange> WithDataSetVersion(
+        this Generator<IndicatorMetaChange> generator,
+        Func<DataSetVersion> dataSetVersion)
+        => generator.ForInstance(s => s.SetDataSetVersion(dataSetVersion));
+
+    public static Generator<IndicatorMetaChange> WithDataSetVersionId(
+        this Generator<IndicatorMetaChange> generator,
+        Guid dataSetVersionId)
+        => generator.ForInstance(s => s.SetDataSetVersionId(dataSetVersionId));
+
+    public static Generator<IndicatorMetaChange> WithCurrentState(
+        this Generator<IndicatorMetaChange> generator,
+        IndicatorMeta? currentState)
+        => generator.ForInstance(s => s.SetCurrentState(currentState));
+
+    public static Generator<IndicatorMetaChange> WithCurrentState(
+        this Generator<IndicatorMetaChange> generator,
+        Func<IndicatorMeta?> currentState)
+        => generator.ForInstance(s => s.SetCurrentState(currentState));
+
+    public static Generator<IndicatorMetaChange> WithCurrentStateId(
+        this Generator<IndicatorMetaChange> generator,
+        int? currentStateId)
+        => generator.ForInstance(s => s.SetCurrentStateId(currentStateId));
+
+    public static Generator<IndicatorMetaChange> WithPreviousState(
+        this Generator<IndicatorMetaChange> generator,
+        IndicatorMeta? previousState)
+        => generator.ForInstance(s => s.SetPreviousState(previousState));
+
+    public static Generator<IndicatorMetaChange> WithPreviousState(
+        this Generator<IndicatorMetaChange> generator,
+        Func<IndicatorMeta?> previousState)
+        => generator.ForInstance(s => s.SetPreviousState(previousState));
+
+    public static Generator<IndicatorMetaChange> WithPreviousStateId(
+        this Generator<IndicatorMetaChange> generator,
+        int? previousStateId)
+        => generator.ForInstance(s => s.SetPreviousStateId(previousStateId));
+
+    public static InstanceSetters<IndicatorMetaChange> SetDefaults(this InstanceSetters<IndicatorMetaChange> setters)
+        => setters
+            .SetDefault(c => c.DataSetVersionId);
+
+    public static InstanceSetters<IndicatorMetaChange> SetDataSetVersion(
+        this InstanceSetters<IndicatorMetaChange> setters,
+        Func<DataSetVersion> dataSetVersion)
+        => setters
+            .Set(c => c.DataSetVersion, dataSetVersion)
+            .Set(c => c.DataSetVersionId, (_, f) => f.DataSetVersion.Id);
+
+    public static InstanceSetters<IndicatorMetaChange> SetDataSetVersionId(
+        this InstanceSetters<IndicatorMetaChange> setters,
+        Guid dataSetVersionId)
+        => setters.Set(c => c.DataSetVersionId, dataSetVersionId);
+
+    public static InstanceSetters<IndicatorMetaChange> SetCurrentState(
+        this InstanceSetters<IndicatorMetaChange> setters,
+        IndicatorMeta? currentState)
+        => setters.SetCurrentState(() => currentState);
+
+    public static InstanceSetters<IndicatorMetaChange> SetCurrentState(
+        this InstanceSetters<IndicatorMetaChange> setters,
+        Func<IndicatorMeta?> currentState)
+        => setters
+            .Set(c => c.CurrentState, currentState)
+            .Set(c => c.CurrentStateId, (_, f) => f.CurrentState?.Id);
+
+    public static InstanceSetters<IndicatorMetaChange> SetCurrentStateId(
+        this InstanceSetters<IndicatorMetaChange> setters,
+        int? currentStateId)
+        => setters.Set(c => c.CurrentStateId, currentStateId);
+
+    public static InstanceSetters<IndicatorMetaChange> SetPreviousState(
+        this InstanceSetters<IndicatorMetaChange> setters,
+        IndicatorMeta? previousState)
+        => setters.SetPreviousState(() => previousState);
+
+    public static InstanceSetters<IndicatorMetaChange> SetPreviousState(
+        this InstanceSetters<IndicatorMetaChange> setters,
+        Func<IndicatorMeta?> previousState)
+        => setters
+            .Set(c => c.PreviousState, previousState)
+            .Set(c => c.PreviousStateId, (_, f) => f.PreviousState?.Id);
+
+    public static InstanceSetters<IndicatorMetaChange> SetPreviousStateId(
+        this InstanceSetters<IndicatorMetaChange> setters,
+        int? previousStateId)
+        => setters.Set(c => c.PreviousStateId, previousStateId);
+}
diff --git a/src/GovUk.Education.ExploreEducationStatistics.Public.Data.Model.Tests/Fixtures/LocationMetaChangeGeneratorExtensions.cs b/src/GovUk.Education.ExploreEducationStatistics.Public.Data.Model.Tests/Fixtures/LocationMetaChangeGeneratorExtensions.cs
new file mode 100644
index 00000000000..68d2a943cd7
--- /dev/null
+++ b/src/GovUk.Education.ExploreEducationStatistics.Public.Data.Model.Tests/Fixtures/LocationMetaChangeGeneratorExtensions.cs
@@ -0,0 +1,104 @@
+using GovUk.Education.ExploreEducationStatistics.Common.Tests.Fixtures;
+
+namespace GovUk.Education.ExploreEducationStatistics.Public.Data.Model.Tests.Fixtures;
+
+public static class LocationMetaChangeGeneratorExtensions
+{
+    public static Generator<LocationMetaChange> DefaultLocationMetaChange(this DataFixture fixture)
+        => fixture
+            .Generator<LocationMetaChange>()
+            .WithDefaults();
+
+    public static Generator<LocationMetaChange> WithDefaults(this Generator<LocationMetaChange> generator)
+        => generator.ForInstance(s => s.SetDefaults());
+
+    public static Generator<LocationMetaChange> WithDataSetVersion(
+        this Generator<LocationMetaChange> generator,
+        Func<DataSetVersion> dataSetVersion)
+        => generator.ForInstance(s => s.SetDataSetVersion(dataSetVersion));
+
+    public static Generator<LocationMetaChange> WithDataSetVersionId(
+        this Generator<LocationMetaChange> generator,
+        Guid dataSetVersionId)
+        => generator.ForInstance(s => s.SetDataSetVersionId(dataSetVersionId));
+
+    public static Generator<LocationMetaChange> WithCurrentState(
+        this Generator<LocationMetaChange> generator,
+        LocationMeta? currentState)
+        => generator.ForInstance(s => s.SetCurrentState(currentState));
+
+    public static Generator<LocationMetaChange> WithCurrentState(
+        this Generator<LocationMetaChange> generator,
+        Func<LocationMeta?> currentState)
+        => generator.ForInstance(s => s.SetCurrentState(currentState));
+
+    public static Generator<LocationMetaChange> WithCurrentStateId(
+        this Generator<LocationMetaChange> generator,
+        int? currentStateId)
+        => generator.ForInstance(s => s.SetCurrentStateId(currentStateId));
+
+    public static Generator<LocationMetaChange> WithPreviousState(
+        this Generator<LocationMetaChange> generator,
+        LocationMeta? previousState)
+        => generator.ForInstance(s => s.SetPreviousState(previousState));
+
+    public static Generator<LocationMetaChange> WithPreviousState(
+        this Generator<LocationMetaChange> generator,
+        Func<LocationMeta?> previousState)
+        => generator.ForInstance(s => s.SetPreviousState(previousState));
+
+    public static Generator<LocationMetaChange> WithPreviousStateId(
+        this Generator<LocationMetaChange> generator,
+        int? previousStateId)
+        => generator.ForInstance(s => s.SetPreviousStateId(previousStateId));
+
+    public static InstanceSetters<LocationMetaChange> SetDefaults(this InstanceSetters<LocationMetaChange> setters)
+        => setters
+            .SetDefault(c => c.DataSetVersionId);
+
+    public static InstanceSetters<LocationMetaChange> SetDataSetVersion(
+        this InstanceSetters<LocationMetaChange> setters,
+        Func<DataSetVersion> dataSetVersion)
+        => setters
+            .Set(c => c.DataSetVersion, dataSetVersion)
+            .Set(c => c.DataSetVersionId, (_, f) => f.DataSetVersion.Id);
+
+    public static InstanceSetters<LocationMetaChange> SetDataSetVersionId(
+        this InstanceSetters<LocationMetaChange> setters,
+        Guid dataSetVersionId)
+        => setters.Set(c => c.DataSetVersionId, dataSetVersionId);
+
+    public static InstanceSetters<LocationMetaChange> SetCurrentState(
+        this InstanceSetters<LocationMetaChange> setters,
+        LocationMeta? currentState)
+        => setters.SetCurrentState(() => currentState);
+
+    public static InstanceSetters<LocationMetaChange> SetCurrentState(
+        this InstanceSetters<LocationMetaChange> setters,
+        Func<LocationMeta?> currentState)
+        => setters
+            .Set(c => c.CurrentState, currentState)
+            .Set(c => c.CurrentStateId, (_, f) => f.CurrentState?.Id);
+
+    public static InstanceSetters<LocationMetaChange> SetCurrentStateId(
+        this InstanceSetters<LocationMetaChange> setters,
+        int? currentStateId)
+        => setters.Set(c => c.CurrentStateId, currentStateId);
+
+    public static InstanceSetters<LocationMetaChange> SetPreviousState(
+        this InstanceSetters<LocationMetaChange> setters,
+        LocationMeta? previousState)
+        => setters.SetPreviousState(() => previousState);
+
+    public static InstanceSetters<LocationMetaChange> SetPreviousState(
+        this InstanceSetters<LocationMetaChange> setters,
+        Func<LocationMeta?> previousState)
+        => setters
+            .Set(c => c.PreviousState, previousState)
+            .Set(c => c.PreviousStateId, (_, f) => f.PreviousState?.Id);
+
+    public static InstanceSetters<LocationMetaChange> SetPreviousStateId(
+        this InstanceSetters<LocationMetaChange> setters,
+        int? previousStateId)
+        => setters.Set(c => c.PreviousStateId, previousStateId);
+}
diff --git a/src/GovUk.Education.ExploreEducationStatistics.Public.Data.Model.Tests/Fixtures/LocationOptionMetaChangeGeneratorExtensions.cs b/src/GovUk.Education.ExploreEducationStatistics.Public.Data.Model.Tests/Fixtures/LocationOptionMetaChangeGeneratorExtensions.cs
new file mode 100644
index 00000000000..93e5b998152
--- /dev/null
+++ b/src/GovUk.Education.ExploreEducationStatistics.Public.Data.Model.Tests/Fixtures/LocationOptionMetaChangeGeneratorExtensions.cs
@@ -0,0 +1,148 @@
+using GovUk.Education.ExploreEducationStatistics.Common.Tests.Fixtures;
+
+namespace GovUk.Education.ExploreEducationStatistics.Public.Data.Model.Tests.Fixtures;
+
+public static class LocationOptionMetaChangeGeneratorExtensions
+{
+    public static Generator<LocationOptionMetaChange> DefaultLocationOptionMetaChange(this DataFixture fixture)
+        => fixture
+            .Generator<LocationOptionMetaChange>()
+            .WithDefaults();
+
+    public static Generator<LocationOptionMetaChange> WithDefaults(this Generator<LocationOptionMetaChange> generator)
+        => generator.ForInstance(s => s.SetDefaults());
+
+    public static Generator<LocationOptionMetaChange> WithDataSetVersion(
+        this Generator<LocationOptionMetaChange> generator,
+        Func<DataSetVersion> dataSetVersion)
+        => generator.ForInstance(s => s.SetDataSetVersion(dataSetVersion));
+
+    public static Generator<LocationOptionMetaChange> WithDataSetVersionId(
+        this Generator<LocationOptionMetaChange> generator,
+        Guid dataSetVersionId)
+        => generator.ForInstance(s => s.SetDataSetVersionId(dataSetVersionId));
+
+    public static Generator<LocationOptionMetaChange> WithCurrentState(
+        this Generator<LocationOptionMetaChange> generator,
+        LocationOptionMetaLink? currentState)
+        => generator.ForInstance(s => s.SetCurrentState(currentState));
+
+    public static Generator<LocationOptionMetaChange> WithCurrentState(
+        this Generator<LocationOptionMetaChange> generator,
+        Func<LocationOptionMetaLink?> currentState)
+        => generator.ForInstance(s => s.SetCurrentState(currentState));
+
+    public static Generator<LocationOptionMetaChange> WithCurrentState(
+        this Generator<LocationOptionMetaChange> generator,
+        LocationOptionMetaChange.State? currentState)
+        => generator.ForInstance(s => s.SetCurrentState(currentState));
+
+    public static Generator<LocationOptionMetaChange> WithCurrentState(
+        this Generator<LocationOptionMetaChange> generator,
+        Func<LocationOptionMetaChange.State?> currentState)
+        => generator.ForInstance(s => s.SetCurrentState(currentState));
+
+    public static Generator<LocationOptionMetaChange> WithPreviousState(
+        this Generator<LocationOptionMetaChange> generator,
+        LocationOptionMetaLink? previousState)
+        => generator.ForInstance(s => s.SetPreviousState(previousState));
+
+    public static Generator<LocationOptionMetaChange> WithPreviousState(
+        this Generator<LocationOptionMetaChange> generator,
+        Func<LocationOptionMetaLink?> previousState)
+        => generator.ForInstance(s => s.SetPreviousState(previousState));
+
+    public static Generator<LocationOptionMetaChange> WithPreviousState(
+        this Generator<LocationOptionMetaChange> generator,
+        LocationOptionMetaChange.State? previousState)
+        => generator.ForInstance(s => s.SetPreviousState(previousState));
+
+    public static Generator<LocationOptionMetaChange> WithPreviousState(
+        this Generator<LocationOptionMetaChange> generator,
+        Func<LocationOptionMetaChange.State?> previousState)
+        => generator.ForInstance(s => s.SetPreviousState(previousState));
+
+    public static InstanceSetters<LocationOptionMetaChange> SetDefaults(
+        this InstanceSetters<LocationOptionMetaChange> setters)
+        => setters
+            .SetDefault(c => c.DataSetVersionId);
+
+    public static InstanceSetters<LocationOptionMetaChange> SetDataSetVersion(
+        this InstanceSetters<LocationOptionMetaChange> setters,
+        Func<DataSetVersion> dataSetVersion)
+        => setters
+            .Set(c => c.DataSetVersion, dataSetVersion)
+            .Set(c => c.DataSetVersionId, (_, f) => f.DataSetVersion.Id);
+
+    public static InstanceSetters<LocationOptionMetaChange> SetDataSetVersionId(
+        this InstanceSetters<LocationOptionMetaChange> setters,
+        Guid dataSetVersionId)
+        => setters.Set(c => c.DataSetVersionId, dataSetVersionId);
+
+    public static InstanceSetters<LocationOptionMetaChange> SetCurrentState(
+        this InstanceSetters<LocationOptionMetaChange> setters,
+        LocationOptionMetaLink? currentState)
+        => setters.SetCurrentState(() => currentState);
+
+    public static InstanceSetters<LocationOptionMetaChange> SetCurrentState(
+        this InstanceSetters<LocationOptionMetaChange> setters,
+        Func<LocationOptionMetaLink?> currentState)
+    {
+        var current = currentState();
+
+        return current is not null
+            ? setters
+                .SetCurrentState(
+                    new LocationOptionMetaChange.State
+                    {
+                        MetaId = current.MetaId,
+                        OptionId = current.OptionId
+
+                    }
+                )
+            : setters;
+    }
+
+    public static InstanceSetters<LocationOptionMetaChange> SetCurrentState(
+        this InstanceSetters<LocationOptionMetaChange> setters,
+        LocationOptionMetaChange.State? currentState)
+        => setters.Set(c => c.CurrentState, currentState);
+
+    public static InstanceSetters<LocationOptionMetaChange> SetCurrentState(
+        this InstanceSetters<LocationOptionMetaChange> setters,
+        Func<LocationOptionMetaChange.State?> currentState)
+        => setters.Set(c => c.CurrentState, currentState);
+
+    public static InstanceSetters<LocationOptionMetaChange> SetPreviousState(
+        this InstanceSetters<LocationOptionMetaChange> setters,
+        LocationOptionMetaLink? previousState)
+        => setters.SetPreviousState(() => previousState);
+
+    public static InstanceSetters<LocationOptionMetaChange> SetPreviousState(
+        this InstanceSetters<LocationOptionMetaChange> setters,
+        Func<LocationOptionMetaLink?> previousState)
+    {
+        var previous = previousState();
+
+        return previous is not null
+            ? setters
+                .SetPreviousState(
+                    new LocationOptionMetaChange.State
+                    {
+                        MetaId = previous.MetaId,
+                        OptionId = previous.OptionId
+                    }
+                )
+            : setters;
+    }
+
+    public static InstanceSetters<LocationOptionMetaChange> SetPreviousState(
+        this InstanceSetters<LocationOptionMetaChange> setters,
+        LocationOptionMetaChange.State? previousState)
+        => setters.Set(c => c.PreviousState, previousState);
+
+    public static InstanceSetters<LocationOptionMetaChange> SetPreviousState(
+        this InstanceSetters<LocationOptionMetaChange> setters,
+        Func<LocationOptionMetaChange.State?> previousState)
+        => setters.Set(c => c.PreviousState, previousState);
+}
diff --git a/src/GovUk.Education.ExploreEducationStatistics.Public.Data.Model.Tests/Fixtures/TimePeriodMetaChangeGeneratorExtensions.cs b/src/GovUk.Education.ExploreEducationStatistics.Public.Data.Model.Tests/Fixtures/TimePeriodMetaChangeGeneratorExtensions.cs
new file mode 100644
index 00000000000..a7c5d7607e8
--- /dev/null
+++ b/src/GovUk.Education.ExploreEducationStatistics.Public.Data.Model.Tests/Fixtures/TimePeriodMetaChangeGeneratorExtensions.cs
@@ -0,0 +1,104 @@
+using GovUk.Education.ExploreEducationStatistics.Common.Tests.Fixtures;
+
+namespace GovUk.Education.ExploreEducationStatistics.Public.Data.Model.Tests.Fixtures;
+
+public static class TimePeriodMetaChangeGeneratorExtensions
+{
+    public static Generator<TimePeriodMetaChange> DefaultTimePeriodMetaChange(this DataFixture fixture)
+        => fixture
+            .Generator<TimePeriodMetaChange>()
+            .WithDefaults();
+
+    public static Generator<TimePeriodMetaChange> WithDefaults(this Generator<TimePeriodMetaChange> generator)
+        => generator.ForInstance(s => s.SetDefaults());
+
+    public static Generator<TimePeriodMetaChange> WithDataSetVersion(
+        this Generator<TimePeriodMetaChange> generator,
+        Func<DataSetVersion> dataSetVersion)
+        => generator.ForInstance(s => s.SetDataSetVersion(dataSetVersion));
+    
+    public static Generator<TimePeriodMetaChange> WithDataSetVersionId(
+        this Generator<TimePeriodMetaChange> generator,
+        Guid dataSetVersionId)
+        => generator.ForInstance(s => s.SetDataSetVersionId(dataSetVersionId));
+
+    public static Generator<TimePeriodMetaChange> WithCurrentState(
+        this Generator<TimePeriodMetaChange> generator,
+        TimePeriodMeta? currentState)
+        => generator.ForInstance(s => s.SetCurrentState(currentState));
+
+    public static Generator<TimePeriodMetaChange> WithCurrentState(
+        this Generator<TimePeriodMetaChange> generator,
+        Func<TimePeriodMeta?> currentState)
+        => generator.ForInstance(s => s.SetCurrentState(currentState));
+
+    public static Generator<TimePeriodMetaChange> WithCurrentStateId(
+        this Generator<TimePeriodMetaChange> generator,
+        int? currentStateId)
+        => generator.ForInstance(s => s.SetCurrentStateId(currentStateId));
+
+    public static Generator<TimePeriodMetaChange> WithPreviousState(
+        this Generator<TimePeriodMetaChange> generator,
+        TimePeriodMeta? previousState)
+        => generator.ForInstance(s => s.SetPreviousState(previousState));
+
+    public static Generator<TimePeriodMetaChange> WithPreviousState(
+        this Generator<TimePeriodMetaChange> generator,
+        Func<TimePeriodMeta?> previousState)
+        => generator.ForInstance(s => s.SetPreviousState(previousState));
+
+    public static Generator<TimePeriodMetaChange> WithPreviousStateId(
+        this Generator<TimePeriodMetaChange> generator,
+        int? previousStateId)
+        => generator.ForInstance(s => s.SetPreviousStateId(previousStateId));
+
+    public static InstanceSetters<TimePeriodMetaChange> SetDefaults(this InstanceSetters<TimePeriodMetaChange> setters)
+        => setters
+            .SetDefault(c => c.DataSetVersionId);
+
+    public static InstanceSetters<TimePeriodMetaChange> SetDataSetVersion(
+        this InstanceSetters<TimePeriodMetaChange> setters,
+        Func<DataSetVersion> dataSetVersion)
+        => setters
+            .Set(c => c.DataSetVersion, dataSetVersion)
+            .Set(c => c.DataSetVersionId, (_, f) => f.DataSetVersion.Id);
+
+    public static InstanceSetters<TimePeriodMetaChange> SetDataSetVersionId(
+        this InstanceSetters<TimePeriodMetaChange> setters,
+        Guid dataSetVersionId)
+        => setters.Set(c => c.DataSetVersionId, dataSetVersionId);
+
+    public static InstanceSetters<TimePeriodMetaChange> SetCurrentState(
+        this InstanceSetters<TimePeriodMetaChange> setters,
+        TimePeriodMeta? previousState)
+        => setters.SetCurrentState(() => previousState);
+
+    public static InstanceSetters<TimePeriodMetaChange> SetCurrentState(
+        this InstanceSetters<TimePeriodMetaChange> setters,
+        Func<TimePeriodMeta?> currentState)
+        => setters
+            .Set(c => c.CurrentState, currentState)
+            .Set(c => c.CurrentStateId, (_, f) => f.CurrentState?.Id);
+
+    public static InstanceSetters<TimePeriodMetaChange> SetCurrentStateId(
+        this InstanceSetters<TimePeriodMetaChange> setters,
+        int? currentStateId)
+        => setters.Set(c => c.CurrentStateId, currentStateId);
+
+    public static InstanceSetters<TimePeriodMetaChange> SetPreviousState(
+        this InstanceSetters<TimePeriodMetaChange> setters,
+        TimePeriodMeta? previousState)
+        => setters.SetPreviousState(() => previousState);
+
+    public static InstanceSetters<TimePeriodMetaChange> SetPreviousState(
+        this InstanceSetters<TimePeriodMetaChange> setters,
+        Func<TimePeriodMeta?> previousState)
+        => setters
+            .Set(c => c.PreviousState, previousState)
+            .Set(c => c.PreviousStateId, (_, f) => f.PreviousState?.Id);
+
+    public static InstanceSetters<TimePeriodMetaChange> SetPreviousStateId(
+        this InstanceSetters<TimePeriodMetaChange> setters,
+        int? previousStateId)
+        => setters.Set(c => c.PreviousStateId, previousStateId);
+}
diff --git a/src/GovUk.Education.ExploreEducationStatistics.Public.Data.Model/Change.cs b/src/GovUk.Education.ExploreEducationStatistics.Public.Data.Model/Change.cs
index 486be1011c7..b40959788fc 100644
--- a/src/GovUk.Education.ExploreEducationStatistics.Public.Data.Model/Change.cs
+++ b/src/GovUk.Education.ExploreEducationStatistics.Public.Data.Model/Change.cs
@@ -1,14 +1,168 @@
-using GovUk.Education.ExploreEducationStatistics.Common.Utils;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
 namespace GovUk.Education.ExploreEducationStatistics.Public.Data.Model;
 
-public class Change<TState>
+public abstract class Change<TEntity>
 {
-    public Guid Identifier { get; set; } = UuidUtils.UuidV7();
+    public long Id { get; set; }
 
-    public required ChangeType Type { get; set; }
+    public DataSetVersion DataSetVersion { get; set; } = null!;
 
-    public TState? CurrentState { get; set; }
+    public required Guid DataSetVersionId { get; set; }
 
-    public TState? PreviousState { get; set; }
+    public TEntity? CurrentState { get; set; }
+
+    public TEntity? PreviousState { get; set; }
+
+    internal abstract class BaseConfig<TChange, TChangeEntity> : IEntityTypeConfiguration<TChange>
+        where TChange : Change<TChangeEntity>
+        where TChangeEntity : class
+    {
+        public virtual void Configure(EntityTypeBuilder<TChange> builder)
+        {
+            builder
+                .HasOne(c => c.CurrentState)
+                .WithMany();
+
+            builder
+                .HasOne(c => c.PreviousState)
+                .WithMany();
+
+            builder.Navigation(c => c.PreviousState).AutoInclude();
+            builder.Navigation(c => c.CurrentState).AutoInclude();
+        }
+    }
+}
+
+public class FilterMetaChange : Change<FilterMeta>
+{
+    public int? CurrentStateId { get; set; }
+
+    public int? PreviousStateId { get; set; }
+
+    internal class Config : BaseConfig<FilterMetaChange, FilterMeta>;
+}
+
+public class FilterOptionMetaChange : Change<FilterOptionMetaChange.State>
+{
+    internal class Config : IEntityTypeConfiguration<FilterOptionMetaChange>
+    {
+        public void Configure(EntityTypeBuilder<FilterOptionMetaChange> builder)
+        {
+            builder.OwnsOne(c => c.PreviousState, b =>
+            {
+                b.HasOne(s => s.Meta)
+                    .WithMany();
+
+                b.HasOne(s => s.Option)
+                    .WithMany();
+
+                b.Navigation(s => s.Option).AutoInclude();
+            });
+
+            builder.OwnsOne(c => c.CurrentState, b =>
+            {
+                b.HasOne(s => s.Meta)
+                    .WithMany();
+
+                b.HasOne(s => s.Option)
+                    .WithMany();
+
+                b.Navigation(s => s.Option).AutoInclude();
+            });
+        }
+    }
+
+    public class State
+    {
+        public FilterMeta Meta { get; set; } = null!;
+
+        public required int MetaId { get; set; }
+
+        public FilterOptionMeta Option { get; set; } = null!;
+
+        public required int OptionId { get; set; }
+
+        public required string PublicId { get; set; }
+    }
+}
+
+public class GeographicLevelMetaChange : Change<GeographicLevelMeta>
+{
+    public int? CurrentStateId { get; set; }
+
+    public int? PreviousStateId { get; set; }
+
+    internal class Config : BaseConfig<GeographicLevelMetaChange, GeographicLevelMeta>;
+}
+
+public class IndicatorMetaChange : Change<IndicatorMeta>
+{
+    public int? CurrentStateId { get; set; }
+
+    public int? PreviousStateId { get; set; }
+
+    internal class Config : BaseConfig<IndicatorMetaChange, IndicatorMeta>;
+}
+
+public class LocationMetaChange : Change<LocationMeta>
+
+{
+    public int? CurrentStateId { get; set; }
+
+    public int? PreviousStateId { get; set; }
+
+    internal class Config : BaseConfig<LocationMetaChange, LocationMeta>;
+}
+
+public class LocationOptionMetaChange : Change<LocationOptionMetaChange.State>
+{
+    internal class Config : IEntityTypeConfiguration<LocationOptionMetaChange>
+    {
+        public void Configure(EntityTypeBuilder<LocationOptionMetaChange> builder)
+        {
+            builder.OwnsOne(c => c.PreviousState, b =>
+            {
+                b.HasOne(s => s.Meta)
+                    .WithMany();
+
+                b.HasOne(s => s.Option)
+                    .WithMany();
+
+                b.Navigation(s => s.Option).AutoInclude();
+            });
+
+            builder.OwnsOne(c => c.CurrentState, b =>
+            {
+                b.HasOne(s => s.Meta)
+                    .WithMany();
+
+                b.HasOne(s => s.Option)
+                    .WithMany();
+
+                b.Navigation(s => s.Option).AutoInclude();
+            });
+        }
+    }
+
+    public class State
+    {
+        public LocationMeta Meta { get; set; } = null!;
+
+        public required int MetaId { get; set; }
+
+        public LocationOptionMeta Option { get; set; } = null!;
+
+        public required int OptionId { get; set; }
+    }
+}
+
+public class TimePeriodMetaChange : Change<TimePeriodMeta>
+{
+    public int? CurrentStateId { get; set; }
+
+    public int? PreviousStateId { get; set; }
+
+    internal class Config : BaseConfig<TimePeriodMetaChange, TimePeriodMeta>;
 }
diff --git a/src/GovUk.Education.ExploreEducationStatistics.Public.Data.Model/ChangeSet.cs b/src/GovUk.Education.ExploreEducationStatistics.Public.Data.Model/ChangeSet.cs
deleted file mode 100644
index 040ed55becb..00000000000
--- a/src/GovUk.Education.ExploreEducationStatistics.Public.Data.Model/ChangeSet.cs
+++ /dev/null
@@ -1,146 +0,0 @@
-using GovUk.Education.ExploreEducationStatistics.Common.Converters;
-using GovUk.Education.ExploreEducationStatistics.Common.Database;
-using GovUk.Education.ExploreEducationStatistics.Common.Model;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.EntityFrameworkCore.Metadata.Builders;
-
-namespace GovUk.Education.ExploreEducationStatistics.Public.Data.Model;
-
-public abstract class ChangeSet<TChangeState> : ICreatedUpdatedTimestamps<DateTimeOffset, DateTimeOffset?>
-{
-    public Guid Id { get; set; }
-
-    public DataSetVersion DataSetVersion { get; set; } = null!;
-
-    public required Guid DataSetVersionId { get; set; }
-
-    public required List<Change<TChangeState>> Changes { get; set; }
-
-    public DateTimeOffset Created { get; set; }
-
-    public DateTimeOffset? Updated { get; set; }
-}
-
-public class ChangeSetFilters : ChangeSet<FilterChangeState>
-{
-    internal class Config : IEntityTypeConfiguration<ChangeSetFilters>
-    {
-        public void Configure(EntityTypeBuilder<ChangeSetFilters> builder)
-        {
-            builder.Property(cs => cs.Id)
-                .HasValueGenerator<UuidV7ValueGenerator>();
-
-            builder.OwnsMany(cs => cs.Changes, cs =>
-            {
-                cs.ToJson();
-                cs.Property(c => c.Identifier).HasJsonPropertyName("Id");
-                cs.Property(c => c.Type).HasConversion<string>();
-                cs.OwnsOne(c => c.CurrentState);
-                cs.OwnsOne(c => c.PreviousState);
-            });
-        }
-    }
-}
-
-public class ChangeSetFilterOptions : ChangeSet<FilterOptionChangeState>
-{
-    internal class Config : IEntityTypeConfiguration<ChangeSetFilterOptions>
-    {
-        public void Configure(EntityTypeBuilder<ChangeSetFilterOptions> builder)
-        {
-            builder.Property(cs => cs.Id)
-                .HasValueGenerator<UuidV7ValueGenerator>();
-
-            builder.OwnsMany(cs => cs.Changes, cs =>
-            {
-                cs.ToJson();
-                cs.Property(c => c.Identifier).HasJsonPropertyName("Id");
-                cs.Property(c => c.Type).HasConversion<string>();
-                cs.OwnsOne(c => c.CurrentState);
-                cs.OwnsOne(c => c.PreviousState);
-            });
-        }
-    }
-}
-
-public class ChangeSetIndicators : ChangeSet<IndicatorChangeState>
-{
-    public class Config : IEntityTypeConfiguration<ChangeSetIndicators>
-    {
-        public void Configure(EntityTypeBuilder<ChangeSetIndicators> builder)
-        {
-            builder.Property(cs => cs.Id)
-                .HasValueGenerator<UuidV7ValueGenerator>();
-
-            builder.OwnsMany(cs => cs.Changes, cs =>
-            {
-                cs.ToJson();
-                cs.Property(c => c.Identifier).HasJsonPropertyName("Id");
-                cs.Property(c => c.Type).HasConversion<string>();
-                cs.OwnsOne(c => c.CurrentState, s =>
-                {
-                    s.Property(sb => sb.Unit)
-                        .HasConversion(new EnumToEnumValueConverter<IndicatorUnit>());
-                });
-                cs.OwnsOne(c => c.PreviousState, s =>
-                {
-                    s.Property(sb => sb.Unit)
-                        .HasConversion(new EnumToEnumValueConverter<IndicatorUnit>());
-                });
-            });
-        }
-    }
-}
-
-public class ChangeSetLocations : ChangeSet<LocationChangeState>
-{
-    internal class Config : IEntityTypeConfiguration<ChangeSetLocations>
-    {
-        public void Configure(EntityTypeBuilder<ChangeSetLocations> builder)
-        {
-            builder.Property(cs => cs.Id)
-                .HasValueGenerator<UuidV7ValueGenerator>();
-
-            builder.OwnsMany(cs => cs.Changes, cs =>
-            {
-                cs.ToJson();
-                cs.Property(c => c.Identifier).HasJsonPropertyName("Id");
-                cs.Property(c => c.Type).HasConversion<string>();
-                cs.OwnsOne(c => c.CurrentState, s =>
-                {
-                    s.Property(sb => sb.Level).HasConversion<string>();
-                });
-                cs.OwnsOne(c => c.PreviousState);
-            });
-        }
-    }
-}
-
-public class ChangeSetTimePeriods : ChangeSet<TimePeriodChangeState>
-{
-    internal class Config : IEntityTypeConfiguration<ChangeSetTimePeriods>
-    {
-        public void Configure(EntityTypeBuilder<ChangeSetTimePeriods> builder)
-        {
-            builder.Property(cs => cs.Id)
-                .HasValueGenerator<UuidV7ValueGenerator>();
-
-            builder.OwnsMany(cs => cs.Changes, cs =>
-            {
-                cs.ToJson();
-                cs.Property(c => c.Identifier).HasJsonPropertyName("Id");
-                cs.Property(c => c.Type).HasConversion<string>();
-                cs.OwnsOne(c => c.CurrentState, s =>
-                {
-                    s.Property(sb => sb.Code)
-                        .HasConversion(new EnumToEnumValueConverter<TimeIdentifier>());
-                });
-                cs.OwnsOne(c => c.PreviousState, s =>
-                {
-                    s.Property(sb => sb.Code)
-                        .HasConversion(new EnumToEnumValueConverter<TimeIdentifier>());
-                });
-            });
-        }
-    }
-}
diff --git a/src/GovUk.Education.ExploreEducationStatistics.Public.Data.Model/DataSetVersion.cs b/src/GovUk.Education.ExploreEducationStatistics.Public.Data.Model/DataSetVersion.cs
index 0f6705ef056..2195eccc77c 100644
--- a/src/GovUk.Education.ExploreEducationStatistics.Public.Data.Model/DataSetVersion.cs
+++ b/src/GovUk.Education.ExploreEducationStatistics.Public.Data.Model/DataSetVersion.cs
@@ -47,15 +47,19 @@ public class DataSetVersion : ICreatedUpdatedTimestamps<DateTimeOffset, DateTime
 
     public List<TimePeriodMeta> TimePeriodMetas { get; set; } = [];
 
-    public List<ChangeSetFilters> FilterChanges { get; set; } = [];
+    public List<FilterMetaChange> FilterMetaChanges { get; set; } = [];
 
-    public List<ChangeSetFilterOptions> FilterOptionChanges { get; set; } = [];
+    public List<FilterOptionMetaChange> FilterOptionMetaChanges { get; set; } = [];
 
-    public List<ChangeSetIndicators> IndicatorChanges { get; set; } = [];
+    public GeographicLevelMetaChange? GeographicLevelMetaChange { get; set; }
 
-    public List<ChangeSetLocations> LocationChanges { get; set; } = [];
+    public List<IndicatorMetaChange> IndicatorMetaChanges { get; set; } = [];
 
-    public List<ChangeSetTimePeriods> TimePeriodChanges { get; set; } = [];
+    public List<LocationMetaChange> LocationMetaChanges { get; set; } = [];
+
+    public List<LocationOptionMetaChange> LocationOptionMetaChanges { get; set; } = [];
+
+    public List<TimePeriodMetaChange> TimePeriodMetaChanges { get; set; } = [];
 
     public List<DataSetVersionImport> Imports { get; set; } = [];
 
diff --git a/src/GovUk.Education.ExploreEducationStatistics.Public.Data.Model/Database/PublicDataDbContext.cs b/src/GovUk.Education.ExploreEducationStatistics.Public.Data.Model/Database/PublicDataDbContext.cs
index 0d01e931e7b..f34dd5dd3ee 100644
--- a/src/GovUk.Education.ExploreEducationStatistics.Public.Data.Model/Database/PublicDataDbContext.cs
+++ b/src/GovUk.Education.ExploreEducationStatistics.Public.Data.Model/Database/PublicDataDbContext.cs
@@ -65,11 +65,13 @@ SELECT setval('public."{sequenceName}"', {value}) AS "Value"
     public DbSet<FilterOptionMetaLink> FilterOptionMetaLinks { get; init; } = null!;
     public DbSet<IndicatorMeta> IndicatorMetas { get; init; } = null!;
     public DbSet<TimePeriodMeta> TimePeriodMetas { get; init; } = null!;
-    public DbSet<ChangeSetFilters> ChangeSetFilters { get; init; } = null!;
-    public DbSet<ChangeSetFilterOptions> ChangeSetFilterOptions { get; init; } = null!;
-    public DbSet<ChangeSetIndicators> ChangeSetIndicators { get; init; } = null!;
-    public DbSet<ChangeSetLocations> ChangeSetLocations { get; init; } = null!;
-    public DbSet<ChangeSetTimePeriods> ChangeSetTimePeriods { get; init; } = null!;
+    public DbSet<FilterMetaChange> FilterMetaChanges { get; init; } = null!;
+    public DbSet<FilterOptionMetaChange> FilterOptionMetaChanges { get; init; } = null!;
+    public DbSet<GeographicLevelMetaChange> GeographicLevelMetaChanges { get; init; } = null!;
+    public DbSet<IndicatorMetaChange> IndicatorMetaChanges { get; init; } = null!;
+    public DbSet<LocationMetaChange> LocationMetaChanges { get; init; } = null!;
+    public DbSet<LocationOptionMetaChange> LocationOptionMetaChanges { get; init; } = null!;
+    public DbSet<TimePeriodMetaChange> TimePeriodMetaChanges { get; init; } = null!;
     public DbSet<PreviewToken> PreviewTokens { get; init; } = null!;
 
     public DbSet<JsonFragment> JsonFragments { get; init; } = null!;
diff --git a/src/GovUk.Education.ExploreEducationStatistics.Public.Data.Model/FilterChangeState.cs b/src/GovUk.Education.ExploreEducationStatistics.Public.Data.Model/FilterChangeState.cs
deleted file mode 100644
index c613028fd5a..00000000000
--- a/src/GovUk.Education.ExploreEducationStatistics.Public.Data.Model/FilterChangeState.cs
+++ /dev/null
@@ -1,10 +0,0 @@
-namespace GovUk.Education.ExploreEducationStatistics.Public.Data.Model;
-
-public class FilterChangeState
-{
-    public required string Id { get; set; }
-
-    public required string Label { get; set; }
-
-    public string Hint { get; set; } = string.Empty;
-}
diff --git a/src/GovUk.Education.ExploreEducationStatistics.Public.Data.Model/FilterOptionChangeState.cs b/src/GovUk.Education.ExploreEducationStatistics.Public.Data.Model/FilterOptionChangeState.cs
deleted file mode 100644
index 4b9a68619f8..00000000000
--- a/src/GovUk.Education.ExploreEducationStatistics.Public.Data.Model/FilterOptionChangeState.cs
+++ /dev/null
@@ -1,12 +0,0 @@
-namespace GovUk.Education.ExploreEducationStatistics.Public.Data.Model;
-
-public class FilterOptionChangeState
-{
-    public required string Id { get; set; }
-
-    public required string Label { get; set; }
-
-    public required string FilterId { get; set; }
-
-    public bool? IsAggregate { get; set; } = null!;
-}
diff --git a/src/GovUk.Education.ExploreEducationStatistics.Public.Data.Model/GeographicLevelMeta.cs b/src/GovUk.Education.ExploreEducationStatistics.Public.Data.Model/GeographicLevelMeta.cs
index 1754880ada7..933f1d9a2de 100644
--- a/src/GovUk.Education.ExploreEducationStatistics.Public.Data.Model/GeographicLevelMeta.cs
+++ b/src/GovUk.Education.ExploreEducationStatistics.Public.Data.Model/GeographicLevelMeta.cs
@@ -1,8 +1,8 @@
+using GovUk.Education.ExploreEducationStatistics.Common.Comparers;
 using GovUk.Education.ExploreEducationStatistics.Common.Converters;
 using GovUk.Education.ExploreEducationStatistics.Common.Model;
 using GovUk.Education.ExploreEducationStatistics.Common.Model.Data;
 using Microsoft.EntityFrameworkCore;
-using Microsoft.EntityFrameworkCore.ChangeTracking;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
 namespace GovUk.Education.ExploreEducationStatistics.Public.Data.Model;
@@ -28,17 +28,9 @@ public void Configure(EntityTypeBuilder<GeographicLevelMeta> builder)
             builder.Property(msb => msb.Levels)
                 .HasColumnType("text[]")
                 .HasConversion(
-                    value => value
-                        .Select(EnumToEnumValueConverter<GeographicLevel>.ToProvider)
-                        .ToList(),
-                    value => value
-                        .Select(EnumToEnumValueConverter<GeographicLevel>.FromProvider)
-                        .ToList(),
-                    new ValueComparer<List<GeographicLevel>>(
-                        (c1, c2) => c1!.SequenceEqual(c2!),
-                        c => c.Aggregate(0, (a, v) => HashCode.Combine(a, v.GetHashCode())),
-                        c => c.ToList())
-                    );
+                    new EnumToEnumValueListConverter<GeographicLevel>(),
+                    new ListValueComparer<GeographicLevel>()
+                );
         }
     }
 }
diff --git a/src/GovUk.Education.ExploreEducationStatistics.Public.Data.Model/IndicatorChangeState.cs b/src/GovUk.Education.ExploreEducationStatistics.Public.Data.Model/IndicatorChangeState.cs
deleted file mode 100644
index 274f03829b7..00000000000
--- a/src/GovUk.Education.ExploreEducationStatistics.Public.Data.Model/IndicatorChangeState.cs
+++ /dev/null
@@ -1,14 +0,0 @@
-using GovUk.Education.ExploreEducationStatistics.Common.Model;
-
-namespace GovUk.Education.ExploreEducationStatistics.Public.Data.Model;
-
-public class IndicatorChangeState
-{
-    public required string Id { get; set; }
-
-    public required string Label { get; set; }
-
-    public IndicatorUnit? Unit { get; set; }
-
-    public byte? DecimalPlaces { get; set; }
-}
diff --git a/src/GovUk.Education.ExploreEducationStatistics.Public.Data.Model/LocationChangeState.cs b/src/GovUk.Education.ExploreEducationStatistics.Public.Data.Model/LocationChangeState.cs
deleted file mode 100644
index 3779f5d1a94..00000000000
--- a/src/GovUk.Education.ExploreEducationStatistics.Public.Data.Model/LocationChangeState.cs
+++ /dev/null
@@ -1,14 +0,0 @@
-using GovUk.Education.ExploreEducationStatistics.Common.Model.Data;
-
-namespace GovUk.Education.ExploreEducationStatistics.Public.Data.Model;
-
-public class LocationChangeState
-{
-    public required string Id { get; set; }
-
-    public required string Label { get; set; }
-
-    public required string Code { get; set; }
-
-    public required GeographicLevel Level { get; set; }
-}
diff --git a/src/GovUk.Education.ExploreEducationStatistics.Public.Data.Model/Migrations/20240725104818_EES4950_RemodelChangeTables.Designer.cs b/src/GovUk.Education.ExploreEducationStatistics.Public.Data.Model/Migrations/20240725104818_EES4950_RemodelChangeTables.Designer.cs
new file mode 100644
index 00000000000..a4e066c28a2
--- /dev/null
+++ b/src/GovUk.Education.ExploreEducationStatistics.Public.Data.Model/Migrations/20240725104818_EES4950_RemodelChangeTables.Designer.cs
@@ -0,0 +1,1407 @@
+// <auto-generated />
+using System;
+using System.Collections.Generic;
+using GovUk.Education.ExploreEducationStatistics.Public.Data.Model.Database;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace GovUk.Education.ExploreEducationStatistics.Public.Data.Model.Migrations
+{
+    [DbContext(typeof(PublicDataDbContext))]
+    [Migration("20240725104818_EES4950_RemodelChangeTables")]
+    partial class EES4950_RemodelChangeTables
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "8.0.4")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.HasSequence<int>("FilterOptionMetaLink_seq");
+
+            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Common.Model.JsonBool", b =>
+                {
+                    b.Property<bool>("BoolValue")
+                        .HasColumnType("boolean");
+
+                    b.ToTable((string)null);
+
+                    b.ToView(null, (string)null);
+                });
+
+            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Common.Model.JsonFragment", b =>
+                {
+                    b.Property<string>("JsonValue")
+                        .HasColumnType("text");
+
+                    b.ToTable((string)null);
+
+                    b.ToView(null, (string)null);
+                });
+
+            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.DataSet", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("Created")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid?>("LatestDraftVersionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("LatestLiveVersionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("PublicationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset?>("Published")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Summary")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("SupersedingDataSetId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset?>("Updated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset?>("Withdrawn")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LatestDraftVersionId")
+                        .IsUnique();
+
+                    b.HasIndex("LatestLiveVersionId")
+                        .IsUnique();
+
+                    b.HasIndex("SupersedingDataSetId");
+
+                    b.ToTable("DataSets");
+                });
+
+            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.DataSetVersion", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("Created")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("DataSetId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Notes")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset?>("Published")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("ReleaseFileId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<long>("TotalResults")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTimeOffset?>("Updated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("VersionMajor")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("VersionMinor")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("VersionPatch")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset?>("Withdrawn")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReleaseFileId");
+
+                    b.HasIndex("DataSetId", "VersionMajor", "VersionMinor", "VersionPatch")
+                        .IsUnique()
+                        .HasDatabaseName("IX_DataSetVersions_DataSetId_VersionNumber");
+
+                    b.ToTable("DataSetVersions");
+                });
+
+            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.DataSetVersionImport", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset?>("Completed")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset>("Created")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("DataSetVersionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("InstanceId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Stage")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset?>("Updated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DataSetVersionId");
+
+                    b.HasIndex("InstanceId")
+                        .IsUnique();
+
+                    b.ToTable("DataSetVersionImports");
+                });
+
+            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.DataSetVersionMapping", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("Created")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("FilterMappingPlan")
+                        .IsRequired()
+                        .HasColumnType("jsonb");
+
+                    b.Property<bool>("FilterMappingsComplete")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("LocationMappingPlan")
+                        .IsRequired()
+                        .HasColumnType("jsonb");
+
+                    b.Property<bool>("LocationMappingsComplete")
+                        .HasColumnType("boolean");
+
+                    b.Property<Guid>("SourceDataSetVersionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("TargetDataSetVersionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset?>("Updated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SourceDataSetVersionId")
+                        .IsUnique()
+                        .HasDatabaseName("IX_DataSetVersionMappings_SourceDataSetVersionId");
+
+                    b.HasIndex("TargetDataSetVersionId")
+                        .IsUnique()
+                        .HasDatabaseName("IX_DataSetVersionMappings_TargetDataSetVersionId");
+
+                    b.ToTable("DataSetVersionMappings");
+                });
+
+            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.FilterMeta", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("Created")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("DataSetVersionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Hint")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Label")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PublicId")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<DateTimeOffset?>("Updated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DataSetVersionId", "PublicId")
+                        .IsUnique();
+
+                    b.ToTable("FilterMetas");
+                });
+
+            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.FilterMetaChange", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<int?>("CurrentStateId")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid>("DataSetVersionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int?>("PreviousStateId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CurrentStateId");
+
+                    b.HasIndex("DataSetVersionId");
+
+                    b.HasIndex("PreviousStateId");
+
+                    b.ToTable("FilterMetaChanges");
+                });
+
+            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.FilterOptionMeta", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<bool?>("IsAggregate")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Label")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("FilterOptionMetas");
+                });
+
+            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.FilterOptionMetaChange", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<Guid>("DataSetVersionId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DataSetVersionId");
+
+                    b.ToTable("FilterOptionMetaChanges");
+                });
+
+            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.FilterOptionMetaLink", b =>
+                {
+                    b.Property<int>("MetaId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("OptionId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("PublicId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("MetaId", "OptionId");
+
+                    b.HasIndex("OptionId");
+
+                    b.HasIndex("PublicId");
+
+                    b.HasIndex("MetaId", "PublicId")
+                        .IsUnique();
+
+                    b.ToTable("FilterOptionMetaLinks");
+                });
+
+            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.GeographicLevelMeta", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("Created")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("DataSetVersionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<List<string>>("Levels")
+                        .IsRequired()
+                        .HasColumnType("text[]");
+
+                    b.Property<DateTimeOffset?>("Updated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DataSetVersionId")
+                        .IsUnique();
+
+                    b.ToTable("GeographicLevelMetas");
+                });
+
+            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.GeographicLevelMetaChange", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<int?>("CurrentStateId")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid>("DataSetVersionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int?>("PreviousStateId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CurrentStateId");
+
+                    b.HasIndex("DataSetVersionId")
+                        .IsUnique();
+
+                    b.HasIndex("PreviousStateId");
+
+                    b.ToTable("GeographicLevelMetaChanges");
+                });
+
+            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.IndicatorMeta", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("Created")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("DataSetVersionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<byte?>("DecimalPlaces")
+                        .HasColumnType("smallint");
+
+                    b.Property<string>("Label")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PublicId")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("Unit")
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset?>("Updated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DataSetVersionId", "PublicId")
+                        .IsUnique();
+
+                    b.ToTable("IndicatorMetas");
+                });
+
+            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.IndicatorMetaChange", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<int?>("CurrentStateId")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid>("DataSetVersionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int?>("PreviousStateId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CurrentStateId");
+
+                    b.HasIndex("DataSetVersionId");
+
+                    b.HasIndex("PreviousStateId");
+
+                    b.ToTable("IndicatorMetaChanges");
+                });
+
+            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.LocationMeta", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("Created")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("DataSetVersionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Level")
+                        .IsRequired()
+                        .HasMaxLength(5)
+                        .HasColumnType("character varying(5)");
+
+                    b.Property<DateTimeOffset?>("Updated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DataSetVersionId", "Level")
+                        .IsUnique();
+
+                    b.ToTable("LocationMetas");
+                });
+
+            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.LocationMetaChange", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<int?>("CurrentStateId")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid>("DataSetVersionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int?>("PreviousStateId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CurrentStateId");
+
+                    b.HasIndex("DataSetVersionId");
+
+                    b.HasIndex("PreviousStateId");
+
+                    b.ToTable("LocationMetaChanges");
+                });
+
+            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.LocationOptionMeta", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Code")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LaEstab")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Label")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("OldCode")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PublicId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("character varying(10)");
+
+                    b.Property<string>("Ukprn")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Urn")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code");
+
+                    b.HasIndex("LaEstab");
+
+                    b.HasIndex("OldCode");
+
+                    b.HasIndex("PublicId")
+                        .IsUnique();
+
+                    b.HasIndex("Type");
+
+                    b.HasIndex("Ukprn");
+
+                    b.HasIndex("Urn");
+
+                    b.HasIndex(new[] { "Type", "Label", "Code", "OldCode", "Urn", "LaEstab", "Ukprn" }, "IX_LocationOptionMetas_All")
+                        .IsUnique();
+
+                    NpgsqlIndexBuilderExtensions.AreNullsDistinct(b.HasIndex(new[] { "Type", "Label", "Code", "OldCode", "Urn", "LaEstab", "Ukprn" }, "IX_LocationOptionMetas_All"), false);
+
+                    b.ToTable("LocationOptionMetas");
+
+                    b.HasDiscriminator<string>("Type").HasValue("LocationOptionMeta");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.LocationOptionMetaChange", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<Guid>("DataSetVersionId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DataSetVersionId");
+
+                    b.ToTable("LocationOptionMetaChanges");
+                });
+
+            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.LocationOptionMetaLink", b =>
+                {
+                    b.Property<int>("MetaId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("OptionId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("MetaId", "OptionId");
+
+                    b.HasIndex("OptionId");
+
+                    b.ToTable("LocationOptionMetaLinks");
+                });
+
+            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.PreviewToken", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("Created")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("CreatedByUserId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("DataSetVersionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("Expiry")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Label")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<DateTimeOffset?>("Updated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DataSetVersionId");
+
+                    b.ToTable("PreviewTokens");
+                });
+
+            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.TimePeriodMeta", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("character varying(10)");
+
+                    b.Property<DateTimeOffset>("Created")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("DataSetVersionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Period")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset?>("Updated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DataSetVersionId", "Code", "Period")
+                        .IsUnique();
+
+                    b.ToTable("TimePeriodMetas");
+                });
+
+            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.TimePeriodMetaChange", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<int?>("CurrentStateId")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid>("DataSetVersionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int?>("PreviousStateId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CurrentStateId");
+
+                    b.HasIndex("DataSetVersionId");
+
+                    b.HasIndex("PreviousStateId");
+
+                    b.ToTable("TimePeriodMetaChanges");
+                });
+
+            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.LocationCodedOptionMeta", b =>
+                {
+                    b.HasBaseType("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.LocationOptionMeta");
+
+                    b.HasDiscriminator().HasValue("CODE");
+                });
+
+            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.LocationLocalAuthorityOptionMeta", b =>
+                {
+                    b.HasBaseType("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.LocationOptionMeta");
+
+                    b.HasDiscriminator().HasValue("LA");
+                });
+
+            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.LocationProviderOptionMeta", b =>
+                {
+                    b.HasBaseType("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.LocationOptionMeta");
+
+                    b.HasDiscriminator().HasValue("PROV");
+                });
+
+            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.LocationRscRegionOptionMeta", b =>
+                {
+                    b.HasBaseType("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.LocationOptionMeta");
+
+                    b.HasDiscriminator().HasValue("RSC");
+                });
+
+            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.LocationSchoolOptionMeta", b =>
+                {
+                    b.HasBaseType("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.LocationOptionMeta");
+
+                    b.HasDiscriminator().HasValue("SCH");
+                });
+
+            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.DataSet", b =>
+                {
+                    b.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.DataSetVersion", "LatestDraftVersion")
+                        .WithOne()
+                        .HasForeignKey("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.DataSet", "LatestDraftVersionId");
+
+                    b.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.DataSetVersion", "LatestLiveVersion")
+                        .WithOne()
+                        .HasForeignKey("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.DataSet", "LatestLiveVersionId");
+
+                    b.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.DataSet", "SupersedingDataSet")
+                        .WithMany()
+                        .HasForeignKey("SupersedingDataSetId");
+
+                    b.Navigation("LatestDraftVersion");
+
+                    b.Navigation("LatestLiveVersion");
+
+                    b.Navigation("SupersedingDataSet");
+                });
+
+            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.DataSetVersion", b =>
+                {
+                    b.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.DataSet", "DataSet")
+                        .WithMany("Versions")
+                        .HasForeignKey("DataSetId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.OwnsOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.DataSetVersionMetaSummary", "MetaSummary", b1 =>
+                        {
+                            b1.Property<Guid>("DataSetVersionId")
+                                .HasColumnType("uuid");
+
+                            b1.Property<List<string>>("Filters")
+                                .IsRequired()
+                                .HasColumnType("text[]");
+
+                            b1.Property<List<string>>("GeographicLevels")
+                                .IsRequired()
+                                .HasColumnType("text[]");
+
+                            b1.Property<List<string>>("Indicators")
+                                .IsRequired()
+                                .HasColumnType("text[]");
+
+                            b1.HasKey("DataSetVersionId");
+
+                            b1.ToTable("DataSetVersions");
+
+                            b1.ToJson("MetaSummary");
+
+                            b1.WithOwner()
+                                .HasForeignKey("DataSetVersionId");
+
+                            b1.OwnsOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.TimePeriodRange", "TimePeriodRange", b2 =>
+                                {
+                                    b2.Property<Guid>("DataSetVersionMetaSummaryDataSetVersionId")
+                                        .HasColumnType("uuid");
+
+                                    b2.HasKey("DataSetVersionMetaSummaryDataSetVersionId");
+
+                                    b2.ToTable("DataSetVersions");
+
+                                    b2.WithOwner()
+                                        .HasForeignKey("DataSetVersionMetaSummaryDataSetVersionId");
+
+                                    b2.OwnsOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.TimePeriodRangeBound", "End", b3 =>
+                                        {
+                                            b3.Property<Guid>("TimePeriodRangeDataSetVersionMetaSummaryDataSetVersionId")
+                                                .HasColumnType("uuid");
+
+                                            b3.Property<string>("Code")
+                                                .IsRequired()
+                                                .HasColumnType("text");
+
+                                            b3.Property<string>("Period")
+                                                .IsRequired()
+                                                .HasColumnType("text");
+
+                                            b3.HasKey("TimePeriodRangeDataSetVersionMetaSummaryDataSetVersionId");
+
+                                            b3.ToTable("DataSetVersions");
+
+                                            b3.WithOwner()
+                                                .HasForeignKey("TimePeriodRangeDataSetVersionMetaSummaryDataSetVersionId");
+                                        });
+
+                                    b2.OwnsOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.TimePeriodRangeBound", "Start", b3 =>
+                                        {
+                                            b3.Property<Guid>("TimePeriodRangeDataSetVersionMetaSummaryDataSetVersionId")
+                                                .HasColumnType("uuid");
+
+                                            b3.Property<string>("Code")
+                                                .IsRequired()
+                                                .HasColumnType("text");
+
+                                            b3.Property<string>("Period")
+                                                .IsRequired()
+                                                .HasColumnType("text");
+
+                                            b3.HasKey("TimePeriodRangeDataSetVersionMetaSummaryDataSetVersionId");
+
+                                            b3.ToTable("DataSetVersions");
+
+                                            b3.WithOwner()
+                                                .HasForeignKey("TimePeriodRangeDataSetVersionMetaSummaryDataSetVersionId");
+                                        });
+
+                                    b2.Navigation("End")
+                                        .IsRequired();
+
+                                    b2.Navigation("Start")
+                                        .IsRequired();
+                                });
+
+                            b1.Navigation("TimePeriodRange")
+                                .IsRequired();
+                        });
+
+                    b.Navigation("DataSet");
+
+                    b.Navigation("MetaSummary");
+                });
+
+            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.DataSetVersionImport", b =>
+                {
+                    b.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.DataSetVersion", "DataSetVersion")
+                        .WithMany("Imports")
+                        .HasForeignKey("DataSetVersionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("DataSetVersion");
+                });
+
+            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.DataSetVersionMapping", b =>
+                {
+                    b.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.DataSetVersion", "SourceDataSetVersion")
+                        .WithMany()
+                        .HasForeignKey("SourceDataSetVersionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.DataSetVersion", "TargetDataSetVersion")
+                        .WithMany()
+                        .HasForeignKey("TargetDataSetVersionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("SourceDataSetVersion");
+
+                    b.Navigation("TargetDataSetVersion");
+                });
+
+            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.FilterMeta", b =>
+                {
+                    b.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.DataSetVersion", "DataSetVersion")
+                        .WithMany("FilterMetas")
+                        .HasForeignKey("DataSetVersionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("DataSetVersion");
+                });
+
+            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.FilterMetaChange", b =>
+                {
+                    b.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.FilterMeta", "CurrentState")
+                        .WithMany()
+                        .HasForeignKey("CurrentStateId");
+
+                    b.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.DataSetVersion", "DataSetVersion")
+                        .WithMany("FilterMetaChanges")
+                        .HasForeignKey("DataSetVersionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.FilterMeta", "PreviousState")
+                        .WithMany()
+                        .HasForeignKey("PreviousStateId");
+
+                    b.Navigation("CurrentState");
+
+                    b.Navigation("DataSetVersion");
+
+                    b.Navigation("PreviousState");
+                });
+
+            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.FilterOptionMetaChange", b =>
+                {
+                    b.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.DataSetVersion", "DataSetVersion")
+                        .WithMany("FilterOptionMetaChanges")
+                        .HasForeignKey("DataSetVersionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.OwnsOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.FilterOptionMetaChange+State", "CurrentState", b1 =>
+                        {
+                            b1.Property<long>("FilterOptionMetaChangeId")
+                                .HasColumnType("bigint");
+
+                            b1.Property<int>("MetaId")
+                                .HasColumnType("integer");
+
+                            b1.Property<int>("OptionId")
+                                .HasColumnType("integer");
+
+                            b1.Property<string>("PublicId")
+                                .IsRequired()
+                                .HasColumnType("text");
+
+                            b1.HasKey("FilterOptionMetaChangeId");
+
+                            b1.HasIndex("MetaId");
+
+                            b1.HasIndex("OptionId");
+
+                            b1.ToTable("FilterOptionMetaChanges");
+
+                            b1.WithOwner()
+                                .HasForeignKey("FilterOptionMetaChangeId");
+
+                            b1.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.FilterMeta", "Meta")
+                                .WithMany()
+                                .HasForeignKey("MetaId")
+                                .OnDelete(DeleteBehavior.Cascade)
+                                .IsRequired();
+
+                            b1.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.FilterOptionMeta", "Option")
+                                .WithMany()
+                                .HasForeignKey("OptionId")
+                                .OnDelete(DeleteBehavior.Cascade)
+                                .IsRequired();
+
+                            b1.Navigation("Meta");
+
+                            b1.Navigation("Option");
+                        });
+
+                    b.OwnsOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.FilterOptionMetaChange+State", "PreviousState", b1 =>
+                        {
+                            b1.Property<long>("FilterOptionMetaChangeId")
+                                .HasColumnType("bigint");
+
+                            b1.Property<int>("MetaId")
+                                .HasColumnType("integer");
+
+                            b1.Property<int>("OptionId")
+                                .HasColumnType("integer");
+
+                            b1.Property<string>("PublicId")
+                                .IsRequired()
+                                .HasColumnType("text");
+
+                            b1.HasKey("FilterOptionMetaChangeId");
+
+                            b1.HasIndex("MetaId");
+
+                            b1.HasIndex("OptionId");
+
+                            b1.ToTable("FilterOptionMetaChanges");
+
+                            b1.WithOwner()
+                                .HasForeignKey("FilterOptionMetaChangeId");
+
+                            b1.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.FilterMeta", "Meta")
+                                .WithMany()
+                                .HasForeignKey("MetaId")
+                                .OnDelete(DeleteBehavior.Cascade)
+                                .IsRequired();
+
+                            b1.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.FilterOptionMeta", "Option")
+                                .WithMany()
+                                .HasForeignKey("OptionId")
+                                .OnDelete(DeleteBehavior.Cascade)
+                                .IsRequired();
+
+                            b1.Navigation("Meta");
+
+                            b1.Navigation("Option");
+                        });
+
+                    b.Navigation("CurrentState");
+
+                    b.Navigation("DataSetVersion");
+
+                    b.Navigation("PreviousState");
+                });
+
+            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.FilterOptionMetaLink", b =>
+                {
+                    b.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.FilterMeta", "Meta")
+                        .WithMany("OptionLinks")
+                        .HasForeignKey("MetaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.FilterOptionMeta", "Option")
+                        .WithMany("MetaLinks")
+                        .HasForeignKey("OptionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Meta");
+
+                    b.Navigation("Option");
+                });
+
+            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.GeographicLevelMeta", b =>
+                {
+                    b.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.DataSetVersion", "DataSetVersion")
+                        .WithOne("GeographicLevelMeta")
+                        .HasForeignKey("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.GeographicLevelMeta", "DataSetVersionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("DataSetVersion");
+                });
+
+            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.GeographicLevelMetaChange", b =>
+                {
+                    b.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.GeographicLevelMeta", "CurrentState")
+                        .WithMany()
+                        .HasForeignKey("CurrentStateId");
+
+                    b.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.DataSetVersion", "DataSetVersion")
+                        .WithOne("GeographicLevelMetaChange")
+                        .HasForeignKey("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.GeographicLevelMetaChange", "DataSetVersionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.GeographicLevelMeta", "PreviousState")
+                        .WithMany()
+                        .HasForeignKey("PreviousStateId");
+
+                    b.Navigation("CurrentState");
+
+                    b.Navigation("DataSetVersion");
+
+                    b.Navigation("PreviousState");
+                });
+
+            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.IndicatorMeta", b =>
+                {
+                    b.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.DataSetVersion", "DataSetVersion")
+                        .WithMany("IndicatorMetas")
+                        .HasForeignKey("DataSetVersionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("DataSetVersion");
+                });
+
+            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.IndicatorMetaChange", b =>
+                {
+                    b.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.IndicatorMeta", "CurrentState")
+                        .WithMany()
+                        .HasForeignKey("CurrentStateId");
+
+                    b.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.DataSetVersion", "DataSetVersion")
+                        .WithMany("IndicatorMetaChanges")
+                        .HasForeignKey("DataSetVersionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.IndicatorMeta", "PreviousState")
+                        .WithMany()
+                        .HasForeignKey("PreviousStateId");
+
+                    b.Navigation("CurrentState");
+
+                    b.Navigation("DataSetVersion");
+
+                    b.Navigation("PreviousState");
+                });
+
+            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.LocationMeta", b =>
+                {
+                    b.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.DataSetVersion", "DataSetVersion")
+                        .WithMany("LocationMetas")
+                        .HasForeignKey("DataSetVersionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("DataSetVersion");
+                });
+
+            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.LocationMetaChange", b =>
+                {
+                    b.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.LocationMeta", "CurrentState")
+                        .WithMany()
+                        .HasForeignKey("CurrentStateId");
+
+                    b.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.DataSetVersion", "DataSetVersion")
+                        .WithMany("LocationMetaChanges")
+                        .HasForeignKey("DataSetVersionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.LocationMeta", "PreviousState")
+                        .WithMany()
+                        .HasForeignKey("PreviousStateId");
+
+                    b.Navigation("CurrentState");
+
+                    b.Navigation("DataSetVersion");
+
+                    b.Navigation("PreviousState");
+                });
+
+            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.LocationOptionMetaChange", b =>
+                {
+                    b.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.DataSetVersion", "DataSetVersion")
+                        .WithMany("LocationOptionMetaChanges")
+                        .HasForeignKey("DataSetVersionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.OwnsOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.LocationOptionMetaChange+State", "CurrentState", b1 =>
+                        {
+                            b1.Property<long>("LocationOptionMetaChangeId")
+                                .HasColumnType("bigint");
+
+                            b1.Property<int>("MetaId")
+                                .HasColumnType("integer");
+
+                            b1.Property<int>("OptionId")
+                                .HasColumnType("integer");
+
+                            b1.HasKey("LocationOptionMetaChangeId");
+
+                            b1.HasIndex("MetaId");
+
+                            b1.HasIndex("OptionId");
+
+                            b1.ToTable("LocationOptionMetaChanges");
+
+                            b1.WithOwner()
+                                .HasForeignKey("LocationOptionMetaChangeId");
+
+                            b1.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.LocationMeta", "Meta")
+                                .WithMany()
+                                .HasForeignKey("MetaId")
+                                .OnDelete(DeleteBehavior.Cascade)
+                                .IsRequired();
+
+                            b1.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.LocationOptionMeta", "Option")
+                                .WithMany()
+                                .HasForeignKey("OptionId")
+                                .OnDelete(DeleteBehavior.Cascade)
+                                .IsRequired();
+
+                            b1.Navigation("Meta");
+
+                            b1.Navigation("Option");
+                        });
+
+                    b.OwnsOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.LocationOptionMetaChange+State", "PreviousState", b1 =>
+                        {
+                            b1.Property<long>("LocationOptionMetaChangeId")
+                                .HasColumnType("bigint");
+
+                            b1.Property<int>("MetaId")
+                                .HasColumnType("integer");
+
+                            b1.Property<int>("OptionId")
+                                .HasColumnType("integer");
+
+                            b1.HasKey("LocationOptionMetaChangeId");
+
+                            b1.HasIndex("MetaId");
+
+                            b1.HasIndex("OptionId");
+
+                            b1.ToTable("LocationOptionMetaChanges");
+
+                            b1.WithOwner()
+                                .HasForeignKey("LocationOptionMetaChangeId");
+
+                            b1.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.LocationMeta", "Meta")
+                                .WithMany()
+                                .HasForeignKey("MetaId")
+                                .OnDelete(DeleteBehavior.Cascade)
+                                .IsRequired();
+
+                            b1.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.LocationOptionMeta", "Option")
+                                .WithMany()
+                                .HasForeignKey("OptionId")
+                                .OnDelete(DeleteBehavior.Cascade)
+                                .IsRequired();
+
+                            b1.Navigation("Meta");
+
+                            b1.Navigation("Option");
+                        });
+
+                    b.Navigation("CurrentState");
+
+                    b.Navigation("DataSetVersion");
+
+                    b.Navigation("PreviousState");
+                });
+
+            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.LocationOptionMetaLink", b =>
+                {
+                    b.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.LocationMeta", "Meta")
+                        .WithMany("OptionLinks")
+                        .HasForeignKey("MetaId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.LocationOptionMeta", "Option")
+                        .WithMany("MetaLinks")
+                        .HasForeignKey("OptionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Meta");
+
+                    b.Navigation("Option");
+                });
+
+            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.PreviewToken", b =>
+                {
+                    b.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.DataSetVersion", "DataSetVersion")
+                        .WithMany("PreviewTokens")
+                        .HasForeignKey("DataSetVersionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("DataSetVersion");
+                });
+
+            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.TimePeriodMeta", b =>
+                {
+                    b.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.DataSetVersion", "DataSetVersion")
+                        .WithMany("TimePeriodMetas")
+                        .HasForeignKey("DataSetVersionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("DataSetVersion");
+                });
+
+            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.TimePeriodMetaChange", b =>
+                {
+                    b.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.TimePeriodMeta", "CurrentState")
+                        .WithMany()
+                        .HasForeignKey("CurrentStateId");
+
+                    b.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.DataSetVersion", "DataSetVersion")
+                        .WithMany("TimePeriodMetaChanges")
+                        .HasForeignKey("DataSetVersionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.TimePeriodMeta", "PreviousState")
+                        .WithMany()
+                        .HasForeignKey("PreviousStateId");
+
+                    b.Navigation("CurrentState");
+
+                    b.Navigation("DataSetVersion");
+
+                    b.Navigation("PreviousState");
+                });
+
+            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.DataSet", b =>
+                {
+                    b.Navigation("Versions");
+                });
+
+            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.DataSetVersion", b =>
+                {
+                    b.Navigation("FilterMetaChanges");
+
+                    b.Navigation("FilterMetas");
+
+                    b.Navigation("FilterOptionMetaChanges");
+
+                    b.Navigation("GeographicLevelMeta");
+
+                    b.Navigation("GeographicLevelMetaChange");
+
+                    b.Navigation("Imports");
+
+                    b.Navigation("IndicatorMetaChanges");
+
+                    b.Navigation("IndicatorMetas");
+
+                    b.Navigation("LocationMetaChanges");
+
+                    b.Navigation("LocationMetas");
+
+                    b.Navigation("LocationOptionMetaChanges");
+
+                    b.Navigation("PreviewTokens");
+
+                    b.Navigation("TimePeriodMetaChanges");
+
+                    b.Navigation("TimePeriodMetas");
+                });
+
+            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.FilterMeta", b =>
+                {
+                    b.Navigation("OptionLinks");
+                });
+
+            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.FilterOptionMeta", b =>
+                {
+                    b.Navigation("MetaLinks");
+                });
+
+            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.LocationMeta", b =>
+                {
+                    b.Navigation("OptionLinks");
+                });
+
+            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.LocationOptionMeta", b =>
+                {
+                    b.Navigation("MetaLinks");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/src/GovUk.Education.ExploreEducationStatistics.Public.Data.Model/Migrations/20240725104818_EES4950_RemodelChangeTables.cs b/src/GovUk.Education.ExploreEducationStatistics.Public.Data.Model/Migrations/20240725104818_EES4950_RemodelChangeTables.cs
new file mode 100644
index 00000000000..f46099cc421
--- /dev/null
+++ b/src/GovUk.Education.ExploreEducationStatistics.Public.Data.Model/Migrations/20240725104818_EES4950_RemodelChangeTables.cs
@@ -0,0 +1,563 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace GovUk.Education.ExploreEducationStatistics.Public.Data.Model.Migrations
+{
+    /// <inheritdoc />
+    public partial class EES4950_RemodelChangeTables : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "ChangeSetFilterOptions");
+
+            migrationBuilder.DropTable(
+                name: "ChangeSetFilters");
+
+            migrationBuilder.DropTable(
+                name: "ChangeSetIndicators");
+
+            migrationBuilder.DropTable(
+                name: "ChangeSetLocations");
+
+            migrationBuilder.DropTable(
+                name: "ChangeSetTimePeriods");
+
+            migrationBuilder.CreateTable(
+                name: "FilterMetaChanges",
+                columns: table => new
+                {
+                    Id = table.Column<long>(type: "bigint", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    CurrentStateId = table.Column<int>(type: "integer", nullable: true),
+                    PreviousStateId = table.Column<int>(type: "integer", nullable: true),
+                    DataSetVersionId = table.Column<Guid>(type: "uuid", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_FilterMetaChanges", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_FilterMetaChanges_DataSetVersions_DataSetVersionId",
+                        column: x => x.DataSetVersionId,
+                        principalTable: "DataSetVersions",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_FilterMetaChanges_FilterMetas_CurrentStateId",
+                        column: x => x.CurrentStateId,
+                        principalTable: "FilterMetas",
+                        principalColumn: "Id");
+                    table.ForeignKey(
+                        name: "FK_FilterMetaChanges_FilterMetas_PreviousStateId",
+                        column: x => x.PreviousStateId,
+                        principalTable: "FilterMetas",
+                        principalColumn: "Id");
+                });
+
+            migrationBuilder.CreateTable(
+                name: "FilterOptionMetaChanges",
+                columns: table => new
+                {
+                    Id = table.Column<long>(type: "bigint", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    DataSetVersionId = table.Column<Guid>(type: "uuid", nullable: false),
+                    CurrentState_MetaId = table.Column<int>(type: "integer", nullable: true),
+                    CurrentState_OptionId = table.Column<int>(type: "integer", nullable: true),
+                    CurrentState_PublicId = table.Column<string>(type: "text", nullable: true),
+                    PreviousState_MetaId = table.Column<int>(type: "integer", nullable: true),
+                    PreviousState_OptionId = table.Column<int>(type: "integer", nullable: true),
+                    PreviousState_PublicId = table.Column<string>(type: "text", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_FilterOptionMetaChanges", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_FilterOptionMetaChanges_DataSetVersions_DataSetVersionId",
+                        column: x => x.DataSetVersionId,
+                        principalTable: "DataSetVersions",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_FilterOptionMetaChanges_FilterMetas_CurrentState_MetaId",
+                        column: x => x.CurrentState_MetaId,
+                        principalTable: "FilterMetas",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_FilterOptionMetaChanges_FilterMetas_PreviousState_MetaId",
+                        column: x => x.PreviousState_MetaId,
+                        principalTable: "FilterMetas",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_FilterOptionMetaChanges_FilterOptionMetas_CurrentState_Opti~",
+                        column: x => x.CurrentState_OptionId,
+                        principalTable: "FilterOptionMetas",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_FilterOptionMetaChanges_FilterOptionMetas_PreviousState_Opt~",
+                        column: x => x.PreviousState_OptionId,
+                        principalTable: "FilterOptionMetas",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "GeographicLevelMetaChanges",
+                columns: table => new
+                {
+                    Id = table.Column<long>(type: "bigint", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    CurrentStateId = table.Column<int>(type: "integer", nullable: true),
+                    PreviousStateId = table.Column<int>(type: "integer", nullable: true),
+                    DataSetVersionId = table.Column<Guid>(type: "uuid", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_GeographicLevelMetaChanges", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_GeographicLevelMetaChanges_DataSetVersions_DataSetVersionId",
+                        column: x => x.DataSetVersionId,
+                        principalTable: "DataSetVersions",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_GeographicLevelMetaChanges_GeographicLevelMetas_CurrentStat~",
+                        column: x => x.CurrentStateId,
+                        principalTable: "GeographicLevelMetas",
+                        principalColumn: "Id");
+                    table.ForeignKey(
+                        name: "FK_GeographicLevelMetaChanges_GeographicLevelMetas_PreviousSta~",
+                        column: x => x.PreviousStateId,
+                        principalTable: "GeographicLevelMetas",
+                        principalColumn: "Id");
+                });
+
+            migrationBuilder.CreateTable(
+                name: "IndicatorMetaChanges",
+                columns: table => new
+                {
+                    Id = table.Column<long>(type: "bigint", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    CurrentStateId = table.Column<int>(type: "integer", nullable: true),
+                    PreviousStateId = table.Column<int>(type: "integer", nullable: true),
+                    DataSetVersionId = table.Column<Guid>(type: "uuid", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_IndicatorMetaChanges", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_IndicatorMetaChanges_DataSetVersions_DataSetVersionId",
+                        column: x => x.DataSetVersionId,
+                        principalTable: "DataSetVersions",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_IndicatorMetaChanges_IndicatorMetas_CurrentStateId",
+                        column: x => x.CurrentStateId,
+                        principalTable: "IndicatorMetas",
+                        principalColumn: "Id");
+                    table.ForeignKey(
+                        name: "FK_IndicatorMetaChanges_IndicatorMetas_PreviousStateId",
+                        column: x => x.PreviousStateId,
+                        principalTable: "IndicatorMetas",
+                        principalColumn: "Id");
+                });
+
+            migrationBuilder.CreateTable(
+                name: "LocationMetaChanges",
+                columns: table => new
+                {
+                    Id = table.Column<long>(type: "bigint", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    CurrentStateId = table.Column<int>(type: "integer", nullable: true),
+                    PreviousStateId = table.Column<int>(type: "integer", nullable: true),
+                    DataSetVersionId = table.Column<Guid>(type: "uuid", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_LocationMetaChanges", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_LocationMetaChanges_DataSetVersions_DataSetVersionId",
+                        column: x => x.DataSetVersionId,
+                        principalTable: "DataSetVersions",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_LocationMetaChanges_LocationMetas_CurrentStateId",
+                        column: x => x.CurrentStateId,
+                        principalTable: "LocationMetas",
+                        principalColumn: "Id");
+                    table.ForeignKey(
+                        name: "FK_LocationMetaChanges_LocationMetas_PreviousStateId",
+                        column: x => x.PreviousStateId,
+                        principalTable: "LocationMetas",
+                        principalColumn: "Id");
+                });
+
+            migrationBuilder.CreateTable(
+                name: "LocationOptionMetaChanges",
+                columns: table => new
+                {
+                    Id = table.Column<long>(type: "bigint", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    DataSetVersionId = table.Column<Guid>(type: "uuid", nullable: false),
+                    CurrentState_MetaId = table.Column<int>(type: "integer", nullable: true),
+                    CurrentState_OptionId = table.Column<int>(type: "integer", nullable: true),
+                    PreviousState_MetaId = table.Column<int>(type: "integer", nullable: true),
+                    PreviousState_OptionId = table.Column<int>(type: "integer", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_LocationOptionMetaChanges", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_LocationOptionMetaChanges_DataSetVersions_DataSetVersionId",
+                        column: x => x.DataSetVersionId,
+                        principalTable: "DataSetVersions",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_LocationOptionMetaChanges_LocationMetas_CurrentState_MetaId",
+                        column: x => x.CurrentState_MetaId,
+                        principalTable: "LocationMetas",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_LocationOptionMetaChanges_LocationMetas_PreviousState_MetaId",
+                        column: x => x.PreviousState_MetaId,
+                        principalTable: "LocationMetas",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_LocationOptionMetaChanges_LocationOptionMetas_CurrentState_~",
+                        column: x => x.CurrentState_OptionId,
+                        principalTable: "LocationOptionMetas",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_LocationOptionMetaChanges_LocationOptionMetas_PreviousState~",
+                        column: x => x.PreviousState_OptionId,
+                        principalTable: "LocationOptionMetas",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "TimePeriodMetaChanges",
+                columns: table => new
+                {
+                    Id = table.Column<long>(type: "bigint", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    CurrentStateId = table.Column<int>(type: "integer", nullable: true),
+                    PreviousStateId = table.Column<int>(type: "integer", nullable: true),
+                    DataSetVersionId = table.Column<Guid>(type: "uuid", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_TimePeriodMetaChanges", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_TimePeriodMetaChanges_DataSetVersions_DataSetVersionId",
+                        column: x => x.DataSetVersionId,
+                        principalTable: "DataSetVersions",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_TimePeriodMetaChanges_TimePeriodMetas_CurrentStateId",
+                        column: x => x.CurrentStateId,
+                        principalTable: "TimePeriodMetas",
+                        principalColumn: "Id");
+                    table.ForeignKey(
+                        name: "FK_TimePeriodMetaChanges_TimePeriodMetas_PreviousStateId",
+                        column: x => x.PreviousStateId,
+                        principalTable: "TimePeriodMetas",
+                        principalColumn: "Id");
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_FilterMetaChanges_CurrentStateId",
+                table: "FilterMetaChanges",
+                column: "CurrentStateId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_FilterMetaChanges_DataSetVersionId",
+                table: "FilterMetaChanges",
+                column: "DataSetVersionId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_FilterMetaChanges_PreviousStateId",
+                table: "FilterMetaChanges",
+                column: "PreviousStateId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_FilterOptionMetaChanges_CurrentState_MetaId",
+                table: "FilterOptionMetaChanges",
+                column: "CurrentState_MetaId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_FilterOptionMetaChanges_CurrentState_OptionId",
+                table: "FilterOptionMetaChanges",
+                column: "CurrentState_OptionId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_FilterOptionMetaChanges_DataSetVersionId",
+                table: "FilterOptionMetaChanges",
+                column: "DataSetVersionId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_FilterOptionMetaChanges_PreviousState_MetaId",
+                table: "FilterOptionMetaChanges",
+                column: "PreviousState_MetaId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_FilterOptionMetaChanges_PreviousState_OptionId",
+                table: "FilterOptionMetaChanges",
+                column: "PreviousState_OptionId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_GeographicLevelMetaChanges_CurrentStateId",
+                table: "GeographicLevelMetaChanges",
+                column: "CurrentStateId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_GeographicLevelMetaChanges_DataSetVersionId",
+                table: "GeographicLevelMetaChanges",
+                column: "DataSetVersionId",
+                unique: true);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_GeographicLevelMetaChanges_PreviousStateId",
+                table: "GeographicLevelMetaChanges",
+                column: "PreviousStateId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_IndicatorMetaChanges_CurrentStateId",
+                table: "IndicatorMetaChanges",
+                column: "CurrentStateId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_IndicatorMetaChanges_DataSetVersionId",
+                table: "IndicatorMetaChanges",
+                column: "DataSetVersionId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_IndicatorMetaChanges_PreviousStateId",
+                table: "IndicatorMetaChanges",
+                column: "PreviousStateId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_LocationMetaChanges_CurrentStateId",
+                table: "LocationMetaChanges",
+                column: "CurrentStateId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_LocationMetaChanges_DataSetVersionId",
+                table: "LocationMetaChanges",
+                column: "DataSetVersionId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_LocationMetaChanges_PreviousStateId",
+                table: "LocationMetaChanges",
+                column: "PreviousStateId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_LocationOptionMetaChanges_CurrentState_MetaId",
+                table: "LocationOptionMetaChanges",
+                column: "CurrentState_MetaId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_LocationOptionMetaChanges_CurrentState_OptionId",
+                table: "LocationOptionMetaChanges",
+                column: "CurrentState_OptionId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_LocationOptionMetaChanges_DataSetVersionId",
+                table: "LocationOptionMetaChanges",
+                column: "DataSetVersionId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_LocationOptionMetaChanges_PreviousState_MetaId",
+                table: "LocationOptionMetaChanges",
+                column: "PreviousState_MetaId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_LocationOptionMetaChanges_PreviousState_OptionId",
+                table: "LocationOptionMetaChanges",
+                column: "PreviousState_OptionId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_TimePeriodMetaChanges_CurrentStateId",
+                table: "TimePeriodMetaChanges",
+                column: "CurrentStateId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_TimePeriodMetaChanges_DataSetVersionId",
+                table: "TimePeriodMetaChanges",
+                column: "DataSetVersionId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_TimePeriodMetaChanges_PreviousStateId",
+                table: "TimePeriodMetaChanges",
+                column: "PreviousStateId");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "FilterMetaChanges");
+
+            migrationBuilder.DropTable(
+                name: "FilterOptionMetaChanges");
+
+            migrationBuilder.DropTable(
+                name: "GeographicLevelMetaChanges");
+
+            migrationBuilder.DropTable(
+                name: "IndicatorMetaChanges");
+
+            migrationBuilder.DropTable(
+                name: "LocationMetaChanges");
+
+            migrationBuilder.DropTable(
+                name: "LocationOptionMetaChanges");
+
+            migrationBuilder.DropTable(
+                name: "TimePeriodMetaChanges");
+
+            migrationBuilder.CreateTable(
+                name: "ChangeSetFilterOptions",
+                columns: table => new
+                {
+                    Id = table.Column<Guid>(type: "uuid", nullable: false),
+                    DataSetVersionId = table.Column<Guid>(type: "uuid", nullable: false),
+                    Created = table.Column<DateTimeOffset>(type: "timestamp with time zone", nullable: false),
+                    Updated = table.Column<DateTimeOffset>(type: "timestamp with time zone", nullable: true),
+                    Changes = table.Column<string>(type: "jsonb", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_ChangeSetFilterOptions", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_ChangeSetFilterOptions_DataSetVersions_DataSetVersionId",
+                        column: x => x.DataSetVersionId,
+                        principalTable: "DataSetVersions",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "ChangeSetFilters",
+                columns: table => new
+                {
+                    Id = table.Column<Guid>(type: "uuid", nullable: false),
+                    DataSetVersionId = table.Column<Guid>(type: "uuid", nullable: false),
+                    Created = table.Column<DateTimeOffset>(type: "timestamp with time zone", nullable: false),
+                    Updated = table.Column<DateTimeOffset>(type: "timestamp with time zone", nullable: true),
+                    Changes = table.Column<string>(type: "jsonb", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_ChangeSetFilters", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_ChangeSetFilters_DataSetVersions_DataSetVersionId",
+                        column: x => x.DataSetVersionId,
+                        principalTable: "DataSetVersions",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "ChangeSetIndicators",
+                columns: table => new
+                {
+                    Id = table.Column<Guid>(type: "uuid", nullable: false),
+                    DataSetVersionId = table.Column<Guid>(type: "uuid", nullable: false),
+                    Created = table.Column<DateTimeOffset>(type: "timestamp with time zone", nullable: false),
+                    Updated = table.Column<DateTimeOffset>(type: "timestamp with time zone", nullable: true),
+                    Changes = table.Column<string>(type: "jsonb", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_ChangeSetIndicators", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_ChangeSetIndicators_DataSetVersions_DataSetVersionId",
+                        column: x => x.DataSetVersionId,
+                        principalTable: "DataSetVersions",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "ChangeSetLocations",
+                columns: table => new
+                {
+                    Id = table.Column<Guid>(type: "uuid", nullable: false),
+                    DataSetVersionId = table.Column<Guid>(type: "uuid", nullable: false),
+                    Created = table.Column<DateTimeOffset>(type: "timestamp with time zone", nullable: false),
+                    Updated = table.Column<DateTimeOffset>(type: "timestamp with time zone", nullable: true),
+                    Changes = table.Column<string>(type: "jsonb", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_ChangeSetLocations", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_ChangeSetLocations_DataSetVersions_DataSetVersionId",
+                        column: x => x.DataSetVersionId,
+                        principalTable: "DataSetVersions",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "ChangeSetTimePeriods",
+                columns: table => new
+                {
+                    Id = table.Column<Guid>(type: "uuid", nullable: false),
+                    DataSetVersionId = table.Column<Guid>(type: "uuid", nullable: false),
+                    Created = table.Column<DateTimeOffset>(type: "timestamp with time zone", nullable: false),
+                    Updated = table.Column<DateTimeOffset>(type: "timestamp with time zone", nullable: true),
+                    Changes = table.Column<string>(type: "jsonb", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_ChangeSetTimePeriods", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_ChangeSetTimePeriods_DataSetVersions_DataSetVersionId",
+                        column: x => x.DataSetVersionId,
+                        principalTable: "DataSetVersions",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_ChangeSetFilterOptions_DataSetVersionId",
+                table: "ChangeSetFilterOptions",
+                column: "DataSetVersionId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_ChangeSetFilters_DataSetVersionId",
+                table: "ChangeSetFilters",
+                column: "DataSetVersionId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_ChangeSetIndicators_DataSetVersionId",
+                table: "ChangeSetIndicators",
+                column: "DataSetVersionId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_ChangeSetLocations_DataSetVersionId",
+                table: "ChangeSetLocations",
+                column: "DataSetVersionId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_ChangeSetTimePeriods_DataSetVersionId",
+                table: "ChangeSetTimePeriods",
+                column: "DataSetVersionId");
+        }
+    }
+}
diff --git a/src/GovUk.Education.ExploreEducationStatistics.Public.Data.Model/Migrations/PublicDataDbContextModelSnapshot.cs b/src/GovUk.Education.ExploreEducationStatistics.Public.Data.Model/Migrations/PublicDataDbContextModelSnapshot.cs
index d5fedae8dbc..bedcb5e8db3 100644
--- a/src/GovUk.Education.ExploreEducationStatistics.Public.Data.Model/Migrations/PublicDataDbContextModelSnapshot.cs
+++ b/src/GovUk.Education.ExploreEducationStatistics.Public.Data.Model/Migrations/PublicDataDbContextModelSnapshot.cs
@@ -45,116 +45,6 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.ToView(null, (string)null);
                 });
 
-            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.ChangeSetFilterOptions", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<DateTimeOffset>("Created")
-                        .HasColumnType("timestamp with time zone");
-
-                    b.Property<Guid>("DataSetVersionId")
-                        .HasColumnType("uuid");
-
-                    b.Property<DateTimeOffset?>("Updated")
-                        .HasColumnType("timestamp with time zone");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("DataSetVersionId");
-
-                    b.ToTable("ChangeSetFilterOptions");
-                });
-
-            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.ChangeSetFilters", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<DateTimeOffset>("Created")
-                        .HasColumnType("timestamp with time zone");
-
-                    b.Property<Guid>("DataSetVersionId")
-                        .HasColumnType("uuid");
-
-                    b.Property<DateTimeOffset?>("Updated")
-                        .HasColumnType("timestamp with time zone");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("DataSetVersionId");
-
-                    b.ToTable("ChangeSetFilters");
-                });
-
-            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.ChangeSetIndicators", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<DateTimeOffset>("Created")
-                        .HasColumnType("timestamp with time zone");
-
-                    b.Property<Guid>("DataSetVersionId")
-                        .HasColumnType("uuid");
-
-                    b.Property<DateTimeOffset?>("Updated")
-                        .HasColumnType("timestamp with time zone");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("DataSetVersionId");
-
-                    b.ToTable("ChangeSetIndicators");
-                });
-
-            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.ChangeSetLocations", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<DateTimeOffset>("Created")
-                        .HasColumnType("timestamp with time zone");
-
-                    b.Property<Guid>("DataSetVersionId")
-                        .HasColumnType("uuid");
-
-                    b.Property<DateTimeOffset?>("Updated")
-                        .HasColumnType("timestamp with time zone");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("DataSetVersionId");
-
-                    b.ToTable("ChangeSetLocations");
-                });
-
-            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.ChangeSetTimePeriods", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<DateTimeOffset>("Created")
-                        .HasColumnType("timestamp with time zone");
-
-                    b.Property<Guid>("DataSetVersionId")
-                        .HasColumnType("uuid");
-
-                    b.Property<DateTimeOffset?>("Updated")
-                        .HasColumnType("timestamp with time zone");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("DataSetVersionId");
-
-                    b.ToTable("ChangeSetTimePeriods");
-                });
-
             modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.DataSet", b =>
                 {
                     b.Property<Guid>("Id")
@@ -383,6 +273,34 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.ToTable("FilterMetas");
                 });
 
+            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.FilterMetaChange", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<int?>("CurrentStateId")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid>("DataSetVersionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int?>("PreviousStateId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CurrentStateId");
+
+                    b.HasIndex("DataSetVersionId");
+
+                    b.HasIndex("PreviousStateId");
+
+                    b.ToTable("FilterMetaChanges");
+                });
+
             modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.FilterOptionMeta", b =>
                 {
                     b.Property<int>("Id")
@@ -403,6 +321,24 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.ToTable("FilterOptionMetas");
                 });
 
+            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.FilterOptionMetaChange", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<Guid>("DataSetVersionId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DataSetVersionId");
+
+                    b.ToTable("FilterOptionMetaChanges");
+                });
+
             modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.FilterOptionMetaLink", b =>
                 {
                     b.Property<int>("MetaId")
@@ -456,6 +392,35 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.ToTable("GeographicLevelMetas");
                 });
 
+            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.GeographicLevelMetaChange", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<int?>("CurrentStateId")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid>("DataSetVersionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int?>("PreviousStateId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CurrentStateId");
+
+                    b.HasIndex("DataSetVersionId")
+                        .IsUnique();
+
+                    b.HasIndex("PreviousStateId");
+
+                    b.ToTable("GeographicLevelMetaChanges");
+                });
+
             modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.IndicatorMeta", b =>
                 {
                     b.Property<int>("Id")
@@ -496,6 +461,34 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.ToTable("IndicatorMetas");
                 });
 
+            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.IndicatorMetaChange", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<int?>("CurrentStateId")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid>("DataSetVersionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int?>("PreviousStateId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CurrentStateId");
+
+                    b.HasIndex("DataSetVersionId");
+
+                    b.HasIndex("PreviousStateId");
+
+                    b.ToTable("IndicatorMetaChanges");
+                });
+
             modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.LocationMeta", b =>
                 {
                     b.Property<int>("Id")
@@ -526,6 +519,34 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.ToTable("LocationMetas");
                 });
 
+            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.LocationMetaChange", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<int?>("CurrentStateId")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid>("DataSetVersionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int?>("PreviousStateId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CurrentStateId");
+
+                    b.HasIndex("DataSetVersionId");
+
+                    b.HasIndex("PreviousStateId");
+
+                    b.ToTable("LocationMetaChanges");
+                });
+
             modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.LocationOptionMeta", b =>
                 {
                     b.Property<int>("Id")
@@ -591,6 +612,24 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.UseTphMappingStrategy();
                 });
 
+            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.LocationOptionMetaChange", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<Guid>("DataSetVersionId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DataSetVersionId");
+
+                    b.ToTable("LocationOptionMetaChanges");
+                });
+
             modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.LocationOptionMetaLink", b =>
                 {
                     b.Property<int>("MetaId")
@@ -673,6 +712,34 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.ToTable("TimePeriodMetas");
                 });
 
+            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.TimePeriodMetaChange", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<int?>("CurrentStateId")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid>("DataSetVersionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int?>("PreviousStateId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CurrentStateId");
+
+                    b.HasIndex("DataSetVersionId");
+
+                    b.HasIndex("PreviousStateId");
+
+                    b.ToTable("TimePeriodMetaChanges");
+                });
+
             modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.LocationCodedOptionMeta", b =>
                 {
                     b.HasBaseType("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.LocationOptionMeta");
@@ -708,533 +775,26 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.HasDiscriminator().HasValue("SCH");
                 });
 
-            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.ChangeSetFilterOptions", b =>
+            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.DataSet", b =>
                 {
-                    b.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.DataSetVersion", "DataSetVersion")
-                        .WithMany("FilterOptionChanges")
-                        .HasForeignKey("DataSetVersionId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.OwnsMany("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.Change<GovUk.Education.ExploreEducationStatistics.Public.Data.Model.FilterOptionChangeState>", "Changes", b1 =>
-                        {
-                            b1.Property<Guid>("ChangeSetFilterOptionsId")
-                                .HasColumnType("uuid");
-
-                            b1.Property<int>("Id")
-                                .ValueGeneratedOnAdd()
-                                .HasColumnType("integer");
-
-                            b1.Property<Guid>("Identifier")
-                                .HasColumnType("uuid")
-                                .HasAnnotation("Relational:JsonPropertyName", "Id");
+                    b.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.DataSetVersion", "LatestDraftVersion")
+                        .WithOne()
+                        .HasForeignKey("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.DataSet", "LatestDraftVersionId");
 
-                            b1.Property<string>("Type")
-                                .IsRequired()
-                                .HasColumnType("text");
+                    b.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.DataSetVersion", "LatestLiveVersion")
+                        .WithOne()
+                        .HasForeignKey("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.DataSet", "LatestLiveVersionId");
 
-                            b1.HasKey("ChangeSetFilterOptionsId", "Id");
+                    b.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.DataSet", "SupersedingDataSet")
+                        .WithMany()
+                        .HasForeignKey("SupersedingDataSetId");
 
-                            b1.ToTable("ChangeSetFilterOptions");
+                    b.Navigation("LatestDraftVersion");
 
-                            b1.ToJson("Changes");
+                    b.Navigation("LatestLiveVersion");
 
-                            b1.WithOwner()
-                                .HasForeignKey("ChangeSetFilterOptionsId");
-
-                            b1.OwnsOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.FilterOptionChangeState", "CurrentState", b2 =>
-                                {
-                                    b2.Property<Guid>("ChangeSetFilterOptionsId")
-                                        .HasColumnType("uuid");
-
-                                    b2.Property<int>("ChangeId")
-                                        .HasColumnType("integer");
-
-                                    b2.Property<string>("FilterId")
-                                        .IsRequired()
-                                        .HasColumnType("text");
-
-                                    b2.Property<string>("Id")
-                                        .IsRequired()
-                                        .HasColumnType("text");
-
-                                    b2.Property<bool?>("IsAggregate")
-                                        .HasColumnType("boolean");
-
-                                    b2.Property<string>("Label")
-                                        .IsRequired()
-                                        .HasColumnType("text");
-
-                                    b2.HasKey("ChangeSetFilterOptionsId", "ChangeId");
-
-                                    b2.ToTable("ChangeSetFilterOptions");
-
-                                    b2.WithOwner()
-                                        .HasForeignKey("ChangeSetFilterOptionsId", "ChangeId");
-                                });
-
-                            b1.OwnsOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.FilterOptionChangeState", "PreviousState", b2 =>
-                                {
-                                    b2.Property<Guid>("ChangeSetFilterOptionsId")
-                                        .HasColumnType("uuid");
-
-                                    b2.Property<int>("ChangeId")
-                                        .HasColumnType("integer");
-
-                                    b2.Property<string>("FilterId")
-                                        .IsRequired()
-                                        .HasColumnType("text");
-
-                                    b2.Property<string>("Id")
-                                        .IsRequired()
-                                        .HasColumnType("text");
-
-                                    b2.Property<bool?>("IsAggregate")
-                                        .HasColumnType("boolean");
-
-                                    b2.Property<string>("Label")
-                                        .IsRequired()
-                                        .HasColumnType("text");
-
-                                    b2.HasKey("ChangeSetFilterOptionsId", "ChangeId");
-
-                                    b2.ToTable("ChangeSetFilterOptions");
-
-                                    b2.WithOwner()
-                                        .HasForeignKey("ChangeSetFilterOptionsId", "ChangeId");
-                                });
-
-                            b1.Navigation("CurrentState");
-
-                            b1.Navigation("PreviousState");
-                        });
-
-                    b.Navigation("Changes");
-
-                    b.Navigation("DataSetVersion");
-                });
-
-            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.ChangeSetFilters", b =>
-                {
-                    b.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.DataSetVersion", "DataSetVersion")
-                        .WithMany("FilterChanges")
-                        .HasForeignKey("DataSetVersionId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.OwnsMany("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.Change<GovUk.Education.ExploreEducationStatistics.Public.Data.Model.FilterChangeState>", "Changes", b1 =>
-                        {
-                            b1.Property<Guid>("ChangeSetFiltersId")
-                                .HasColumnType("uuid");
-
-                            b1.Property<int>("Id")
-                                .ValueGeneratedOnAdd()
-                                .HasColumnType("integer");
-
-                            b1.Property<Guid>("Identifier")
-                                .HasColumnType("uuid")
-                                .HasAnnotation("Relational:JsonPropertyName", "Id");
-
-                            b1.Property<string>("Type")
-                                .IsRequired()
-                                .HasColumnType("text");
-
-                            b1.HasKey("ChangeSetFiltersId", "Id");
-
-                            b1.ToTable("ChangeSetFilters");
-
-                            b1.ToJson("Changes");
-
-                            b1.WithOwner()
-                                .HasForeignKey("ChangeSetFiltersId");
-
-                            b1.OwnsOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.FilterChangeState", "CurrentState", b2 =>
-                                {
-                                    b2.Property<Guid>("ChangeSetFiltersId")
-                                        .HasColumnType("uuid");
-
-                                    b2.Property<int>("ChangeId")
-                                        .HasColumnType("integer");
-
-                                    b2.Property<string>("Hint")
-                                        .IsRequired()
-                                        .HasColumnType("text");
-
-                                    b2.Property<string>("Id")
-                                        .IsRequired()
-                                        .HasColumnType("text");
-
-                                    b2.Property<string>("Label")
-                                        .IsRequired()
-                                        .HasColumnType("text");
-
-                                    b2.HasKey("ChangeSetFiltersId", "ChangeId");
-
-                                    b2.ToTable("ChangeSetFilters");
-
-                                    b2.WithOwner()
-                                        .HasForeignKey("ChangeSetFiltersId", "ChangeId");
-                                });
-
-                            b1.OwnsOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.FilterChangeState", "PreviousState", b2 =>
-                                {
-                                    b2.Property<Guid>("ChangeSetFiltersId")
-                                        .HasColumnType("uuid");
-
-                                    b2.Property<int>("ChangeId")
-                                        .HasColumnType("integer");
-
-                                    b2.Property<string>("Hint")
-                                        .IsRequired()
-                                        .HasColumnType("text");
-
-                                    b2.Property<string>("Id")
-                                        .IsRequired()
-                                        .HasColumnType("text");
-
-                                    b2.Property<string>("Label")
-                                        .IsRequired()
-                                        .HasColumnType("text");
-
-                                    b2.HasKey("ChangeSetFiltersId", "ChangeId");
-
-                                    b2.ToTable("ChangeSetFilters");
-
-                                    b2.WithOwner()
-                                        .HasForeignKey("ChangeSetFiltersId", "ChangeId");
-                                });
-
-                            b1.Navigation("CurrentState");
-
-                            b1.Navigation("PreviousState");
-                        });
-
-                    b.Navigation("Changes");
-
-                    b.Navigation("DataSetVersion");
-                });
-
-            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.ChangeSetIndicators", b =>
-                {
-                    b.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.DataSetVersion", "DataSetVersion")
-                        .WithMany("IndicatorChanges")
-                        .HasForeignKey("DataSetVersionId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.OwnsMany("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.Change<GovUk.Education.ExploreEducationStatistics.Public.Data.Model.IndicatorChangeState>", "Changes", b1 =>
-                        {
-                            b1.Property<Guid>("ChangeSetIndicatorsId")
-                                .HasColumnType("uuid");
-
-                            b1.Property<int>("Id")
-                                .ValueGeneratedOnAdd()
-                                .HasColumnType("integer");
-
-                            b1.Property<Guid>("Identifier")
-                                .HasColumnType("uuid")
-                                .HasAnnotation("Relational:JsonPropertyName", "Id");
-
-                            b1.Property<string>("Type")
-                                .IsRequired()
-                                .HasColumnType("text");
-
-                            b1.HasKey("ChangeSetIndicatorsId", "Id");
-
-                            b1.ToTable("ChangeSetIndicators");
-
-                            b1.ToJson("Changes");
-
-                            b1.WithOwner()
-                                .HasForeignKey("ChangeSetIndicatorsId");
-
-                            b1.OwnsOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.IndicatorChangeState", "CurrentState", b2 =>
-                                {
-                                    b2.Property<Guid>("ChangeSetIndicatorsId")
-                                        .HasColumnType("uuid");
-
-                                    b2.Property<int>("ChangeId")
-                                        .HasColumnType("integer");
-
-                                    b2.Property<byte?>("DecimalPlaces")
-                                        .HasColumnType("smallint");
-
-                                    b2.Property<string>("Id")
-                                        .IsRequired()
-                                        .HasColumnType("text");
-
-                                    b2.Property<string>("Label")
-                                        .IsRequired()
-                                        .HasColumnType("text");
-
-                                    b2.Property<string>("Unit")
-                                        .HasColumnType("text");
-
-                                    b2.HasKey("ChangeSetIndicatorsId", "ChangeId");
-
-                                    b2.ToTable("ChangeSetIndicators");
-
-                                    b2.WithOwner()
-                                        .HasForeignKey("ChangeSetIndicatorsId", "ChangeId");
-                                });
-
-                            b1.OwnsOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.IndicatorChangeState", "PreviousState", b2 =>
-                                {
-                                    b2.Property<Guid>("ChangeSetIndicatorsId")
-                                        .HasColumnType("uuid");
-
-                                    b2.Property<int>("ChangeId")
-                                        .HasColumnType("integer");
-
-                                    b2.Property<byte?>("DecimalPlaces")
-                                        .HasColumnType("smallint");
-
-                                    b2.Property<string>("Id")
-                                        .IsRequired()
-                                        .HasColumnType("text");
-
-                                    b2.Property<string>("Label")
-                                        .IsRequired()
-                                        .HasColumnType("text");
-
-                                    b2.Property<string>("Unit")
-                                        .HasColumnType("text");
-
-                                    b2.HasKey("ChangeSetIndicatorsId", "ChangeId");
-
-                                    b2.ToTable("ChangeSetIndicators");
-
-                                    b2.WithOwner()
-                                        .HasForeignKey("ChangeSetIndicatorsId", "ChangeId");
-                                });
-
-                            b1.Navigation("CurrentState");
-
-                            b1.Navigation("PreviousState");
-                        });
-
-                    b.Navigation("Changes");
-
-                    b.Navigation("DataSetVersion");
-                });
-
-            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.ChangeSetLocations", b =>
-                {
-                    b.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.DataSetVersion", "DataSetVersion")
-                        .WithMany("LocationChanges")
-                        .HasForeignKey("DataSetVersionId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.OwnsMany("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.Change<GovUk.Education.ExploreEducationStatistics.Public.Data.Model.LocationChangeState>", "Changes", b1 =>
-                        {
-                            b1.Property<Guid>("ChangeSetLocationsId")
-                                .HasColumnType("uuid");
-
-                            b1.Property<int>("Id")
-                                .ValueGeneratedOnAdd()
-                                .HasColumnType("integer");
-
-                            b1.Property<Guid>("Identifier")
-                                .HasColumnType("uuid")
-                                .HasAnnotation("Relational:JsonPropertyName", "Id");
-
-                            b1.Property<string>("Type")
-                                .IsRequired()
-                                .HasColumnType("text");
-
-                            b1.HasKey("ChangeSetLocationsId", "Id");
-
-                            b1.ToTable("ChangeSetLocations");
-
-                            b1.ToJson("Changes");
-
-                            b1.WithOwner()
-                                .HasForeignKey("ChangeSetLocationsId");
-
-                            b1.OwnsOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.LocationChangeState", "CurrentState", b2 =>
-                                {
-                                    b2.Property<Guid>("ChangeSetLocationsId")
-                                        .HasColumnType("uuid");
-
-                                    b2.Property<int>("ChangeId")
-                                        .HasColumnType("integer");
-
-                                    b2.Property<string>("Code")
-                                        .IsRequired()
-                                        .HasColumnType("text");
-
-                                    b2.Property<string>("Id")
-                                        .IsRequired()
-                                        .HasColumnType("text");
-
-                                    b2.Property<string>("Label")
-                                        .IsRequired()
-                                        .HasColumnType("text");
-
-                                    b2.Property<string>("Level")
-                                        .IsRequired()
-                                        .HasColumnType("text");
-
-                                    b2.HasKey("ChangeSetLocationsId", "ChangeId");
-
-                                    b2.ToTable("ChangeSetLocations");
-
-                                    b2.WithOwner()
-                                        .HasForeignKey("ChangeSetLocationsId", "ChangeId");
-                                });
-
-                            b1.OwnsOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.LocationChangeState", "PreviousState", b2 =>
-                                {
-                                    b2.Property<Guid>("ChangeSetLocationsId")
-                                        .HasColumnType("uuid");
-
-                                    b2.Property<int>("ChangeId")
-                                        .HasColumnType("integer");
-
-                                    b2.Property<string>("Code")
-                                        .IsRequired()
-                                        .HasColumnType("text");
-
-                                    b2.Property<string>("Id")
-                                        .IsRequired()
-                                        .HasColumnType("text");
-
-                                    b2.Property<string>("Label")
-                                        .IsRequired()
-                                        .HasColumnType("text");
-
-                                    b2.Property<int>("Level")
-                                        .HasColumnType("integer");
-
-                                    b2.HasKey("ChangeSetLocationsId", "ChangeId");
-
-                                    b2.ToTable("ChangeSetLocations");
-
-                                    b2.WithOwner()
-                                        .HasForeignKey("ChangeSetLocationsId", "ChangeId");
-                                });
-
-                            b1.Navigation("CurrentState");
-
-                            b1.Navigation("PreviousState");
-                        });
-
-                    b.Navigation("Changes");
-
-                    b.Navigation("DataSetVersion");
-                });
-
-            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.ChangeSetTimePeriods", b =>
-                {
-                    b.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.DataSetVersion", "DataSetVersion")
-                        .WithMany("TimePeriodChanges")
-                        .HasForeignKey("DataSetVersionId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.OwnsMany("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.Change<GovUk.Education.ExploreEducationStatistics.Public.Data.Model.TimePeriodChangeState>", "Changes", b1 =>
-                        {
-                            b1.Property<Guid>("ChangeSetTimePeriodsId")
-                                .HasColumnType("uuid");
-
-                            b1.Property<int>("Id")
-                                .ValueGeneratedOnAdd()
-                                .HasColumnType("integer");
-
-                            b1.Property<Guid>("Identifier")
-                                .HasColumnType("uuid")
-                                .HasAnnotation("Relational:JsonPropertyName", "Id");
-
-                            b1.Property<string>("Type")
-                                .IsRequired()
-                                .HasColumnType("text");
-
-                            b1.HasKey("ChangeSetTimePeriodsId", "Id");
-
-                            b1.ToTable("ChangeSetTimePeriods");
-
-                            b1.ToJson("Changes");
-
-                            b1.WithOwner()
-                                .HasForeignKey("ChangeSetTimePeriodsId");
-
-                            b1.OwnsOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.TimePeriodChangeState", "CurrentState", b2 =>
-                                {
-                                    b2.Property<Guid>("ChangeSetTimePeriodsId")
-                                        .HasColumnType("uuid");
-
-                                    b2.Property<int>("ChangeId")
-                                        .HasColumnType("integer");
-
-                                    b2.Property<string>("Code")
-                                        .IsRequired()
-                                        .HasColumnType("text");
-
-                                    b2.Property<int>("Year")
-                                        .HasColumnType("integer");
-
-                                    b2.HasKey("ChangeSetTimePeriodsId", "ChangeId");
-
-                                    b2.ToTable("ChangeSetTimePeriods");
-
-                                    b2.WithOwner()
-                                        .HasForeignKey("ChangeSetTimePeriodsId", "ChangeId");
-                                });
-
-                            b1.OwnsOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.TimePeriodChangeState", "PreviousState", b2 =>
-                                {
-                                    b2.Property<Guid>("ChangeSetTimePeriodsId")
-                                        .HasColumnType("uuid");
-
-                                    b2.Property<int>("ChangeId")
-                                        .HasColumnType("integer");
-
-                                    b2.Property<string>("Code")
-                                        .IsRequired()
-                                        .HasColumnType("text");
-
-                                    b2.Property<int>("Year")
-                                        .HasColumnType("integer");
-
-                                    b2.HasKey("ChangeSetTimePeriodsId", "ChangeId");
-
-                                    b2.ToTable("ChangeSetTimePeriods");
-
-                                    b2.WithOwner()
-                                        .HasForeignKey("ChangeSetTimePeriodsId", "ChangeId");
-                                });
-
-                            b1.Navigation("CurrentState");
-
-                            b1.Navigation("PreviousState");
-                        });
-
-                    b.Navigation("Changes");
-
-                    b.Navigation("DataSetVersion");
-                });
-
-            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.DataSet", b =>
-                {
-                    b.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.DataSetVersion", "LatestDraftVersion")
-                        .WithOne()
-                        .HasForeignKey("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.DataSet", "LatestDraftVersionId");
-
-                    b.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.DataSetVersion", "LatestLiveVersion")
-                        .WithOne()
-                        .HasForeignKey("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.DataSet", "LatestLiveVersionId");
-
-                    b.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.DataSet", "SupersedingDataSet")
-                        .WithMany()
-                        .HasForeignKey("SupersedingDataSetId");
-
-                    b.Navigation("LatestDraftVersion");
-
-                    b.Navigation("LatestLiveVersion");
-
-                    b.Navigation("SupersedingDataSet");
-                });
+                    b.Navigation("SupersedingDataSet");
+                });
 
             modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.DataSetVersion", b =>
                 {
@@ -1381,6 +941,130 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.Navigation("DataSetVersion");
                 });
 
+            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.FilterMetaChange", b =>
+                {
+                    b.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.FilterMeta", "CurrentState")
+                        .WithMany()
+                        .HasForeignKey("CurrentStateId");
+
+                    b.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.DataSetVersion", "DataSetVersion")
+                        .WithMany("FilterMetaChanges")
+                        .HasForeignKey("DataSetVersionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.FilterMeta", "PreviousState")
+                        .WithMany()
+                        .HasForeignKey("PreviousStateId");
+
+                    b.Navigation("CurrentState");
+
+                    b.Navigation("DataSetVersion");
+
+                    b.Navigation("PreviousState");
+                });
+
+            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.FilterOptionMetaChange", b =>
+                {
+                    b.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.DataSetVersion", "DataSetVersion")
+                        .WithMany("FilterOptionMetaChanges")
+                        .HasForeignKey("DataSetVersionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.OwnsOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.FilterOptionMetaChange+State", "CurrentState", b1 =>
+                        {
+                            b1.Property<long>("FilterOptionMetaChangeId")
+                                .HasColumnType("bigint");
+
+                            b1.Property<int>("MetaId")
+                                .HasColumnType("integer");
+
+                            b1.Property<int>("OptionId")
+                                .HasColumnType("integer");
+
+                            b1.Property<string>("PublicId")
+                                .IsRequired()
+                                .HasColumnType("text");
+
+                            b1.HasKey("FilterOptionMetaChangeId");
+
+                            b1.HasIndex("MetaId");
+
+                            b1.HasIndex("OptionId");
+
+                            b1.ToTable("FilterOptionMetaChanges");
+
+                            b1.WithOwner()
+                                .HasForeignKey("FilterOptionMetaChangeId");
+
+                            b1.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.FilterMeta", "Meta")
+                                .WithMany()
+                                .HasForeignKey("MetaId")
+                                .OnDelete(DeleteBehavior.Cascade)
+                                .IsRequired();
+
+                            b1.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.FilterOptionMeta", "Option")
+                                .WithMany()
+                                .HasForeignKey("OptionId")
+                                .OnDelete(DeleteBehavior.Cascade)
+                                .IsRequired();
+
+                            b1.Navigation("Meta");
+
+                            b1.Navigation("Option");
+                        });
+
+                    b.OwnsOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.FilterOptionMetaChange+State", "PreviousState", b1 =>
+                        {
+                            b1.Property<long>("FilterOptionMetaChangeId")
+                                .HasColumnType("bigint");
+
+                            b1.Property<int>("MetaId")
+                                .HasColumnType("integer");
+
+                            b1.Property<int>("OptionId")
+                                .HasColumnType("integer");
+
+                            b1.Property<string>("PublicId")
+                                .IsRequired()
+                                .HasColumnType("text");
+
+                            b1.HasKey("FilterOptionMetaChangeId");
+
+                            b1.HasIndex("MetaId");
+
+                            b1.HasIndex("OptionId");
+
+                            b1.ToTable("FilterOptionMetaChanges");
+
+                            b1.WithOwner()
+                                .HasForeignKey("FilterOptionMetaChangeId");
+
+                            b1.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.FilterMeta", "Meta")
+                                .WithMany()
+                                .HasForeignKey("MetaId")
+                                .OnDelete(DeleteBehavior.Cascade)
+                                .IsRequired();
+
+                            b1.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.FilterOptionMeta", "Option")
+                                .WithMany()
+                                .HasForeignKey("OptionId")
+                                .OnDelete(DeleteBehavior.Cascade)
+                                .IsRequired();
+
+                            b1.Navigation("Meta");
+
+                            b1.Navigation("Option");
+                        });
+
+                    b.Navigation("CurrentState");
+
+                    b.Navigation("DataSetVersion");
+
+                    b.Navigation("PreviousState");
+                });
+
             modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.FilterOptionMetaLink", b =>
                 {
                     b.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.FilterMeta", "Meta")
@@ -1411,6 +1095,29 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.Navigation("DataSetVersion");
                 });
 
+            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.GeographicLevelMetaChange", b =>
+                {
+                    b.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.GeographicLevelMeta", "CurrentState")
+                        .WithMany()
+                        .HasForeignKey("CurrentStateId");
+
+                    b.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.DataSetVersion", "DataSetVersion")
+                        .WithOne("GeographicLevelMetaChange")
+                        .HasForeignKey("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.GeographicLevelMetaChange", "DataSetVersionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.GeographicLevelMeta", "PreviousState")
+                        .WithMany()
+                        .HasForeignKey("PreviousStateId");
+
+                    b.Navigation("CurrentState");
+
+                    b.Navigation("DataSetVersion");
+
+                    b.Navigation("PreviousState");
+                });
+
             modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.IndicatorMeta", b =>
                 {
                     b.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.DataSetVersion", "DataSetVersion")
@@ -1422,6 +1129,29 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.Navigation("DataSetVersion");
                 });
 
+            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.IndicatorMetaChange", b =>
+                {
+                    b.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.IndicatorMeta", "CurrentState")
+                        .WithMany()
+                        .HasForeignKey("CurrentStateId");
+
+                    b.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.DataSetVersion", "DataSetVersion")
+                        .WithMany("IndicatorMetaChanges")
+                        .HasForeignKey("DataSetVersionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.IndicatorMeta", "PreviousState")
+                        .WithMany()
+                        .HasForeignKey("PreviousStateId");
+
+                    b.Navigation("CurrentState");
+
+                    b.Navigation("DataSetVersion");
+
+                    b.Navigation("PreviousState");
+                });
+
             modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.LocationMeta", b =>
                 {
                     b.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.DataSetVersion", "DataSetVersion")
@@ -1433,6 +1163,122 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.Navigation("DataSetVersion");
                 });
 
+            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.LocationMetaChange", b =>
+                {
+                    b.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.LocationMeta", "CurrentState")
+                        .WithMany()
+                        .HasForeignKey("CurrentStateId");
+
+                    b.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.DataSetVersion", "DataSetVersion")
+                        .WithMany("LocationMetaChanges")
+                        .HasForeignKey("DataSetVersionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.LocationMeta", "PreviousState")
+                        .WithMany()
+                        .HasForeignKey("PreviousStateId");
+
+                    b.Navigation("CurrentState");
+
+                    b.Navigation("DataSetVersion");
+
+                    b.Navigation("PreviousState");
+                });
+
+            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.LocationOptionMetaChange", b =>
+                {
+                    b.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.DataSetVersion", "DataSetVersion")
+                        .WithMany("LocationOptionMetaChanges")
+                        .HasForeignKey("DataSetVersionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.OwnsOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.LocationOptionMetaChange+State", "CurrentState", b1 =>
+                        {
+                            b1.Property<long>("LocationOptionMetaChangeId")
+                                .HasColumnType("bigint");
+
+                            b1.Property<int>("MetaId")
+                                .HasColumnType("integer");
+
+                            b1.Property<int>("OptionId")
+                                .HasColumnType("integer");
+
+                            b1.HasKey("LocationOptionMetaChangeId");
+
+                            b1.HasIndex("MetaId");
+
+                            b1.HasIndex("OptionId");
+
+                            b1.ToTable("LocationOptionMetaChanges");
+
+                            b1.WithOwner()
+                                .HasForeignKey("LocationOptionMetaChangeId");
+
+                            b1.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.LocationMeta", "Meta")
+                                .WithMany()
+                                .HasForeignKey("MetaId")
+                                .OnDelete(DeleteBehavior.Cascade)
+                                .IsRequired();
+
+                            b1.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.LocationOptionMeta", "Option")
+                                .WithMany()
+                                .HasForeignKey("OptionId")
+                                .OnDelete(DeleteBehavior.Cascade)
+                                .IsRequired();
+
+                            b1.Navigation("Meta");
+
+                            b1.Navigation("Option");
+                        });
+
+                    b.OwnsOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.LocationOptionMetaChange+State", "PreviousState", b1 =>
+                        {
+                            b1.Property<long>("LocationOptionMetaChangeId")
+                                .HasColumnType("bigint");
+
+                            b1.Property<int>("MetaId")
+                                .HasColumnType("integer");
+
+                            b1.Property<int>("OptionId")
+                                .HasColumnType("integer");
+
+                            b1.HasKey("LocationOptionMetaChangeId");
+
+                            b1.HasIndex("MetaId");
+
+                            b1.HasIndex("OptionId");
+
+                            b1.ToTable("LocationOptionMetaChanges");
+
+                            b1.WithOwner()
+                                .HasForeignKey("LocationOptionMetaChangeId");
+
+                            b1.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.LocationMeta", "Meta")
+                                .WithMany()
+                                .HasForeignKey("MetaId")
+                                .OnDelete(DeleteBehavior.Cascade)
+                                .IsRequired();
+
+                            b1.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.LocationOptionMeta", "Option")
+                                .WithMany()
+                                .HasForeignKey("OptionId")
+                                .OnDelete(DeleteBehavior.Cascade)
+                                .IsRequired();
+
+                            b1.Navigation("Meta");
+
+                            b1.Navigation("Option");
+                        });
+
+                    b.Navigation("CurrentState");
+
+                    b.Navigation("DataSetVersion");
+
+                    b.Navigation("PreviousState");
+                });
+
             modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.LocationOptionMetaLink", b =>
                 {
                     b.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.LocationMeta", "Meta")
@@ -1474,6 +1320,29 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.Navigation("DataSetVersion");
                 });
 
+            modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.TimePeriodMetaChange", b =>
+                {
+                    b.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.TimePeriodMeta", "CurrentState")
+                        .WithMany()
+                        .HasForeignKey("CurrentStateId");
+
+                    b.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.DataSetVersion", "DataSetVersion")
+                        .WithMany("TimePeriodMetaChanges")
+                        .HasForeignKey("DataSetVersionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.TimePeriodMeta", "PreviousState")
+                        .WithMany()
+                        .HasForeignKey("PreviousStateId");
+
+                    b.Navigation("CurrentState");
+
+                    b.Navigation("DataSetVersion");
+
+                    b.Navigation("PreviousState");
+                });
+
             modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.DataSet", b =>
                 {
                     b.Navigation("Versions");
@@ -1481,27 +1350,31 @@ protected override void BuildModel(ModelBuilder modelBuilder)
 
             modelBuilder.Entity("GovUk.Education.ExploreEducationStatistics.Public.Data.Model.DataSetVersion", b =>
                 {
-                    b.Navigation("FilterChanges");
+                    b.Navigation("FilterMetaChanges");
 
                     b.Navigation("FilterMetas");
 
-                    b.Navigation("FilterOptionChanges");
+                    b.Navigation("FilterOptionMetaChanges");
 
                     b.Navigation("GeographicLevelMeta");
 
+                    b.Navigation("GeographicLevelMetaChange");
+
                     b.Navigation("Imports");
 
-                    b.Navigation("IndicatorChanges");
+                    b.Navigation("IndicatorMetaChanges");
 
                     b.Navigation("IndicatorMetas");
 
-                    b.Navigation("LocationChanges");
+                    b.Navigation("LocationMetaChanges");
 
                     b.Navigation("LocationMetas");
 
+                    b.Navigation("LocationOptionMetaChanges");
+
                     b.Navigation("PreviewTokens");
 
-                    b.Navigation("TimePeriodChanges");
+                    b.Navigation("TimePeriodMetaChanges");
 
                     b.Navigation("TimePeriodMetas");
                 });
diff --git a/src/GovUk.Education.ExploreEducationStatistics.Public.Data.Model/TimePeriodChangeState.cs b/src/GovUk.Education.ExploreEducationStatistics.Public.Data.Model/TimePeriodChangeState.cs
deleted file mode 100644
index e0a5baa835d..00000000000
--- a/src/GovUk.Education.ExploreEducationStatistics.Public.Data.Model/TimePeriodChangeState.cs
+++ /dev/null
@@ -1,10 +0,0 @@
-using GovUk.Education.ExploreEducationStatistics.Common.Model;
-
-namespace GovUk.Education.ExploreEducationStatistics.Public.Data.Model;
-
-public class TimePeriodChangeState
-{
-    public required TimeIdentifier Code { get; set; }
-
-    public required int Year { get; set; }
-}