refactor: Model store and query API

Use Adapters to simplify API usage.

73 files changed, 1344 insertions, 691 deletions

diff --git a/subprojects/store/src/main/java/tools/refinery/store/adapter/AbstractModelAdapterBuilder.java b/subprojects/store/src/main/java/tools/refinery/store/adapter/AbstractModelAdapterBuilder.java
new file mode 100644
index 00000000..4c142217
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/adapter/AbstractModelAdapterBuilder.java
@@ -0,0 +1,27 @@
+package tools.refinery.store.adapter;
+
+import tools.refinery.store.model.ModelStore;
+import tools.refinery.store.model.ModelStoreBuilder;
+
+public abstract class AbstractModelAdapterBuilder implements ModelAdapterBuilder {
+        private final ModelStoreBuilder storeBuilder;
+
+        protected AbstractModelAdapterBuilder(ModelStoreBuilder storeBuilder) {
+                this.storeBuilder = storeBuilder;
+        }
+
+        @Override
+        public <T extends ModelAdapterBuilder> T with(ModelAdapterBuilderFactory<?, ?, T> adapterBuilderFactory) {
+                return storeBuilder.with(adapterBuilderFactory);
+        }
+
+        @Override
+        public ModelStoreBuilder getStoreBuilder() {
+                return storeBuilder;
+        }
+
+        @Override
+        public ModelStore build() {
+                return storeBuilder.build();
+        }
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/adapter/AdapterList.java b/subprojects/store/src/main/java/tools/refinery/store/adapter/AdapterList.java
new file mode 100644
index 00000000..2783675f
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/adapter/AdapterList.java
@@ -0,0 +1,94 @@
+package tools.refinery.store.adapter;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.*;
+import java.util.function.Consumer;
+
+public class AdapterList<T> implements Iterable<T> {
+        private final List<AnyModelAdapterType> adapterTypes;
+        private final List<T> adapters;
+
+        public AdapterList() {
+                adapterTypes = new ArrayList<>();
+                adapters = new ArrayList<>();
+        }
+
+        public AdapterList(int adapterCount) {
+                adapterTypes = new ArrayList<>(adapterCount);
+                adapters = new ArrayList<>(adapterCount);
+        }
+
+        public int size() {
+                return adapters.size();
+        }
+
+        public void add(AnyModelAdapterType adapterType, T adapter) {
+                adapterTypes.add(adapterType);
+                adapters.add(adapter);
+        }
+
+        public <U extends T> Optional<U> tryGet(AnyModelAdapterType adapterType, Class<? extends U> adapterClass) {
+                int size = size();
+                for (int i = 0; i < size; i++) {
+                        if (getType(i).supports(adapterType)) {
+                                return Optional.of(adapterClass.cast(get(i)));
+                        }
+                }
+                return Optional.empty();
+        }
+
+        public <U extends T> U get(AnyModelAdapterType adapterType, Class<U> adapterClass) {
+                return tryGet(adapterType, adapterClass).orElseThrow(() -> new IllegalArgumentException(
+                                "No %s was configured".formatted(adapterType)));
+        }
+
+        public AnyModelAdapterType getType(int i) {
+                return adapterTypes.get(i);
+        }
+
+        public T get(int i) {
+                return adapters.get(i);
+        }
+
+        public Collection<AnyModelAdapterType> getAdapterTypes() {
+                return Collections.unmodifiableCollection(adapterTypes);
+        }
+
+        public Iterable<Entry<T>> withAdapterTypes() {
+                return () -> new Iterator<>() {
+                        private int i = 0;
+
+                        @Override
+                        public boolean hasNext() {
+                                return i < size();
+                        }
+
+                        @Override
+                        public Entry<T> next() {
+                                var entry = new Entry<>(getType(i), get(i));
+                                i++;
+                                return entry;
+                        }
+                };
+        }
+
+        @NotNull
+        @Override
+        public Iterator<T> iterator() {
+                return adapters.iterator();
+        }
+
+        @Override
+        public void forEach(Consumer<? super T> action) {
+                adapters.forEach(action);
+        }
+
+        @Override
+        public Spliterator<T> spliterator() {
+                return adapters.spliterator();
+        }
+
+        public record Entry<T>(AnyModelAdapterType adapterType, T adapter) {
+        }
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/adapter/AnyModelAdapterType.java b/subprojects/store/src/main/java/tools/refinery/store/adapter/AnyModelAdapterType.java
new file mode 100644
index 00000000..37a247fe
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/adapter/AnyModelAdapterType.java
@@ -0,0 +1,19 @@
+package tools.refinery.store.adapter;
+
+import java.util.Collection;
+
+public sealed interface AnyModelAdapterType permits ModelAdapterType {
+        Class<? extends ModelAdapter> getModelAdapterClass();
+
+        Class<? extends ModelStoreAdapter> getModelStoreAdapterClass();
+
+        Class<? extends ModelAdapterBuilder> getModelAdapterBuilderClass();
+
+        Collection<AnyModelAdapterType> getSupportedAdapterTypes();
+
+        default boolean supports(AnyModelAdapterType targetAdapter) {
+                return getSupportedAdapterTypes().contains(targetAdapter);
+        }
+
+        String getName();
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/adapter/ModelAdapter.java b/subprojects/store/src/main/java/tools/refinery/store/adapter/ModelAdapter.java
new file mode 100644
index 00000000..aa079e01
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/adapter/ModelAdapter.java
@@ -0,0 +1,9 @@
+package tools.refinery.store.adapter;
+
+import tools.refinery.store.model.Model;
+
+public interface ModelAdapter {
+        Model getModel();
+
+        ModelStoreAdapter getStoreAdapter();
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/adapter/ModelAdapterBuilder.java b/subprojects/store/src/main/java/tools/refinery/store/adapter/ModelAdapterBuilder.java
new file mode 100644
index 00000000..64b3e59f
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/adapter/ModelAdapterBuilder.java
@@ -0,0 +1,17 @@
+package tools.refinery.store.adapter;
+
+import tools.refinery.store.model.ModelStore;
+import tools.refinery.store.model.ModelStoreBuilder;
+
+public interface ModelAdapterBuilder {
+        ModelStoreAdapter createStoreAdapter(ModelStore store);
+
+        <T extends ModelAdapterBuilder> T with(ModelAdapterBuilderFactory<?, ?, T> adapterBuilderFactory);
+
+        ModelStoreBuilder getStoreBuilder();
+
+        default void configure() {
+        }
+
+        ModelStore build();
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/adapter/ModelAdapterBuilderFactory.java b/subprojects/store/src/main/java/tools/refinery/store/adapter/ModelAdapterBuilderFactory.java
new file mode 100644
index 00000000..7c9b01bc
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/adapter/ModelAdapterBuilderFactory.java
@@ -0,0 +1,14 @@
+package tools.refinery.store.adapter;
+
+import tools.refinery.store.model.ModelStoreBuilder;
+
+public abstract class ModelAdapterBuilderFactory<T1 extends ModelAdapter, T2 extends ModelStoreAdapter,
+                T3 extends ModelAdapterBuilder> extends ModelAdapterType<T1, T2, T3> {
+
+        protected ModelAdapterBuilderFactory(Class<T1> modelAdapterClass, Class<T2> modelStoreAdapterClass,
+                                                                                 Class<T3> modelAdapterBuilderClass) {
+                super(modelAdapterClass, modelStoreAdapterClass, modelAdapterBuilderClass);
+        }
+
+        public abstract T3 createBuilder(ModelStoreBuilder storeBuilder);
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/adapter/ModelAdapterType.java b/subprojects/store/src/main/java/tools/refinery/store/adapter/ModelAdapterType.java
new file mode 100644
index 00000000..82ddeb12
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/adapter/ModelAdapterType.java
@@ -0,0 +1,79 @@
+package tools.refinery.store.adapter;
+
+import tools.refinery.store.model.Model;
+import tools.refinery.store.model.ModelStore;
+
+import java.lang.reflect.Method;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
+
+public abstract non-sealed class ModelAdapterType<T1 extends ModelAdapter, T2 extends ModelStoreAdapter,
+                T3 extends ModelAdapterBuilder> implements AnyModelAdapterType {
+        private final Class<? extends T1> modelAdapterClass;
+        private final Class<? extends T2> modelStoreAdapterClass;
+        private final Class<? extends T3> modelAdapterBuilderClass;
+        private final Set<AnyModelAdapterType> supportedAdapters = new HashSet<>();
+
+        protected ModelAdapterType(Class<T1> modelAdapterClass, Class<T2> modelStoreAdapterClass,
+                                                           Class<T3> modelAdapterBuilderClass) {
+                checkReturnType(modelAdapterClass, modelStoreAdapterClass, "createModelAdapter", Model.class);
+                checkReturnType(modelStoreAdapterClass, modelAdapterBuilderClass, "createStoreAdapter", ModelStore.class);
+                this.modelAdapterClass = modelAdapterClass;
+                this.modelStoreAdapterClass = modelStoreAdapterClass;
+                this.modelAdapterBuilderClass = modelAdapterBuilderClass;
+                supportedAdapters.add(this);
+        }
+
+        private void checkReturnType(Class<?> expectedReturnType, Class<?> ownerClass, String methodName,
+                                                                 Class<?>... argumentTypes) {
+                Method method;
+                try {
+                        method = ownerClass.getMethod(methodName, argumentTypes);
+                } catch (NoSuchMethodException e) {
+                        throw new IllegalStateException("Invalid %s: %s#%s method is required"
+                                        .formatted(this, ownerClass.getName(), methodName), e);
+                }
+                var returnType = method.getReturnType();
+                if (!expectedReturnType.isAssignableFrom(returnType)) {
+                        throw new IllegalStateException("Invalid %s: %s is not assignable from the return type %s of %s#%s"
+                                        .formatted(this, expectedReturnType.getName(), returnType.getCanonicalName(),
+                                                        ownerClass.getName(), methodName));
+                }
+        }
+
+        protected void extendsAdapter(ModelAdapterType<? super T1, ? super T2, ? super T3> superAdapter) {
+                supportedAdapters.addAll(superAdapter.supportedAdapters);
+        }
+
+        @Override
+        public final Class<? extends T1> getModelAdapterClass() {
+                return modelAdapterClass;
+        }
+
+        @Override
+        public final Class<? extends T2> getModelStoreAdapterClass() {
+                return modelStoreAdapterClass;
+        }
+
+        @Override
+        public final Class<? extends T3> getModelAdapterBuilderClass() {
+                return modelAdapterBuilderClass;
+        }
+
+        @Override
+        public Collection<AnyModelAdapterType> getSupportedAdapterTypes() {
+                return Collections.unmodifiableCollection(supportedAdapters);
+        }
+
+        @Override
+        public String getName() {
+                return "%s.ADAPTER".formatted(this.getClass().getName());
+        }
+
+        @Override
+        public String toString() {
+                return getName();
+        }
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/adapter/ModelStoreAdapter.java b/subprojects/store/src/main/java/tools/refinery/store/adapter/ModelStoreAdapter.java
new file mode 100644
index 00000000..1eb40ada
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/adapter/ModelStoreAdapter.java
@@ -0,0 +1,10 @@
+package tools.refinery.store.adapter;
+
+import tools.refinery.store.model.Model;
+import tools.refinery.store.model.ModelStore;
+
+public interface ModelStoreAdapter {
+        ModelStore getStore();
+
+        ModelAdapter createModelAdapter(Model model);
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/AnyInterpretation.java b/subprojects/store/src/main/java/tools/refinery/store/model/AnyInterpretation.java
new file mode 100644
index 00000000..d18ba71d
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/model/AnyInterpretation.java
@@ -0,0 +1,11 @@
+package tools.refinery.store.model;
+
+import tools.refinery.store.representation.AnySymbol;
+
+public sealed interface AnyInterpretation permits Interpretation {
+        Model getModel();
+
+        AnySymbol getSymbol();
+
+        long getSize();
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/Interpretation.java b/subprojects/store/src/main/java/tools/refinery/store/model/Interpretation.java
new file mode 100644
index 00000000..55949d0c
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/model/Interpretation.java
@@ -0,0 +1,25 @@
+package tools.refinery.store.model;
+
+import tools.refinery.store.map.Cursor;
+import tools.refinery.store.map.DiffCursor;
+import tools.refinery.store.representation.Symbol;
+import tools.refinery.store.tuple.Tuple;
+
+public non-sealed interface Interpretation<T> extends AnyInterpretation {
+        @Override
+        Symbol<T> getSymbol();
+
+        T get(Tuple key);
+
+        Cursor<Tuple, T> getAll();
+
+        T put(Tuple key, T value);
+
+        void putAll(Cursor<Tuple, T> cursor);
+
+        DiffCursor<Tuple, T> getDiffCursor(long to);
+
+        void addListener(InterpretationListener<T> listener, boolean alsoWhenRestoring);
+
+        void removeListener(InterpretationListener<T> listener);
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/InterpretationListener.java b/subprojects/store/src/main/java/tools/refinery/store/model/InterpretationListener.java
new file mode 100644
index 00000000..73950779
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/model/InterpretationListener.java
@@ -0,0 +1,7 @@
+package tools.refinery.store.model;
+
+import tools.refinery.store.tuple.Tuple;
+
+public interface InterpretationListener<T> {
+        void put(Tuple key, T fromValue, T toValue, boolean restoring);
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/Model.java b/subprojects/store/src/main/java/tools/refinery/store/model/Model.java
index 69f57389..8d2a4614 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/model/Model.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/model/Model.java
@@ -1,24 +1,31 @@
 package tools.refinery.store.model;
 
-import tools.refinery.store.map.Cursor;
+import tools.refinery.store.adapter.ModelAdapter;
+import tools.refinery.store.adapter.ModelAdapterType;
 import tools.refinery.store.map.Versioned;
-import tools.refinery.store.model.representation.AnyDataRepresentation;
-import tools.refinery.store.model.representation.DataRepresentation;
+import tools.refinery.store.representation.AnySymbol;
+import tools.refinery.store.representation.Symbol;
 
-import java.util.Set;
+import java.util.Optional;
 
 public interface Model extends Versioned {
-        Set<AnyDataRepresentation> getDataRepresentations();
+        ModelStore getStore();
 
-        <K, V> V get(DataRepresentation<K, V> representation, K key);
+        long getState();
 
-        <K, V> Cursor<K, V> getAll(DataRepresentation<K, V> representation);
+        default AnyInterpretation getInterpretation(AnySymbol symbol) {
+                return getInterpretation((Symbol<?>) symbol);
+        }
 
-        <K, V> V put(DataRepresentation<K, V> representation, K key, V value);
+        <T> Interpretation<T> getInterpretation(Symbol<T> symbol);
 
-        <K, V> void putAll(DataRepresentation<K, V> representation, Cursor<K, V> cursor);
+        ModelDiffCursor getDiffCursor(long to);
 
-        long getSize(AnyDataRepresentation representation);
+        <T extends ModelAdapter> Optional<T> tryGetAdapter(ModelAdapterType<? extends T, ?, ?> adapterType);
 
-        ModelDiffCursor getDiffCursor(long to);
+        <T extends ModelAdapter> T getAdapter(ModelAdapterType<T, ?, ?> adapterType);
+
+        void addListener(ModelListener listener);
+
+        void removeListener(ModelListener listener);
 }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/ModelDiffCursor.java b/subprojects/store/src/main/java/tools/refinery/store/model/ModelDiffCursor.java
index d5bb541b..97bf2039 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/model/ModelDiffCursor.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/model/ModelDiffCursor.java
@@ -1,27 +1,27 @@
 package tools.refinery.store.model;
 
-import tools.refinery.store.map.Cursor;
 import tools.refinery.store.map.DiffCursor;
-import tools.refinery.store.model.representation.AnyDataRepresentation;
-import tools.refinery.store.model.representation.DataRepresentation;
+import tools.refinery.store.representation.AnySymbol;
+import tools.refinery.store.representation.Symbol;
+import tools.refinery.store.tuple.Tuple;
 
 import java.util.Map;
 
 public class ModelDiffCursor {
-        final Map<AnyDataRepresentation, DiffCursor<?, ?>> diffCursors;
+        private final Map<? extends AnySymbol, ? extends DiffCursor<?, ?>> diffCursors;
 
-        public ModelDiffCursor(Map<AnyDataRepresentation, DiffCursor<?, ?>> diffCursors) {
+        public ModelDiffCursor(Map<? extends AnySymbol, ? extends DiffCursor<?, ?>> diffCursors) {
                 super();
                 this.diffCursors = diffCursors;
         }
 
-        @SuppressWarnings("unchecked")
-        public <K, V> DiffCursor<K, V> getCursor(DataRepresentation<K, V> representation) {
-                Cursor<?, ?> cursor = diffCursors.get(representation);
-                if (cursor != null) {
-                        return (DiffCursor<K, V>) cursor;
-                } else {
-                        throw new IllegalArgumentException("ModelCursor does not contain cursor for representation " + representation);
+        public <T> DiffCursor<Tuple, T> getCursor(Symbol<T> symbol) {
+                var cursor = diffCursors.get(symbol);
+                if (cursor == null) {
+                        throw new IllegalArgumentException("No cursor for symbol %s".formatted(symbol));
                 }
+                @SuppressWarnings("unchecked")
+                var typedCursor = (DiffCursor<Tuple, T>) cursor;
+                return typedCursor;
         }
 }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/ModelListener.java b/subprojects/store/src/main/java/tools/refinery/store/model/ModelListener.java
new file mode 100644
index 00000000..f67540bb
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/model/ModelListener.java
@@ -0,0 +1,15 @@
+package tools.refinery.store.model;
+
+public interface ModelListener {
+        default void beforeCommit() {
+        }
+
+        default void afterCommit() {
+        }
+
+        default void beforeRestore(long state) {
+        }
+
+        default void afterRestore() {
+        }
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/ModelStore.java b/subprojects/store/src/main/java/tools/refinery/store/model/ModelStore.java
index 84b67765..bc863d4b 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/model/ModelStore.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/model/ModelStore.java
@@ -1,11 +1,16 @@
 package tools.refinery.store.model;
 
-import tools.refinery.store.model.representation.AnyDataRepresentation;
+import tools.refinery.store.adapter.ModelAdapterType;
+import tools.refinery.store.adapter.ModelStoreAdapter;
+import tools.refinery.store.model.internal.ModelStoreBuilderImpl;
+import tools.refinery.store.representation.AnySymbol;
 
+import java.util.Collection;
+import java.util.Optional;
 import java.util.Set;
 
 public interface ModelStore {
-        Set<AnyDataRepresentation> getDataRepresentations();
+        Collection<AnySymbol> getSymbols();
 
         Model createModel();
 
@@ -14,4 +19,12 @@ public interface ModelStore {
         Set<Long> getStates();
 
         ModelDiffCursor getDiffCursor(long from, long to);
+
+        <T extends ModelStoreAdapter> Optional<T> tryGetAdapter(ModelAdapterType<?, ? extends T, ?> adapterType);
+
+        <T extends ModelStoreAdapter> T getAdapter(ModelAdapterType<?, T, ?> adapterType);
+
+        static ModelStoreBuilder builder() {
+                return new ModelStoreBuilderImpl();
+        }
 }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/ModelStoreBuilder.java b/subprojects/store/src/main/java/tools/refinery/store/model/ModelStoreBuilder.java
new file mode 100644
index 00000000..289099da
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/model/ModelStoreBuilder.java
@@ -0,0 +1,36 @@
+package tools.refinery.store.model;
+
+import tools.refinery.store.adapter.ModelAdapterBuilder;
+import tools.refinery.store.adapter.ModelAdapterBuilderFactory;
+import tools.refinery.store.adapter.ModelAdapterType;
+import tools.refinery.store.representation.AnySymbol;
+import tools.refinery.store.representation.Symbol;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.Optional;
+
+public interface ModelStoreBuilder {
+        default ModelStoreBuilder symbols(AnySymbol... symbols) {
+                return symbols(List.of(symbols));
+        }
+
+        default ModelStoreBuilder symbols(Collection<? extends AnySymbol> symbols) {
+                symbols.forEach(this::symbol);
+                return this;
+        }
+
+        default ModelStoreBuilder symbol(AnySymbol symbol) {
+                return symbol((Symbol<?>) symbol);
+        }
+
+        <T> ModelStoreBuilder symbol(Symbol<T> symbol);
+
+        <T extends ModelAdapterBuilder> T with(ModelAdapterBuilderFactory<?, ?, T> adapterBuilderFactory);
+
+        <T extends ModelAdapterBuilder> Optional<T> tryGetAdapter(ModelAdapterType<?, ?, ? extends T> adapterType);
+
+        <T extends ModelAdapterBuilder> T getAdapter(ModelAdapterType<?, ?, T> adapterType);
+
+        ModelStore build();
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/ModelStoreImpl.java b/subprojects/store/src/main/java/tools/refinery/store/model/ModelStoreImpl.java
deleted file mode 100644
index 2f73a0e5..00000000
--- a/subprojects/store/src/main/java/tools/refinery/store/model/ModelStoreImpl.java
+++ /dev/null
@@ -1,115 +0,0 @@
-package tools.refinery.store.model;
-
-import tools.refinery.store.map.*;
-import tools.refinery.store.model.internal.ModelImpl;
-import tools.refinery.store.model.internal.SimilarRelationEquivalenceClass;
-import tools.refinery.store.model.representation.AnyDataRepresentation;
-import tools.refinery.store.model.representation.AuxiliaryData;
-import tools.refinery.store.model.representation.DataRepresentation;
-import tools.refinery.store.model.representation.Relation;
-import tools.refinery.store.tuple.Tuple;
-
-import java.util.*;
-import java.util.Map.Entry;
-
-public class ModelStoreImpl implements ModelStore {
-
-        private final Map<AnyDataRepresentation, VersionedMapStore<?, ?>> stores;
-
-        public ModelStoreImpl(Set<AnyDataRepresentation> dataRepresentations) {
-                stores = initStores(dataRepresentations);
-        }
-
-        private Map<AnyDataRepresentation, VersionedMapStore<?, ?>> initStores(
-                        Set<AnyDataRepresentation> dataRepresentations) {
-                Map<AnyDataRepresentation, VersionedMapStore<?, ?>> result = new HashMap<>();
-
-                Map<SimilarRelationEquivalenceClass, List<Relation<?>>> symbolRepresentationsPerHashPerArity = new HashMap<>();
-
-                for (AnyDataRepresentation dataRepresentation : dataRepresentations) {
-                        if (dataRepresentation instanceof Relation<?> symbolRepresentation) {
-                                addOrCreate(symbolRepresentationsPerHashPerArity,
-                                                new SimilarRelationEquivalenceClass(symbolRepresentation), symbolRepresentation);
-                        } else if (dataRepresentation instanceof AuxiliaryData<?, ?> auxiliaryData) {
-                                VersionedMapStoreImpl<?, ?> store = new VersionedMapStoreImpl<>(auxiliaryData.getHashProvider(),
-                                                auxiliaryData.getDefaultValue());
-                                result.put(auxiliaryData, store);
-                        } else {
-                                throw new UnsupportedOperationException(
-                                                "Model store does not have strategy to use " + dataRepresentation.getClass() + "!");
-                        }
-                }
-                for (List<Relation<?>> symbolGroup : symbolRepresentationsPerHashPerArity.values()) {
-                        initRepresentationGroup(result, symbolGroup);
-                }
-
-                return result;
-        }
-
-        private void initRepresentationGroup(Map<AnyDataRepresentation, VersionedMapStore<?, ?>> result,
-                        List<Relation<?>> symbolGroup) {
-                final ContinousHashProvider<Tuple> hashProvider = symbolGroup.get(0).getHashProvider();
-                final Object defaultValue = symbolGroup.get(0).getDefaultValue();
-
-                List<VersionedMapStore<Tuple, Object>> maps = VersionedMapStoreImpl
-                                .createSharedVersionedMapStores(symbolGroup.size(), hashProvider, defaultValue);
-
-                for (int i = 0; i < symbolGroup.size(); i++) {
-                        result.put(symbolGroup.get(i), maps.get(i));
-                }
-        }
-
-        private static <K, V> void addOrCreate(Map<K, List<V>> map, K key, V value) {
-                List<V> list;
-                if (map.containsKey(key)) {
-                        list = map.get(key);
-                } else {
-                        list = new LinkedList<>();
-                        map.put(key, list);
-                }
-                list.add(value);
-        }
-
-        @Override
-        public Set<AnyDataRepresentation> getDataRepresentations() {
-                return this.stores.keySet();
-        }
-
-        @Override
-        public ModelImpl createModel() {
-                Map<AnyDataRepresentation, VersionedMap<?, ?>> maps = new HashMap<>();
-                for (var entry : this.stores.entrySet()) {
-                        maps.put(entry.getKey(), entry.getValue().createMap());
-                }
-                return new ModelImpl(this, maps);
-        }
-
-        @Override
-        public synchronized ModelImpl createModel(long state) {
-                Map<AnyDataRepresentation, VersionedMap<?, ?>> maps = new HashMap<>();
-                for (var entry : this.stores.entrySet()) {
-                        maps.put(entry.getKey(), entry.getValue().createMap(state));
-                }
-                return new ModelImpl(this, maps);
-        }
-
-        @Override
-        public synchronized Set<Long> getStates() {
-                var iterator = stores.values().iterator();
-                if (iterator.hasNext()) {
-                        return Set.copyOf(iterator.next().getStates());
-                }
-                return Set.of(0l);
-        }
-
-        @Override
-        public synchronized ModelDiffCursor getDiffCursor(long from, long to) {
-                Map<AnyDataRepresentation, DiffCursor<?, ?>> diffcursors = new HashMap<>();
-                for (var entry : stores.entrySet()) {
-                        var representation = entry.getKey();
-                        var diffCursor = entry.getValue().getDiffCursor(from, to);
-                        diffcursors.put(representation, diffCursor);
-                }
-                return new ModelDiffCursor(diffcursors);
-        }
-}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/RelationLike.java b/subprojects/store/src/main/java/tools/refinery/store/model/RelationLike.java
deleted file mode 100644
index 6a5fdcd5..00000000
--- a/subprojects/store/src/main/java/tools/refinery/store/model/RelationLike.java
+++ /dev/null
@@ -1,7 +0,0 @@
-package tools.refinery.store.model;
-
-public interface RelationLike {
-        String getName();
-
-        int getArity();
-}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/TupleHashProvider.java b/subprojects/store/src/main/java/tools/refinery/store/model/TupleHashProvider.java
index 24ec3b59..4bcf9ff4 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/model/TupleHashProvider.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/model/TupleHashProvider.java
@@ -4,15 +4,6 @@ import tools.refinery.store.map.ContinousHashProvider;
 import tools.refinery.store.tuple.Tuple;
 
 public class TupleHashProvider implements ContinousHashProvider<Tuple> {
-        protected static TupleHashProvider instance;
-
-        public static TupleHashProvider singleton() {
-                if (instance == null) {
-                        instance = new TupleHashProvider();
-                }
-                return instance;
-        }
-
         protected static final int[] primes = new int[] { 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101,
                         103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211,
                         223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337,
@@ -45,6 +36,8 @@ public class TupleHashProvider implements ContinousHashProvider<Tuple> {
 
         public static final int MAX_MODEL_SIZE = (int) LARGEST_PRIME_30_BITS;
 
+        public static final TupleHashProvider INSTANCE = new TupleHashProvider();
+
         public TupleHashProvider() {
                 if (primes.length < MAX_PRACTICAL_DEPTH) {
                         throw new UnsupportedOperationException(
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/internal/ModelAction.java b/subprojects/store/src/main/java/tools/refinery/store/model/internal/ModelAction.java
new file mode 100644
index 00000000..f68859db
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/model/internal/ModelAction.java
@@ -0,0 +1,7 @@
+package tools.refinery.store.model.internal;
+
+public enum ModelAction {
+        NONE,
+        COMMIT,
+        RESTORE
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/internal/ModelImpl.java b/subprojects/store/src/main/java/tools/refinery/store/model/internal/ModelImpl.java
index 795a891b..10331e28 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/model/internal/ModelImpl.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/model/internal/ModelImpl.java
@@ -1,131 +1,166 @@
 package tools.refinery.store.model.internal;
 
-import tools.refinery.store.map.ContinousHashProvider;
-import tools.refinery.store.map.Cursor;
+import tools.refinery.store.adapter.AdapterList;
+import tools.refinery.store.adapter.AnyModelAdapterType;
+import tools.refinery.store.adapter.ModelAdapter;
+import tools.refinery.store.adapter.ModelAdapterType;
 import tools.refinery.store.map.DiffCursor;
-import tools.refinery.store.map.VersionedMap;
-import tools.refinery.store.map.internal.MapDiffCursor;
-import tools.refinery.store.model.Model;
-import tools.refinery.store.model.ModelDiffCursor;
-import tools.refinery.store.model.ModelStore;
-import tools.refinery.store.model.representation.AnyDataRepresentation;
-import tools.refinery.store.model.representation.DataRepresentation;
-
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Set;
+import tools.refinery.store.model.*;
+import tools.refinery.store.representation.AnySymbol;
+import tools.refinery.store.representation.Symbol;
+import tools.refinery.store.tuple.Tuple;
+
+import java.util.*;
 
 public class ModelImpl implements Model {
         private final ModelStore store;
-
-        private final Map<AnyDataRepresentation, VersionedMap<?, ?>> maps;
-
-        public ModelImpl(ModelStore store, Map<AnyDataRepresentation, VersionedMap<?, ?>> maps) {
+        private long state;
+        private Map<? extends AnySymbol, ? extends VersionedInterpretation<?>> interpretations;
+        private final AdapterList<ModelAdapter> adapters;
+        private final List<ModelListener> listeners = new ArrayList<>();
+        private ModelAction pendingAction = ModelAction.NONE;
+        private long restoringToState = -1;
+
+        ModelImpl(ModelStore store, long state, int adapterCount) {
                 this.store = store;
-                this.maps = maps;
+                this.state = state;
+                adapters = new AdapterList<>(adapterCount);
         }
 
-        @Override
-        public Set<AnyDataRepresentation> getDataRepresentations() {
-                return maps.keySet();
+        void setInterpretations(Map<? extends AnySymbol, ? extends VersionedInterpretation<?>> interpretations) {
+                this.interpretations = interpretations;
         }
 
-        private VersionedMap<?, ?> getMap(AnyDataRepresentation representation) {
-                if (maps.containsKey(representation)) {
-                        return maps.get(representation);
-                } else {
-                        throw new IllegalArgumentException("Model does have representation " + representation);
-                }
+        @Override
+        public ModelStore getStore() {
+                return store;
         }
 
-        @SuppressWarnings("unchecked")
-        private <K, V> VersionedMap<K, V> getMap(DataRepresentation<K, V> representation) {
-                return (VersionedMap<K, V>) maps.get(representation);
+        @Override
+        public long getState() {
+                return state;
         }
 
-        private <K, V> VersionedMap<K, V> getMapValidateKey(DataRepresentation<K, V> representation, K key) {
-                if (representation.isValidKey(key)) {
-                        return getMap(representation);
-                } else {
-                        throw new IllegalArgumentException(
-                                        "Key is not valid for representation! (representation=" + representation + ", key=" + key + ");");
+        @Override
+        public <T> Interpretation<T> getInterpretation(Symbol<T> symbol) {
+                var interpretation = interpretations.get(symbol);
+                if (interpretation == null) {
+                        throw new IllegalArgumentException("No interpretation for symbol %s in model".formatted(symbol));
                 }
+                @SuppressWarnings("unchecked")
+                var typedInterpretation = (Interpretation<T>) interpretation;
+                return typedInterpretation;
         }
 
         @Override
-        public <K, V> V get(DataRepresentation<K, V> representation, K key) {
-                return getMapValidateKey(representation, key).get(key);
+        public ModelDiffCursor getDiffCursor(long to) {
+                var diffCursors = new HashMap<AnySymbol, DiffCursor<Tuple, ?>>(interpretations.size());
+                for (var entry : interpretations.entrySet()) {
+                        diffCursors.put(entry.getKey(), entry.getValue().getDiffCursor(to));
+                }
+                return new ModelDiffCursor(diffCursors);
         }
 
         @Override
-        public <K, V> Cursor<K, V> getAll(DataRepresentation<K, V> representation) {
-                return getMap(representation).getAll();
+        public long commit() {
+                if (pendingAction != ModelAction.NONE) {
+                        throw pendingActionError("commit");
+                }
+                pendingAction = ModelAction.COMMIT;
+                try {
+                        int listenerCount = listeners.size();
+                        int i = listenerCount;
+                        long version = 0;
+                        while (i > 0) {
+                                i--;
+                                listeners.get(i).beforeCommit();
+                        }
+                        boolean versionSet = false;
+                        for (var interpretation : interpretations.values()) {
+                                long newVersion = interpretation.commit();
+                                if (versionSet) {
+                                        if (version != newVersion) {
+                                                throw new IllegalStateException("Interpretations in model have different versions (%d and %d)"
+                                                                .formatted(version, newVersion));
+                                        }
+                                } else {
+                                        version = newVersion;
+                                        versionSet = true;
+                                }
+                        }
+                        state = version;
+                        while (i < listenerCount) {
+                                listeners.get(i).afterCommit();
+                                i++;
+                        }
+                        return version;
+                } finally {
+                        pendingAction = ModelAction.NONE;
+                }
         }
 
         @Override
-        public <K, V> V put(DataRepresentation<K, V> representation, K key, V value) {
-                return getMapValidateKey(representation, key).put(key, value);
+        public void restore(long version) {
+                if (pendingAction != ModelAction.NONE) {
+                        throw pendingActionError("restore to %d".formatted(version));
+                }
+                if (!store.getStates().contains(version)) {
+                        throw new IllegalArgumentException("Store does not contain state %d".formatted(version));
+                }
+                pendingAction = ModelAction.RESTORE;
+                restoringToState = version;
+                try {
+                        int listenerCount = listeners.size();
+                        int i = listenerCount;
+                        while (i > 0) {
+                                i--;
+                                listeners.get(i).beforeRestore(version);
+                        }
+                        for (var interpretation : interpretations.values()) {
+                                interpretation.restore(version);
+                        }
+                        state = version;
+                        while (i < listenerCount) {
+                                listeners.get(i).afterRestore();
+                                i++;
+                        }
+                } finally {
+                        pendingAction = ModelAction.NONE;
+                        restoringToState = -1;
+                }
         }
 
-        @Override
-        public <K, V> void putAll(DataRepresentation<K, V> representation, Cursor<K, V> cursor) {
-                getMap(representation).putAll(cursor);
+        public RuntimeException pendingActionError(String currentActionName) {
+                var pendingActionName = switch (pendingAction) {
+                        case NONE -> throw new IllegalArgumentException("Trying to throw pending action error when there is no " +
+                                        "pending action");
+                        case COMMIT -> "commit";
+                        case RESTORE -> "restore to %d".formatted(restoringToState);
+                };
+                return new IllegalStateException("Cannot %s due to pending %s".formatted(currentActionName, pendingActionName));
         }
 
         @Override
-        public long getSize(AnyDataRepresentation representation) {
-                return getMap(representation).getSize();
+        public <T extends ModelAdapter> Optional<T> tryGetAdapter(ModelAdapterType<? extends T, ?, ?> adapterType) {
+                return adapters.tryGet(adapterType, adapterType.getModelAdapterClass());
         }
 
         @Override
-        public ModelDiffCursor getDiffCursor(long to) {
-                Model toModel = store.createModel(to);
-                Map<AnyDataRepresentation, DiffCursor<?, ?>> diffCursors = new HashMap<>();
-                for (AnyDataRepresentation anyDataRepresentation : this.maps.keySet()) {
-                        var dataRepresentation = (DataRepresentation<?, ?>) anyDataRepresentation;
-                        MapDiffCursor<?, ?> diffCursor = constructDiffCursor(toModel, dataRepresentation);
-                        diffCursors.put(dataRepresentation, diffCursor);
-                }
-                return new ModelDiffCursor(diffCursors);
+        public <T extends ModelAdapter> T getAdapter(ModelAdapterType<T, ?, ?> adapterType) {
+                return adapters.get(adapterType, adapterType.getModelAdapterClass());
         }
 
-        private <K, V> MapDiffCursor<K, V> constructDiffCursor(Model toModel, DataRepresentation<K, V> representation) {
-                @SuppressWarnings("unchecked")
-                Cursor<K, V> fromCursor = (Cursor<K, V>) this.maps.get(representation).getAll();
-                Cursor<K, V> toCursor = toModel.getAll(representation);
-
-                ContinousHashProvider<K> hashProvider = representation.getHashProvider();
-                V defaultValue = representation.getDefaultValue();
-                return new MapDiffCursor<>(hashProvider, defaultValue, fromCursor, toCursor);
+        void addAdapter(AnyModelAdapterType adapterType, ModelAdapter adapter) {
+                adapters.add(adapterType, adapter);
         }
 
         @Override
-        public long commit() {
-                long version = 0;
-                boolean versionSet = false;
-                for (VersionedMap<?, ?> map : maps.values()) {
-                        long newVersion = map.commit();
-                        if (versionSet) {
-                                if (version != newVersion) {
-                                        throw new IllegalStateException(
-                                                        "Maps in model have different versions! (" + version + " and" + newVersion + ")");
-                                }
-                        } else {
-                                version = newVersion;
-                                versionSet = true;
-                        }
-                }
-                return version;
+        public void addListener(ModelListener listener) {
+                listeners.add(listener);
         }
 
         @Override
-        public void restore(long state) {
-                if (store.getStates().contains(state)) {
-                        for (VersionedMap<?, ?> map : maps.values()) {
-                                map.restore(state);
-                        }
-                } else {
-                        throw new IllegalArgumentException("Map does not contain state " + state + "!");
-                }
+        public void removeListener(ModelListener listener) {
+                listeners.remove(listener);
         }
 }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/internal/ModelStoreBuilderImpl.java b/subprojects/store/src/main/java/tools/refinery/store/model/internal/ModelStoreBuilderImpl.java
new file mode 100644
index 00000000..79f7195d
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/model/internal/ModelStoreBuilderImpl.java
@@ -0,0 +1,104 @@
+package tools.refinery.store.model.internal;
+
+import tools.refinery.store.adapter.AdapterList;
+import tools.refinery.store.adapter.ModelAdapterBuilder;
+import tools.refinery.store.adapter.ModelAdapterBuilderFactory;
+import tools.refinery.store.adapter.ModelAdapterType;
+import tools.refinery.store.map.VersionedMapStore;
+import tools.refinery.store.map.VersionedMapStoreImpl;
+import tools.refinery.store.model.ModelStore;
+import tools.refinery.store.model.ModelStoreBuilder;
+import tools.refinery.store.model.TupleHashProvider;
+import tools.refinery.store.representation.AnySymbol;
+import tools.refinery.store.representation.Symbol;
+import tools.refinery.store.tuple.Tuple;
+
+import java.util.*;
+
+public class ModelStoreBuilderImpl implements ModelStoreBuilder {
+        private final Set<AnySymbol> allSymbols = new HashSet<>();
+        private final Map<SymbolEquivalenceClass<?>, List<AnySymbol>> equivalenceClasses = new HashMap<>();
+        private final AdapterList<ModelAdapterBuilder> adapters = new AdapterList<>();
+
+        @Override
+        public <T> ModelStoreBuilder symbol(Symbol<T> symbol) {
+                if (!allSymbols.add(symbol)) {
+                        throw new IllegalArgumentException("Symbol %s already added".formatted(symbol));
+                }
+                var equivalenceClass = new SymbolEquivalenceClass<>(symbol);
+                var symbolsInEquivalenceClass = equivalenceClasses.computeIfAbsent(equivalenceClass,
+                                ignored -> new ArrayList<>());
+                symbolsInEquivalenceClass.add(symbol);
+                return this;
+        }
+
+        @Override
+        public <T extends ModelAdapterBuilder> T with(ModelAdapterBuilderFactory<?, ?, T> adapterBuilderFactory) {
+                return adapters.<T>tryGet(adapterBuilderFactory, adapterBuilderFactory.getModelAdapterBuilderClass())
+                                .orElseGet(() -> addAdapter(adapterBuilderFactory));
+        }
+
+        private <T extends ModelAdapterBuilder> T addAdapter(ModelAdapterBuilderFactory<?, ?, T> adapterBuilderFactory) {
+                for (var configuredAdapterType : adapters.getAdapterTypes()) {
+                        var intersection = new HashSet<>(adapterBuilderFactory.getSupportedAdapterTypes());
+                        intersection.retainAll(configuredAdapterType.getSupportedAdapterTypes());
+                        if (!intersection.isEmpty()) {
+                                if (configuredAdapterType.supports(adapterBuilderFactory)) {
+                                        // Impossible to end up here from <code>#with</code>, because we should have returned
+                                        // the existing adapter there instead of adding a new one.
+                                        throw new IllegalArgumentException(
+                                                        "Cannot add %s, because it is already provided by configured adapter %s"
+                                                                        .formatted(adapterBuilderFactory, configuredAdapterType));
+                                } else if (adapterBuilderFactory.supports(configuredAdapterType)) {
+                                        throw new IllegalArgumentException(
+                                                        "Cannot add %s, because it provides already configured adapter %s"
+                                                                        .formatted(adapterBuilderFactory, configuredAdapterType));
+                                } else {
+                                        throw new IllegalArgumentException(
+                                                        "Cannot add %s, because configured adapter %s already provides %s"
+                                                                        .formatted(adapterBuilderFactory, configuredAdapterType, intersection));
+                                }
+                        }
+                }
+                var newAdapter = adapterBuilderFactory.createBuilder(this);
+                adapters.add(adapterBuilderFactory, newAdapter);
+                return newAdapter;
+        }
+
+        @Override
+        public <T extends ModelAdapterBuilder> Optional<T> tryGetAdapter(ModelAdapterType<?, ?, ? extends T> adapterType) {
+                return adapters.tryGet(adapterType, adapterType.getModelAdapterBuilderClass());
+        }
+
+        @Override
+        public <T extends ModelAdapterBuilder> T getAdapter(ModelAdapterType<?, ?, T> adapterType) {
+                return adapters.get(adapterType, adapterType.getModelAdapterBuilderClass());
+        }
+
+        @Override
+        public ModelStore build() {
+                var stores = new HashMap<AnySymbol, VersionedMapStore<Tuple, ?>>(allSymbols.size());
+                for (var entry : equivalenceClasses.entrySet()) {
+                        createStores(stores, entry.getKey(), entry.getValue());
+                }
+                var modelStore = new ModelStoreImpl(stores, adapters.size());
+                for (int i = adapters.size() - 1; i >= 0; i--) {
+                        adapters.get(i).configure();
+                }
+                for (var entry : adapters.withAdapterTypes()) {
+                        var adapter = entry.adapter().createStoreAdapter(modelStore);
+                        modelStore.addAdapter(entry.adapterType(), adapter);
+                }
+                return modelStore;
+        }
+
+        private <T> void createStores(Map<AnySymbol, VersionedMapStore<Tuple, ?>> stores,
+                                                                  SymbolEquivalenceClass<T> equivalenceClass, List<AnySymbol> symbols) {
+                int size = symbols.size();
+                var storeGroup = VersionedMapStoreImpl.createSharedVersionedMapStores(size, TupleHashProvider.INSTANCE,
+                                equivalenceClass.defaultValue());
+                for (int i = 0; i < size; i++) {
+                        stores.put(symbols.get(i), storeGroup.get(i));
+                }
+        }
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/internal/ModelStoreImpl.java b/subprojects/store/src/main/java/tools/refinery/store/model/internal/ModelStoreImpl.java
new file mode 100644
index 00000000..8aab57af
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/model/internal/ModelStoreImpl.java
@@ -0,0 +1,100 @@
+package tools.refinery.store.model.internal;
+
+import tools.refinery.store.adapter.AdapterList;
+import tools.refinery.store.adapter.AnyModelAdapterType;
+import tools.refinery.store.adapter.ModelAdapterType;
+import tools.refinery.store.adapter.ModelStoreAdapter;
+import tools.refinery.store.map.DiffCursor;
+import tools.refinery.store.map.VersionedMapStore;
+import tools.refinery.store.model.ModelDiffCursor;
+import tools.refinery.store.model.ModelStore;
+import tools.refinery.store.representation.AnySymbol;
+import tools.refinery.store.tuple.Tuple;
+
+import java.util.*;
+
+public class ModelStoreImpl implements ModelStore {
+        private final Map<? extends AnySymbol, ? extends VersionedMapStore<Tuple, ?>> stores;
+        private final AdapterList<ModelStoreAdapter> adapters;
+
+        ModelStoreImpl(Map<? extends AnySymbol, ? extends VersionedMapStore<Tuple, ?>> stores, int adapterCount) {
+                this.stores = stores;
+                adapters = new AdapterList<>(adapterCount);
+        }
+
+        @Override
+        public Collection<AnySymbol> getSymbols() {
+                return Collections.unmodifiableCollection(stores.keySet());
+        }
+
+        private ModelImpl createEmptyModel(long state) {
+                return new ModelImpl(this, state, adapters.size());
+        }
+
+        @Override
+        public ModelImpl createModel() {
+                var model = createEmptyModel(-1);
+                var interpretations = new HashMap<AnySymbol, VersionedInterpretation<?>>(stores.size());
+                for (var entry : this.stores.entrySet()) {
+                        var symbol = entry.getKey();
+                        interpretations.put(symbol, VersionedInterpretation.of(model, symbol, entry.getValue()));
+                }
+                model.setInterpretations(interpretations);
+                adaptModel(model);
+                return model;
+        }
+
+        @Override
+        public synchronized ModelImpl createModel(long state) {
+                var model = createEmptyModel(state);
+                var interpretations = new HashMap<AnySymbol, VersionedInterpretation<?>>(stores.size());
+                for (var entry : this.stores.entrySet()) {
+                        var symbol = entry.getKey();
+                        interpretations.put(symbol, VersionedInterpretation.of(model, symbol, entry.getValue(), state));
+                }
+                model.setInterpretations(interpretations);
+                adaptModel(model);
+                return model;
+        }
+
+        private void adaptModel(ModelImpl model) {
+                for (var entry : adapters.withAdapterTypes()) {
+                        var adapter = entry.adapter().createModelAdapter(model);
+                        model.addAdapter(entry.adapterType(), adapter);
+                }
+        }
+
+        @Override
+        public synchronized Set<Long> getStates() {
+                var iterator = stores.values().iterator();
+                if (iterator.hasNext()) {
+                        return Set.copyOf(iterator.next().getStates());
+                }
+                return Set.of(0L);
+        }
+
+        @Override
+        public synchronized ModelDiffCursor getDiffCursor(long from, long to) {
+                var diffCursors = new HashMap<AnySymbol, DiffCursor<?, ?>>();
+                for (var entry : stores.entrySet()) {
+                        var representation = entry.getKey();
+                        var diffCursor = entry.getValue().getDiffCursor(from, to);
+                        diffCursors.put(representation, diffCursor);
+                }
+                return new ModelDiffCursor(diffCursors);
+        }
+
+        @Override
+        public <T extends ModelStoreAdapter> Optional<T> tryGetAdapter(ModelAdapterType<?, ? extends T, ?> adapterType) {
+                return adapters.tryGet(adapterType, adapterType.getModelStoreAdapterClass());
+        }
+
+        @Override
+        public <T extends ModelStoreAdapter> T getAdapter(ModelAdapterType<?, T, ?> adapterType) {
+                return adapters.get(adapterType, adapterType.getModelStoreAdapterClass());
+        }
+
+        void addAdapter(AnyModelAdapterType adapterType, ModelStoreAdapter adapter) {
+                adapters.add(adapterType, adapter);
+        }
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/internal/SimilarRelationEquivalenceClass.java b/subprojects/store/src/main/java/tools/refinery/store/model/internal/SimilarRelationEquivalenceClass.java
deleted file mode 100644
index 79e4c9f9..00000000
--- a/subprojects/store/src/main/java/tools/refinery/store/model/internal/SimilarRelationEquivalenceClass.java
+++ /dev/null
@@ -1,35 +0,0 @@
-package tools.refinery.store.model.internal;
-
-import tools.refinery.store.map.ContinousHashProvider;
-import tools.refinery.store.model.representation.Relation;
-import tools.refinery.store.tuple.Tuple;
-
-import java.util.Objects;
-
-public class SimilarRelationEquivalenceClass {
-        final ContinousHashProvider<Tuple> hashProvider;
-        final Object defaultValue;
-        final int arity;
-
-        public SimilarRelationEquivalenceClass(Relation<?> representation) {
-                this.hashProvider = representation.getHashProvider();
-                this.defaultValue = representation.getDefaultValue();
-                this.arity = representation.getArity();
-        }
-
-        @Override
-        public int hashCode() {
-                return Objects.hash(arity, defaultValue, hashProvider);
-        }
-
-        @Override
-        public boolean equals(Object obj) {
-                if (this == obj)
-                        return true;
-                if (!(obj instanceof SimilarRelationEquivalenceClass other))
-                        return false;
-                return arity == other.arity && Objects.equals(defaultValue, other.defaultValue)
-                                && Objects.equals(hashProvider, other.hashProvider);
-        }
-
-}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/internal/SymbolEquivalenceClass.java b/subprojects/store/src/main/java/tools/refinery/store/model/internal/SymbolEquivalenceClass.java
new file mode 100644
index 00000000..5bf1b90d
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/model/internal/SymbolEquivalenceClass.java
@@ -0,0 +1,9 @@
+package tools.refinery.store.model.internal;
+
+import tools.refinery.store.representation.Symbol;
+
+public record SymbolEquivalenceClass<T>(int arity, Class<T> valueType, T defaultValue) {
+        public SymbolEquivalenceClass(Symbol<T> symbol) {
+                this(symbol.arity(), symbol.valueType(), symbol.defaultValue());
+        }
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/internal/VersionedInterpretation.java b/subprojects/store/src/main/java/tools/refinery/store/model/internal/VersionedInterpretation.java
new file mode 100644
index 00000000..1bdb1cdf
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/model/internal/VersionedInterpretation.java
@@ -0,0 +1,159 @@
+package tools.refinery.store.model.internal;
+
+import tools.refinery.store.map.Cursor;
+import tools.refinery.store.map.DiffCursor;
+import tools.refinery.store.map.VersionedMap;
+import tools.refinery.store.map.VersionedMapStore;
+import tools.refinery.store.map.internal.MapDiffCursor;
+import tools.refinery.store.model.Interpretation;
+import tools.refinery.store.model.InterpretationListener;
+import tools.refinery.store.model.Model;
+import tools.refinery.store.model.TupleHashProvider;
+import tools.refinery.store.representation.AnySymbol;
+import tools.refinery.store.representation.Symbol;
+import tools.refinery.store.tuple.Tuple;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class VersionedInterpretation<T> implements Interpretation<T> {
+        private final ModelImpl model;
+        private final Symbol<T> symbol;
+        private final VersionedMapStore<Tuple, T> store;
+        private final VersionedMap<Tuple, T> map;
+        private final List<InterpretationListener<T>> listeners = new ArrayList<>();
+        private final List<InterpretationListener<T>> restoreListeners = new ArrayList<>();
+
+        private VersionedInterpretation(ModelImpl model, Symbol<T> symbol, VersionedMapStore<Tuple, T> store,
+                                                                        VersionedMap<Tuple, T> map) {
+                this.model = model;
+                this.symbol = symbol;
+                this.store = store;
+                this.map = map;
+        }
+
+        @Override
+        public Model getModel() {
+                return model;
+        }
+
+        @Override
+        public Symbol<T> getSymbol() {
+                return symbol;
+        }
+
+        @Override
+        public long getSize() {
+                return map.getSize();
+        }
+
+        private void checkKey(Tuple key) {
+                if (key == null || key.getSize() != symbol.arity()) {
+                        throw new IllegalArgumentException("Key for %s must be a tuple with arity %s"
+                                        .formatted(symbol, symbol.arity()));
+                }
+        }
+        @Override
+        public T get(Tuple key) {
+                checkKey(key);
+                return map.get(key);
+        }
+
+        @Override
+        public Cursor<Tuple, T> getAll() {
+                return map.getAll();
+        }
+
+        private void notifyListeners(Tuple key, T fromValue, T toValue, boolean restoring) {
+                var listenerList = restoring ? restoreListeners : listeners;
+                int listenerCount = listenerList.size();
+                // Use a for loop instead of a for-each loop to avoid <code>Iterator</code> allocation overhead.
+                //noinspection ForLoopReplaceableByForEach
+                for (int i = 0; i < listenerCount; i++) {
+                        listenerList.get(i).put(key, fromValue, toValue, restoring);
+                }
+        }
+
+        @Override
+        public T put(Tuple key, T value) {
+                checkKey(key);
+                var oldValue = map.put(key, value);
+                notifyListeners(key, oldValue, value, false);
+                return oldValue;
+        }
+
+        @Override
+        public void putAll(Cursor<Tuple, T> cursor) {
+                if (listeners.isEmpty()) {
+                        map.putAll(cursor);
+                        return;
+                }
+                if (cursor.getDependingMaps().contains(map)) {
+                        List<Tuple> keys = new ArrayList<>();
+                        List<T> values = new ArrayList<>();
+                        while (cursor.move()) {
+                                keys.add(cursor.getKey());
+                                values.add(cursor.getValue());
+                        }
+                        var keyIterator = keys.iterator();
+                        var valueIterator = values.iterator();
+                        while (keyIterator.hasNext()) {
+                                put(keyIterator.next(), valueIterator.next());
+                        }
+                } else {
+                        while (cursor.move()) {
+                                put(cursor.getKey(), cursor.getValue());
+                        }
+                }
+        }
+
+        @Override
+        public DiffCursor<Tuple, T> getDiffCursor(long to) {
+                var fromCursor = getAll();
+                var toCursor = store.createMap(to).getAll();
+                return new MapDiffCursor<>(TupleHashProvider.INSTANCE, symbol.defaultValue(), fromCursor, toCursor);
+        }
+
+        public long commit() {
+                return map.commit();
+        }
+
+        public void restore(long state) {
+                if (!restoreListeners.isEmpty()) {
+                        var diffCursor = getDiffCursor(state);
+                        while (diffCursor.move()) {
+                                notifyListeners(diffCursor.getKey(), diffCursor.getFromValue(), diffCursor.getToValue(), true);
+                        }
+                }
+                map.restore(state);
+        }
+
+        @Override
+        public void addListener(InterpretationListener<T> listener, boolean alsoWhenRestoring) {
+                listeners.add(listener);
+                if (alsoWhenRestoring) {
+                        restoreListeners.add(listener);
+                }
+        }
+
+        @Override
+        public void removeListener(InterpretationListener<T> listener) {
+                listeners.remove(listener);
+                restoreListeners.remove(listener);
+        }
+
+        static <T> VersionedInterpretation<T> of(ModelImpl model, AnySymbol symbol, VersionedMapStore<Tuple, T> store) {
+                @SuppressWarnings("unchecked")
+                var typedSymbol = (Symbol<T>) symbol;
+                var map = store.createMap();
+                return new VersionedInterpretation<>(model, typedSymbol, store, map);
+        }
+
+        static <T> VersionedInterpretation<T> of(ModelImpl model, AnySymbol symbol, VersionedMapStore<Tuple, T> store,
+                                                                                         long state) {
+                @SuppressWarnings("unchecked")
+                var typedSymbol = (Symbol<T>) symbol;
+                var map = store.createMap(state);
+                return new VersionedInterpretation<>(model, typedSymbol, store, map);
+        }
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/representation/AnyAuxiliaryData.java b/subprojects/store/src/main/java/tools/refinery/store/model/representation/AnyAuxiliaryData.java
deleted file mode 100644
index 951952e5..00000000
--- a/subprojects/store/src/main/java/tools/refinery/store/model/representation/AnyAuxiliaryData.java
+++ /dev/null
@@ -1,4 +0,0 @@
-package tools.refinery.store.model.representation;
-
-public sealed interface AnyAuxiliaryData extends AnyDataRepresentation permits AuxiliaryData {
-}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/representation/AnyDataRepresentation.java b/subprojects/store/src/main/java/tools/refinery/store/model/representation/AnyDataRepresentation.java
deleted file mode 100644
index ea74a625..00000000
--- a/subprojects/store/src/main/java/tools/refinery/store/model/representation/AnyDataRepresentation.java
+++ /dev/null
@@ -1,9 +0,0 @@
-package tools.refinery.store.model.representation;
-
-public sealed interface AnyDataRepresentation permits DataRepresentation, AnyRelation, AnyAuxiliaryData {
-        String getName();
-
-        Class<?> getKeyType();
-
-        Class<?> getValueType();
-}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/representation/AnyRelation.java b/subprojects/store/src/main/java/tools/refinery/store/model/representation/AnyRelation.java
deleted file mode 100644
index 1d698c28..00000000
--- a/subprojects/store/src/main/java/tools/refinery/store/model/representation/AnyRelation.java
+++ /dev/null
@@ -1,9 +0,0 @@
-package tools.refinery.store.model.representation;
-
-import tools.refinery.store.model.RelationLike;
-import tools.refinery.store.tuple.Tuple;
-
-public sealed interface AnyRelation extends AnyDataRepresentation, RelationLike permits Relation {
-        @Override
-        Class<Tuple> getKeyType();
-}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/representation/AuxiliaryData.java b/subprojects/store/src/main/java/tools/refinery/store/model/representation/AuxiliaryData.java
deleted file mode 100644
index dad1ccf4..00000000
--- a/subprojects/store/src/main/java/tools/refinery/store/model/representation/AuxiliaryData.java
+++ /dev/null
@@ -1,23 +0,0 @@
-package tools.refinery.store.model.representation;
-
-import tools.refinery.store.map.ContinousHashProvider;
-
-public final class AuxiliaryData<K, V> extends DataRepresentation<K, V> implements AnyAuxiliaryData {
-        private final ContinousHashProvider<K> hashProvider;
-
-        public AuxiliaryData(String name, Class<K> keyType, ContinousHashProvider<K> hashProvider, Class<V> valueType,
-                                                 V defaultValue) {
-                super(name, keyType, valueType, defaultValue);
-                this.hashProvider = hashProvider;
-        }
-
-        @Override
-        public ContinousHashProvider<K> getHashProvider() {
-                return hashProvider;
-        }
-
-        @Override
-        public boolean isValidKey(K key) {
-                return true;
-        }
-}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/representation/DataRepresentation.java b/subprojects/store/src/main/java/tools/refinery/store/model/representation/DataRepresentation.java
deleted file mode 100644
index 2bf498b9..00000000
--- a/subprojects/store/src/main/java/tools/refinery/store/model/representation/DataRepresentation.java
+++ /dev/null
@@ -1,43 +0,0 @@
-package tools.refinery.store.model.representation;
-
-import tools.refinery.store.map.ContinousHashProvider;
-
-public abstract sealed class DataRepresentation<K, V> implements AnyDataRepresentation permits Relation, AuxiliaryData {
-        private final String name;
-
-        private final V defaultValue;
-
-        private final Class<K> keyType;
-
-        private final Class<V> valueType;
-
-        protected DataRepresentation(String name, Class<K> keyType, Class<V> valueType, V defaultValue) {
-                this.name = name;
-                this.defaultValue = defaultValue;
-                this.keyType = keyType;
-                this.valueType = valueType;
-        }
-
-        @Override
-        public String getName() {
-                return name;
-        }
-
-        public abstract ContinousHashProvider<K> getHashProvider();
-
-        public abstract boolean isValidKey(K key);
-
-        public V getDefaultValue() {
-                return defaultValue;
-        }
-
-        @Override
-        public Class<K> getKeyType() {
-                return keyType;
-        }
-
-        @Override
-        public Class<V> getValueType() {
-                return valueType;
-        }
-}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/representation/Relation.java b/subprojects/store/src/main/java/tools/refinery/store/model/representation/Relation.java
deleted file mode 100644
index 47a07536..00000000
--- a/subprojects/store/src/main/java/tools/refinery/store/model/representation/Relation.java
+++ /dev/null
@@ -1,33 +0,0 @@
-package tools.refinery.store.model.representation;
-
-import tools.refinery.store.map.ContinousHashProvider;
-import tools.refinery.store.model.TupleHashProvider;
-import tools.refinery.store.tuple.Tuple;
-
-public final class Relation<D> extends DataRepresentation<Tuple, D> implements AnyRelation {
-        private final int arity;
-
-        public Relation(String name, int arity, Class<D> valueType, D defaultValue) {
-                super(name, Tuple.class, valueType, defaultValue);
-                this.arity = arity;
-        }
-
-        @Override
-        public int getArity() {
-                return arity;
-        }
-
-        @Override
-        public ContinousHashProvider<Tuple> getHashProvider() {
-                return TupleHashProvider.singleton();
-        }
-
-        @Override
-        public boolean isValidKey(Tuple key) {
-                if (key == null) {
-                        return false;
-                } else {
-                        return key.getSize() == getArity();
-                }
-        }
-}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/DNF.java b/subprojects/store/src/main/java/tools/refinery/store/query/DNF.java
index 7d4b3091..336c25a1 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/query/DNF.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/query/DNF.java
@@ -1,11 +1,11 @@
 package tools.refinery.store.query;
 
-import tools.refinery.store.model.RelationLike;
+import tools.refinery.store.representation.SymbolLike;
 import tools.refinery.store.query.atom.DNFAtom;
 
 import java.util.*;
 
-public class DNF implements RelationLike {
+public class DNF implements SymbolLike {
         private final String name;
 
         private final String uniqueName;
@@ -22,7 +22,7 @@ public class DNF implements RelationLike {
         }
 
         @Override
-        public String getName() {
+        public String name() {
                 return name;
         }
 
@@ -35,7 +35,7 @@ public class DNF implements RelationLike {
         }
 
         @Override
-        public int getArity() {
+        public int arity() {
                 return parameters.size();
         }
 
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/ModelQuery.java b/subprojects/store/src/main/java/tools/refinery/store/query/ModelQuery.java
new file mode 100644
index 00000000..6a1aeabb
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/query/ModelQuery.java
@@ -0,0 +1,11 @@
+package tools.refinery.store.query;
+
+import tools.refinery.store.adapter.ModelAdapterType;
+
+public final class ModelQuery extends ModelAdapterType<ModelQueryAdapter, ModelQueryStoreAdapter, ModelQueryBuilder> {
+        public static final ModelQuery ADAPTER = new ModelQuery();
+
+        private ModelQuery() {
+                super(ModelQueryAdapter.class, ModelQueryStoreAdapter.class, ModelQueryBuilder.class);
+        }
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/ModelQueryAdapter.java b/subprojects/store/src/main/java/tools/refinery/store/query/ModelQueryAdapter.java
new file mode 100644
index 00000000..d0cdf02d
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/query/ModelQueryAdapter.java
@@ -0,0 +1,11 @@
+package tools.refinery.store.query;
+
+import tools.refinery.store.adapter.ModelAdapter;
+
+public interface ModelQueryAdapter extends ModelAdapter {
+        ModelQueryStoreAdapter getStoreAdapter();
+
+        ResultSet getResultSet(DNF query);
+
+        void flushChanges();
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/ModelQueryBuilder.java b/subprojects/store/src/main/java/tools/refinery/store/query/ModelQueryBuilder.java
new file mode 100644
index 00000000..853a1796
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/query/ModelQueryBuilder.java
@@ -0,0 +1,23 @@
+package tools.refinery.store.query;
+
+import tools.refinery.store.adapter.ModelAdapterBuilder;
+import tools.refinery.store.model.ModelStore;
+
+import java.util.Collection;
+import java.util.List;
+
+public interface ModelQueryBuilder extends ModelAdapterBuilder {
+        default ModelQueryBuilder queries(DNF... queries) {
+                return queries(List.of(queries));
+        }
+
+        default ModelQueryBuilder queries(Collection<? extends DNF> queries) {
+                queries.forEach(this::query);
+                return this;
+        }
+
+        ModelQueryBuilder query(DNF query);
+
+        @Override
+        ModelQueryStoreAdapter createStoreAdapter(ModelStore store);
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/ModelQueryStoreAdapter.java b/subprojects/store/src/main/java/tools/refinery/store/query/ModelQueryStoreAdapter.java
new file mode 100644
index 00000000..ef5a4587
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/query/ModelQueryStoreAdapter.java
@@ -0,0 +1,16 @@
+package tools.refinery.store.query;
+
+import tools.refinery.store.adapter.ModelStoreAdapter;
+import tools.refinery.store.model.Model;
+import tools.refinery.store.query.view.AnyRelationView;
+
+import java.util.Collection;
+
+public interface ModelQueryStoreAdapter extends ModelStoreAdapter {
+        Collection<AnyRelationView> getRelationViews();
+
+        Collection<DNF> getQueries();
+
+        @Override
+        ModelQueryAdapter createModelAdapter(Model model);
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/QueryableModel.java b/subprojects/store/src/main/java/tools/refinery/store/query/QueryableModel.java
deleted file mode 100644
index 9655d1a1..00000000
--- a/subprojects/store/src/main/java/tools/refinery/store/query/QueryableModel.java
+++ /dev/null
@@ -1,33 +0,0 @@
-package tools.refinery.store.query;
-
-import tools.refinery.store.model.Model;
-import tools.refinery.store.tuple.Tuple;
-import tools.refinery.store.tuple.TupleLike;
-
-import java.util.Optional;
-import java.util.Set;
-import java.util.stream.Stream;
-
-public interface QueryableModel extends Model {
-        Set<DNF> getPredicates();
-
-        boolean hasChanges();
-
-        void flushChanges();
-
-        boolean hasResult(DNF predicate);
-
-        boolean hasResult(DNF predicate, Tuple parameters);
-
-        Optional<TupleLike> oneResult(DNF predicate);
-
-        Optional<TupleLike> oneResult(DNF predicate, Tuple parameters);
-
-        Stream<TupleLike> allResults(DNF predicate);
-
-        Stream<TupleLike> allResults(DNF predicate, Tuple parameters);
-
-        int countResults(DNF predicate);
-
-        int countResults(DNF predicate, Tuple parameters);
-}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/QueryableModelStore.java b/subprojects/store/src/main/java/tools/refinery/store/query/QueryableModelStore.java
deleted file mode 100644
index 3a69f3a4..00000000
--- a/subprojects/store/src/main/java/tools/refinery/store/query/QueryableModelStore.java
+++ /dev/null
@@ -1,19 +0,0 @@
-package tools.refinery.store.query;
-
-import tools.refinery.store.model.ModelStore;
-import tools.refinery.store.model.representation.AnyDataRepresentation;
-import tools.refinery.store.query.view.AnyRelationView;
-
-import java.util.Set;
-
-public interface QueryableModelStore extends ModelStore {
-    Set<AnyDataRepresentation> getDataRepresentations();
-
-        Set<AnyRelationView> getViews();
-
-        Set<DNF> getPredicates();
-
-        QueryableModel createModel();
-
-        QueryableModel createModel(long state);
-}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/ResultSet.java b/subprojects/store/src/main/java/tools/refinery/store/query/ResultSet.java
new file mode 100644
index 00000000..3542e252
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/query/ResultSet.java
@@ -0,0 +1,25 @@
+package tools.refinery.store.query;
+
+import tools.refinery.store.tuple.Tuple;
+import tools.refinery.store.tuple.TupleLike;
+
+import java.util.Optional;
+import java.util.stream.Stream;
+
+public interface ResultSet {
+        boolean hasResult();
+
+        boolean hasResult(Tuple parameters);
+
+        Optional<TupleLike> oneResult();
+
+        Optional<TupleLike> oneResult(Tuple parameters);
+
+        Stream<TupleLike> allResults();
+
+        Stream<TupleLike> allResults(Tuple parameters);
+
+        int countResults();
+
+        int countResults(Tuple parameters);
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/atom/AbstractSubstitutionAtom.java b/subprojects/store/src/main/java/tools/refinery/store/query/atom/AbstractSubstitutionAtom.java
index e8a8b5e1..af6a8f5a 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/query/atom/AbstractSubstitutionAtom.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/query/atom/AbstractSubstitutionAtom.java
@@ -1,20 +1,20 @@
 package tools.refinery.store.query.atom;
 
-import tools.refinery.store.model.RelationLike;
+import tools.refinery.store.representation.SymbolLike;
 import tools.refinery.store.query.Variable;
 
 import java.util.List;
 import java.util.Set;
 
-public abstract class AbstractSubstitutionAtom<T extends RelationLike> implements DNFAtom {
+public abstract class AbstractSubstitutionAtom<T extends SymbolLike> implements DNFAtom {
         private final T target;
 
         private final List<Variable> substitution;
 
         protected AbstractSubstitutionAtom(T target, List<Variable> substitution) {
-                if (substitution.size() != target.getArity()) {
-                        throw new IllegalArgumentException("%s needs %d arguments, but got %s".formatted(target.getName(),
-                                        target.getArity(), substitution.size()));
+                if (substitution.size() != target.arity()) {
+                        throw new IllegalArgumentException("%s needs %d arguments, but got %s".formatted(target.name(),
+                                        target.arity(), substitution.size()));
                 }
                 this.target = target;
                 this.substitution = substitution;
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/atom/CallAtom.java b/subprojects/store/src/main/java/tools/refinery/store/query/atom/CallAtom.java
index 9e289a8a..2e855246 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/query/atom/CallAtom.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/query/atom/CallAtom.java
@@ -1,40 +1,40 @@
 package tools.refinery.store.query.atom;
 
-import tools.refinery.store.model.RelationLike;
+import tools.refinery.store.representation.SymbolLike;
 import tools.refinery.store.query.Variable;
 
 import java.util.List;
 import java.util.Objects;
 import java.util.Set;
 
-public final class CallAtom<T extends RelationLike> extends AbstractSubstitutionAtom<T> {
+public abstract class CallAtom<T extends SymbolLike> extends AbstractSubstitutionAtom<T> {
         private final CallPolarity polarity;
 
-        public CallAtom(CallPolarity polarity, T target, List<Variable> substitution) {
+        protected CallAtom(CallPolarity polarity, T target, List<Variable> substitution) {
                 super(target, substitution);
-                if (polarity.isTransitive() && target.getArity() != 2) {
+                if (polarity.isTransitive() && target.arity() != 2) {
                         throw new IllegalArgumentException("Transitive closures can only take binary relations");
                 }
                 this.polarity = polarity;
         }
 
-        public CallAtom(CallPolarity polarity, T target, Variable... substitution) {
+        protected CallAtom(CallPolarity polarity, T target, Variable... substitution) {
                 this(polarity, target, List.of(substitution));
         }
 
-        public CallAtom(boolean positive, T target, List<Variable> substitution) {
+        protected CallAtom(boolean positive, T target, List<Variable> substitution) {
                 this(CallPolarity.fromBoolean(positive), target, substitution);
         }
 
-        public CallAtom(boolean positive, T target, Variable... substitution) {
+        protected CallAtom(boolean positive, T target, Variable... substitution) {
                 this(positive, target, List.of(substitution));
         }
 
-        public CallAtom(T target, List<Variable> substitution) {
+        protected CallAtom(T target, List<Variable> substitution) {
                 this(true, target, substitution);
         }
 
-        public CallAtom(T target, Variable... substitution) {
+        protected CallAtom(T target, Variable... substitution) {
                 this(target, List.of(substitution));
         }
 
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/atom/DNFCallAtom.java b/subprojects/store/src/main/java/tools/refinery/store/query/atom/DNFCallAtom.java
new file mode 100644
index 00000000..3b4f5cd1
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/query/atom/DNFCallAtom.java
@@ -0,0 +1,32 @@
+package tools.refinery.store.query.atom;
+
+import tools.refinery.store.query.DNF;
+import tools.refinery.store.query.Variable;
+
+import java.util.List;
+
+public class DNFCallAtom extends CallAtom<DNF> {
+        public DNFCallAtom(CallPolarity polarity, DNF target, List<Variable> substitution) {
+                super(polarity, target, substitution);
+        }
+
+        public DNFCallAtom(CallPolarity polarity, DNF target, Variable... substitution) {
+                super(polarity, target, substitution);
+        }
+
+        public DNFCallAtom(boolean positive, DNF target, List<Variable> substitution) {
+                super(positive, target, substitution);
+        }
+
+        public DNFCallAtom(boolean positive, DNF target, Variable... substitution) {
+                super(positive, target, substitution);
+        }
+
+        public DNFCallAtom(DNF target, List<Variable> substitution) {
+                super(target, substitution);
+        }
+
+        public DNFCallAtom(DNF target, Variable... substitution) {
+                super(target, substitution);
+        }
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/atom/ModalRelation.java b/subprojects/store/src/main/java/tools/refinery/store/query/atom/ModalRelation.java
index 1e4f8f55..c2ca1fdb 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/query/atom/ModalRelation.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/query/atom/ModalRelation.java
@@ -1,17 +1,17 @@
 package tools.refinery.store.query.atom;
 
-import tools.refinery.store.model.RelationLike;
-import tools.refinery.store.model.representation.Relation;
-import tools.refinery.store.model.representation.TruthValue;
+import tools.refinery.store.representation.SymbolLike;
+import tools.refinery.store.representation.Symbol;
+import tools.refinery.store.representation.TruthValue;
 
-public record ModalRelation(Modality modality, Relation<TruthValue> relation) implements RelationLike {
+public record ModalRelation(Modality modality, Symbol<TruthValue> relation) implements SymbolLike {
         @Override
-        public String getName() {
+        public String name() {
                 return "%s %s".formatted(modality, relation);
         }
 
         @Override
-        public int getArity() {
-                return relation.getArity();
+        public int arity() {
+                return relation.arity();
         }
 }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/view/AbstractFilteredRelationView.java b/subprojects/store/src/main/java/tools/refinery/store/query/view/AbstractFilteredRelationView.java
deleted file mode 100644
index 79de1c4d..00000000
--- a/subprojects/store/src/main/java/tools/refinery/store/query/view/AbstractFilteredRelationView.java
+++ /dev/null
@@ -1,44 +0,0 @@
-package tools.refinery.store.query.view;
-
-import tools.refinery.store.model.Model;
-import tools.refinery.store.tuple.Tuple;
-import tools.refinery.store.tuple.Tuple1;
-import tools.refinery.store.model.representation.Relation;
-
-public abstract class AbstractFilteredRelationView<D> extends RelationView<D> {
-        protected AbstractFilteredRelationView(Relation<D> representation, String name) {
-                super(representation, name);
-        }
-
-        protected AbstractFilteredRelationView(Relation<D> representation) {
-                super(representation);
-        }
-
-        @Override
-        public Object[] forwardMap(Tuple key, D value) {
-                return toTuple1Array(key);
-        }
-
-        @Override
-        public boolean get(Model model, Object[] tuple) {
-                int[] content = new int[tuple.length];
-                for (int i = 0; i < tuple.length; i++) {
-                        content[i] = ((Tuple1) tuple[i]).value0();
-                }
-                Tuple key = Tuple.of(content);
-                D value = model.get(getRepresentation(), key);
-                return filter(key, value);
-        }
-
-        public int getArity() {
-                return this.getRepresentation().getArity();
-        }
-
-        private static Object[] toTuple1Array(Tuple t) {
-                Object[] result = new Object[t.getSize()];
-                for (int i = 0; i < t.getSize(); i++) {
-                        result[i] = Tuple.of(t.get(i));
-                }
-                return result;
-        }
-}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/view/AnyRelationView.java b/subprojects/store/src/main/java/tools/refinery/store/query/view/AnyRelationView.java
index df5e0d72..9df1038b 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/query/view/AnyRelationView.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/query/view/AnyRelationView.java
@@ -1,11 +1,11 @@
 package tools.refinery.store.query.view;
 
 import tools.refinery.store.model.Model;
-import tools.refinery.store.model.RelationLike;
-import tools.refinery.store.model.representation.AnyRelation;
+import tools.refinery.store.representation.SymbolLike;
+import tools.refinery.store.representation.AnySymbol;
 
-public sealed interface AnyRelationView extends RelationLike permits RelationView {
-        AnyRelation getRepresentation();
+public sealed interface AnyRelationView extends SymbolLike permits RelationView {
+        AnySymbol getSymbol();
 
         boolean get(Model model, Object[] tuple);
 
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/view/FilteredRelationView.java b/subprojects/store/src/main/java/tools/refinery/store/query/view/FilteredRelationView.java
index 5b892cc6..64c601bb 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/query/view/FilteredRelationView.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/query/view/FilteredRelationView.java
@@ -1,35 +1,35 @@
 package tools.refinery.store.query.view;
 
 import tools.refinery.store.tuple.Tuple;
-import tools.refinery.store.model.representation.Relation;
+import tools.refinery.store.representation.Symbol;
 
 import java.util.Objects;
 import java.util.function.BiPredicate;
 import java.util.function.Predicate;
 
-public class FilteredRelationView<D> extends AbstractFilteredRelationView<D> {
-        private final BiPredicate<Tuple, D> predicate;
+public class FilteredRelationView<T> extends TuplePreservingRelationView<T> {
+        private final BiPredicate<Tuple, T> predicate;
 
-        public FilteredRelationView(Relation<D> representation, String name, BiPredicate<Tuple, D> predicate) {
-                super(representation, name);
+        public FilteredRelationView(Symbol<T> symbol, String name, BiPredicate<Tuple, T> predicate) {
+                super(symbol, name);
                 this.predicate = predicate;
         }
 
-        public FilteredRelationView(Relation<D> representation, BiPredicate<Tuple, D> predicate) {
-                super(representation);
+        public FilteredRelationView(Symbol<T> symbol, BiPredicate<Tuple, T> predicate) {
+                super(symbol);
                 this.predicate = predicate;
         }
 
-        public FilteredRelationView(Relation<D> representation, String name, Predicate<D> predicate) {
-                this(representation, name, (k, v) -> predicate.test(v));
+        public FilteredRelationView(Symbol<T> symbol, String name, Predicate<T> predicate) {
+                this(symbol, name, (k, v) -> predicate.test(v));
         }
 
-        public FilteredRelationView(Relation<D> representation, Predicate<D> predicate) {
-                this(representation, (k, v) -> predicate.test(v));
+        public FilteredRelationView(Symbol<T> symbol, Predicate<T> predicate) {
+                this(symbol, (k, v) -> predicate.test(v));
         }
 
         @Override
-        public boolean filter(Tuple key, D value) {
+        public boolean filter(Tuple key, T value) {
                 return this.predicate.test(key, value);
         }
 
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/view/FunctionalRelationView.java b/subprojects/store/src/main/java/tools/refinery/store/query/view/FunctionalRelationView.java
index ef3954a4..d263679a 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/query/view/FunctionalRelationView.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/query/view/FunctionalRelationView.java
@@ -3,24 +3,24 @@ package tools.refinery.store.query.view;
 import tools.refinery.store.model.Model;
 import tools.refinery.store.tuple.Tuple;
 import tools.refinery.store.tuple.Tuple1;
-import tools.refinery.store.model.representation.Relation;
+import tools.refinery.store.representation.Symbol;
 
-public class FunctionalRelationView<D> extends RelationView<D> {
-        public FunctionalRelationView(Relation<D> representation, String name) {
-                super(representation, name);
+public class FunctionalRelationView<T> extends RelationView<T> {
+        public FunctionalRelationView(Symbol<T> symbol, String name) {
+                super(symbol, name);
         }
 
-        public FunctionalRelationView(Relation<D> representation) {
-                super(representation);
+        public FunctionalRelationView(Symbol<T> symbol) {
+                super(symbol);
         }
 
         @Override
-        public boolean filter(Tuple key, D value) {
+        public boolean filter(Tuple key, T value) {
                 return true;
         }
 
         @Override
-        public Object[] forwardMap(Tuple key, D value) {
+        public Object[] forwardMap(Tuple key, T value) {
                 return toTuple1ArrayPlusValue(key, value);
         }
 
@@ -32,14 +32,14 @@ public class FunctionalRelationView<D> extends RelationView<D> {
                 }
                 Tuple key = Tuple.of(content);
                 @SuppressWarnings("unchecked")
-                D valueInTuple = (D) tuple[tuple.length - 1];
-                D valueInMap = model.get(getRepresentation(), key);
+                T valueInTuple = (T) tuple[tuple.length - 1];
+                T valueInMap = model.getInterpretation(getSymbol()).get(key);
                 return valueInTuple.equals(valueInMap);
         }
 
         @Override
-        public int getArity() {
-                return getRepresentation().getArity() + 1;
+        public int arity() {
+                return getSymbol().arity() + 1;
         }
 
         private static <D> Object[] toTuple1ArrayPlusValue(Tuple t, D value) {
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/view/KeyOnlyRelationView.java b/subprojects/store/src/main/java/tools/refinery/store/query/view/KeyOnlyRelationView.java
index f7e7d28a..fdfcdf28 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/query/view/KeyOnlyRelationView.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/query/view/KeyOnlyRelationView.java
@@ -1,23 +1,23 @@
 package tools.refinery.store.query.view;
 
+import tools.refinery.store.representation.Symbol;
 import tools.refinery.store.tuple.Tuple;
-import tools.refinery.store.model.representation.Relation;
 
 import java.util.Objects;
 
-public class KeyOnlyRelationView extends AbstractFilteredRelationView<Boolean> {
+public class KeyOnlyRelationView<T> extends TuplePreservingRelationView<T> {
         public static final String VIEW_NAME = "key";
 
-        private final Boolean defaultValue;
+        private final T defaultValue;
 
-        public KeyOnlyRelationView(Relation<Boolean> representation) {
-                super(representation, VIEW_NAME);
-                defaultValue = representation.getDefaultValue();
+        public KeyOnlyRelationView(Symbol<T> symbol) {
+                super(symbol, VIEW_NAME);
+                defaultValue = symbol.defaultValue();
         }
 
         @Override
-        public boolean filter(Tuple key, Boolean value) {
-                return !value.equals(defaultValue);
+        public boolean filter(Tuple key, T value) {
+                return !Objects.equals(value, defaultValue);
         }
 
         @Override
@@ -25,7 +25,7 @@ public class KeyOnlyRelationView extends AbstractFilteredRelationView<Boolean> {
                 if (this == o) return true;
                 if (o == null || getClass() != o.getClass()) return false;
                 if (!super.equals(o)) return false;
-                KeyOnlyRelationView that = (KeyOnlyRelationView) o;
+                KeyOnlyRelationView<?> that = (KeyOnlyRelationView<?>) o;
                 return Objects.equals(defaultValue, that.defaultValue);
         }
 
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/view/RelationView.java b/subprojects/store/src/main/java/tools/refinery/store/query/view/RelationView.java
index 1224076c..bbec1e73 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/query/view/RelationView.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/query/view/RelationView.java
@@ -2,49 +2,49 @@ package tools.refinery.store.query.view;
 
 import tools.refinery.store.map.CursorAsIterator;
 import tools.refinery.store.model.Model;
-import tools.refinery.store.model.representation.Relation;
+import tools.refinery.store.representation.Symbol;
 import tools.refinery.store.tuple.Tuple;
 
 import java.util.Objects;
 import java.util.UUID;
 
 /**
- * Represents a view of a {@link Relation} that can be queried.
+ * Represents a view of a {@link Symbol} that can be queried.
  *
- * @param <D>
+ * @param <T>
  * @author Oszkar Semerath
  */
-public abstract non-sealed class RelationView<D> implements AnyRelationView {
-        private final Relation<D> representation;
+public abstract non-sealed class RelationView<T> implements AnyRelationView {
+        private final Symbol<T> symbol;
 
         private final String name;
 
-        protected RelationView(Relation<D> representation, String name) {
-                this.representation = representation;
+        protected RelationView(Symbol<T> symbol, String name) {
+                this.symbol = symbol;
                 this.name = name;
         }
 
-        protected RelationView(Relation<D> representation) {
+        protected RelationView(Symbol<T> representation) {
                 this(representation, UUID.randomUUID().toString());
         }
 
         @Override
-        public Relation<D> getRepresentation() {
-                return representation;
+        public Symbol<T> getSymbol() {
+                return symbol;
         }
 
         @Override
-        public String getName() {
-                return representation.getName() + "#" + name;
+        public String name() {
+                return symbol.name() + "#" + name;
         }
 
-        public abstract boolean filter(Tuple key, D value);
+        public abstract boolean filter(Tuple key, T value);
 
-        public abstract Object[] forwardMap(Tuple key, D value);
+        public abstract Object[] forwardMap(Tuple key, T value);
 
         @Override
         public Iterable<Object[]> getAll(Model model) {
-                return (() -> new CursorAsIterator<>(model.getAll(representation), this::forwardMap, this::filter));
+                return (() -> new CursorAsIterator<>(model.getInterpretation(symbol).getAll(), this::forwardMap, this::filter));
         }
 
         @Override
@@ -52,11 +52,11 @@ public abstract non-sealed class RelationView<D> implements AnyRelationView {
                 if (this == o) return true;
                 if (o == null || getClass() != o.getClass()) return false;
                 RelationView<?> that = (RelationView<?>) o;
-                return Objects.equals(representation, that.representation) && Objects.equals(name, that.name);
+                return Objects.equals(symbol, that.symbol) && Objects.equals(name, that.name);
         }
 
         @Override
         public int hashCode() {
-                return Objects.hash(representation, name);
+                return Objects.hash(symbol, name);
         }
 }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/view/TuplePreservingRelationView.java b/subprojects/store/src/main/java/tools/refinery/store/query/view/TuplePreservingRelationView.java
new file mode 100644
index 00000000..8cc4986e
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/query/view/TuplePreservingRelationView.java
@@ -0,0 +1,44 @@
+package tools.refinery.store.query.view;
+
+import tools.refinery.store.model.Model;
+import tools.refinery.store.tuple.Tuple;
+import tools.refinery.store.tuple.Tuple1;
+import tools.refinery.store.representation.Symbol;
+
+public abstract class TuplePreservingRelationView<T> extends RelationView<T> {
+        protected TuplePreservingRelationView(Symbol<T> symbol, String name) {
+                super(symbol, name);
+        }
+
+        protected TuplePreservingRelationView(Symbol<T> symbol) {
+                super(symbol);
+        }
+
+        public Object[] forwardMap(Tuple key) {
+                Object[] result = new Object[key.getSize()];
+                for (int i = 0; i < key.getSize(); i++) {
+                        result[i] = Tuple.of(key.get(i));
+                }
+                return result;
+        }
+
+        @Override
+        public Object[] forwardMap(Tuple key, T value) {
+                return forwardMap(key);
+        }
+
+        @Override
+        public boolean get(Model model, Object[] tuple) {
+                int[] content = new int[tuple.length];
+                for (int i = 0; i < tuple.length; i++) {
+                        content[i] = ((Tuple1) tuple[i]).value0();
+                }
+                Tuple key = Tuple.of(content);
+                T value = model.getInterpretation(getSymbol()).get(key);
+                return filter(key, value);
+        }
+
+        public int arity() {
+                return this.getSymbol().arity();
+        }
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/representation/AnySymbol.java b/subprojects/store/src/main/java/tools/refinery/store/representation/AnySymbol.java
new file mode 100644
index 00000000..12a45bed
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/representation/AnySymbol.java
@@ -0,0 +1,5 @@
+package tools.refinery.store.representation;
+
+public sealed interface AnySymbol extends SymbolLike permits Symbol {
+        Class<?> valueType();
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/representation/Symbol.java b/subprojects/store/src/main/java/tools/refinery/store/representation/Symbol.java
new file mode 100644
index 00000000..404b5ddb
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/representation/Symbol.java
@@ -0,0 +1,47 @@
+package tools.refinery.store.representation;
+
+import java.util.Objects;
+
+// Deliberately not a record, because we want equality by reference.
+@SuppressWarnings({"squid:S6206", "ClassCanBeRecord"})
+public final class Symbol<T> implements AnySymbol {
+        private final String name;
+        private final int arity;
+        private final Class<T> valueType;
+        private final T defaultValue;
+
+        public Symbol(String name, int arity, Class<T> valueType, T defaultValue) {
+                this.name = name;
+                this.arity = arity;
+                this.valueType = valueType;
+                this.defaultValue = defaultValue;
+        }
+
+        @Override
+        public String name() {
+                return name;
+        }
+
+        @Override
+        public int arity() {
+                return arity;
+        }
+
+        @Override
+        public Class<T> valueType() {
+                return valueType;
+        }
+
+        public T defaultValue() {
+                return defaultValue;
+        }
+
+        public boolean isDefaultValue(T value) {
+                return Objects.equals(defaultValue, value);
+        }
+
+        @Override
+        public String toString() {
+                return "%s/%d".formatted(name, arity);
+        }
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/representation/SymbolLike.java b/subprojects/store/src/main/java/tools/refinery/store/representation/SymbolLike.java
new file mode 100644
index 00000000..8c84500c
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/representation/SymbolLike.java
@@ -0,0 +1,7 @@
+package tools.refinery.store.representation;
+
+public interface SymbolLike {
+        String name();
+
+        int arity();
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/representation/TruthValue.java b/subprojects/store/src/main/java/tools/refinery/store/representation/TruthValue.java
index a5ba825b..b7893fd3 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/model/representation/TruthValue.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/representation/TruthValue.java
@@ -1,4 +1,4 @@
-package tools.refinery.store.model.representation;
+package tools.refinery.store.representation;
 
 public enum TruthValue {
         TRUE("true"),
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/representation/cardinality/CardinalityInterval.java b/subprojects/store/src/main/java/tools/refinery/store/representation/cardinality/CardinalityInterval.java
index 1f252b4c..273d0de7 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/model/representation/cardinality/CardinalityInterval.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/representation/cardinality/CardinalityInterval.java
@@ -1,4 +1,4 @@
-package tools.refinery.store.model.representation.cardinality;
+package tools.refinery.store.representation.cardinality;
 
 public sealed interface CardinalityInterval permits NonEmptyCardinalityInterval, EmptyCardinalityInterval {
         int lowerBound();
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/representation/cardinality/CardinalityIntervals.java b/subprojects/store/src/main/java/tools/refinery/store/representation/cardinality/CardinalityIntervals.java
index b7c52bd1..e1a08bf9 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/model/representation/cardinality/CardinalityIntervals.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/representation/cardinality/CardinalityIntervals.java
@@ -1,4 +1,4 @@
-package tools.refinery.store.model.representation.cardinality;
+package tools.refinery.store.representation.cardinality;
 
 public final class CardinalityIntervals {
         public static final CardinalityInterval NONE = exactly(0);
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/representation/cardinality/EmptyCardinalityInterval.java b/subprojects/store/src/main/java/tools/refinery/store/representation/cardinality/EmptyCardinalityInterval.java
index 127651df..ab3ad9d1 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/model/representation/cardinality/EmptyCardinalityInterval.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/representation/cardinality/EmptyCardinalityInterval.java
@@ -1,4 +1,4 @@
-package tools.refinery.store.model.representation.cardinality;
+package tools.refinery.store.representation.cardinality;
 
 public final class EmptyCardinalityInterval implements CardinalityInterval {
         static final EmptyCardinalityInterval INSTANCE = new EmptyCardinalityInterval();
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/representation/cardinality/FiniteUpperCardinality.java b/subprojects/store/src/main/java/tools/refinery/store/representation/cardinality/FiniteUpperCardinality.java
index ec643a97..381c8a57 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/model/representation/cardinality/FiniteUpperCardinality.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/representation/cardinality/FiniteUpperCardinality.java
@@ -1,4 +1,4 @@
-package tools.refinery.store.model.representation.cardinality;
+package tools.refinery.store.representation.cardinality;
 
 import org.jetbrains.annotations.NotNull;
 
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/representation/cardinality/NonEmptyCardinalityInterval.java b/subprojects/store/src/main/java/tools/refinery/store/representation/cardinality/NonEmptyCardinalityInterval.java
index b534f2e3..32b3786f 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/model/representation/cardinality/NonEmptyCardinalityInterval.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/representation/cardinality/NonEmptyCardinalityInterval.java
@@ -1,4 +1,4 @@
-package tools.refinery.store.model.representation.cardinality;
+package tools.refinery.store.representation.cardinality;
 
 import java.util.function.BinaryOperator;
 import java.util.function.IntBinaryOperator;
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/representation/cardinality/UnboundedUpperCardinality.java b/subprojects/store/src/main/java/tools/refinery/store/representation/cardinality/UnboundedUpperCardinality.java
index 4199d44f..593bc322 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/model/representation/cardinality/UnboundedUpperCardinality.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/representation/cardinality/UnboundedUpperCardinality.java
@@ -1,4 +1,4 @@
-package tools.refinery.store.model.representation.cardinality;
+package tools.refinery.store.representation.cardinality;
 
 import org.jetbrains.annotations.NotNull;
 
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/representation/cardinality/UpperCardinalities.java b/subprojects/store/src/main/java/tools/refinery/store/representation/cardinality/UpperCardinalities.java
index b433cda2..d850fdc9 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/model/representation/cardinality/UpperCardinalities.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/representation/cardinality/UpperCardinalities.java
@@ -1,4 +1,4 @@
-package tools.refinery.store.model.representation.cardinality;
+package tools.refinery.store.representation.cardinality;
 
 public final class UpperCardinalities {
         public static final UpperCardinality UNBOUNDED = UnboundedUpperCardinality.INSTANCE;
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/representation/cardinality/UpperCardinality.java b/subprojects/store/src/main/java/tools/refinery/store/representation/cardinality/UpperCardinality.java
index 91dd40b0..c6e31cb7 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/model/representation/cardinality/UpperCardinality.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/representation/cardinality/UpperCardinality.java
@@ -1,4 +1,4 @@
-package tools.refinery.store.model.representation.cardinality;
+package tools.refinery.store.representation.cardinality;
 
 public sealed interface UpperCardinality extends Comparable<UpperCardinality> permits FiniteUpperCardinality,
                 UnboundedUpperCardinality {
diff --git a/subprojects/store/src/test/java/tools/refinery/store/map/tests/MapUnitTests.java b/subprojects/store/src/test/java/tools/refinery/store/map/tests/MapUnitTests.java
index 081112cc..77c62305 100644
--- a/subprojects/store/src/test/java/tools/refinery/store/map/tests/MapUnitTests.java
+++ b/subprojects/store/src/test/java/tools/refinery/store/map/tests/MapUnitTests.java
@@ -1,18 +1,17 @@
 package tools.refinery.store.map.tests;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
-
 import org.junit.jupiter.api.Test;
-
 import tools.refinery.store.map.VersionedMapStore;
 import tools.refinery.store.map.VersionedMapStoreImpl;
-import tools.refinery.store.tuple.Tuple;
 import tools.refinery.store.model.TupleHashProvider;
+import tools.refinery.store.tuple.Tuple;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 class MapUnitTests {
         @Test
         void defaultTest() {
-                VersionedMapStore<Tuple, Boolean> store = new VersionedMapStoreImpl<Tuple, Boolean>(TupleHashProvider.singleton(), false);
+                VersionedMapStore<Tuple, Boolean> store = new VersionedMapStoreImpl<>(TupleHashProvider.INSTANCE, false);
                 var map = store.createMap();
                 var out1 = map.put(Tuple.of(0), true);
                 assertEquals(false, out1);
diff --git a/subprojects/store/src/test/java/tools/refinery/store/model/hashTests/HashEfficiencyTest.java b/subprojects/store/src/test/java/tools/refinery/store/model/hashtests/HashEfficiencyTest.java
index ceec40f5..bb083805 100644
--- a/subprojects/store/src/test/java/tools/refinery/store/model/hashTests/HashEfficiencyTest.java
+++ b/subprojects/store/src/test/java/tools/refinery/store/model/hashtests/HashEfficiencyTest.java
@@ -1,4 +1,4 @@
-package tools.refinery.store.model.hashTests;
+package tools.refinery.store.model.hashtests;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 
diff --git a/subprojects/store/src/test/java/tools/refinery/store/model/tests/ModelTest.java b/subprojects/store/src/test/java/tools/refinery/store/model/tests/ModelTest.java
index 7a89daeb..e7bff1f9 100644
--- a/subprojects/store/src/test/java/tools/refinery/store/model/tests/ModelTest.java
+++ b/subprojects/store/src/test/java/tools/refinery/store/model/tests/ModelTest.java
@@ -1,145 +1,149 @@
 package tools.refinery.store.model.tests;
 
 import org.junit.jupiter.api.Test;
-import tools.refinery.store.model.Model;
 import tools.refinery.store.model.ModelStore;
-import tools.refinery.store.model.ModelStoreImpl;
-import tools.refinery.store.model.representation.Relation;
+import tools.refinery.store.representation.Symbol;
 import tools.refinery.store.tuple.Tuple;
 
-import java.util.Set;
-
 import static org.junit.jupiter.api.Assertions.*;
 
 class ModelTest {
-
         @Test
         void modelConstructionTest() {
-                Relation<Boolean> person = new Relation<>("Person", 1, Boolean.class, false);
-                Relation<Boolean> friend = new Relation<>("friend", 2, Boolean.class, false);
+                var person = new Symbol<>("Person", 1, Boolean.class, false);
+                var friend = new Symbol<>("friend", 2, Boolean.class, false);
 
-                ModelStore store = new ModelStoreImpl(Set.of(person, friend));
-                Model model = store.createModel();
+                var store = ModelStore.builder().symbols(person, friend).build();
+                var symbols = store.getSymbols();
 
-                assertTrue(store.getDataRepresentations().contains(person));
-                assertTrue(store.getDataRepresentations().contains(friend));
-                assertTrue(model.getDataRepresentations().contains(person));
-                assertTrue(model.getDataRepresentations().contains(friend));
+                assertTrue(symbols.contains(person));
+                assertTrue(symbols.contains(friend));
 
-                Relation<Integer> other = new Relation<Integer>("other", 2, Integer.class, null);
-                assertFalse(model.getDataRepresentations().contains(other));
+                var other = new Symbol<>("other", 2, Integer.class, null);
+                assertFalse(symbols.contains(other));
         }
 
         @Test
         void modelBuildingTest() {
-                Relation<Boolean> person = new Relation<>("Person", 1, Boolean.class, false);
-                Relation<Integer> age = new Relation<Integer>("age", 1, Integer.class, null);
-                Relation<Boolean> friend = new Relation<>("friend", 2, Boolean.class, false);
-
-                ModelStore store = new ModelStoreImpl(Set.of(person, age, friend));
-                Model model = store.createModel();
-
-                model.put(person, Tuple.of(0), true);
-                model.put(person, Tuple.of(1), true);
-                model.put(age, Tuple.of(0), 3);
-                model.put(age, Tuple.of(1), 1);
-                model.put(friend, Tuple.of(0, 1), true);
-                model.put(friend, Tuple.of(1, 0), true);
-
-                assertTrue(model.get(person, Tuple.of(0)));
-                assertTrue(model.get(person, Tuple.of(1)));
-                assertFalse(model.get(person, Tuple.of(2)));
-
-                assertEquals(3, model.get(age, Tuple.of(0)));
-                assertEquals(1, model.get(age, Tuple.of(1)));
-                assertNull(model.get(age, Tuple.of(2)));
-
-                assertTrue(model.get(friend, Tuple.of(0, 1)));
-                assertFalse(model.get(friend, Tuple.of(0, 5)));
+                var person = new Symbol<>("Person", 1, Boolean.class, false);
+                var age = new Symbol<>("age", 1, Integer.class, null);
+                var friend = new Symbol<>("friend", 2, Boolean.class, false);
+
+                var store = ModelStore.builder().symbols(person, age, friend).build();
+                var model = store.createModel();
+                var personInterpretation = model.getInterpretation(person);
+                var ageInterpretation = model.getInterpretation(age);
+                var friendInterpretation = model.getInterpretation(friend);
+
+                personInterpretation.put(Tuple.of(0), true);
+                personInterpretation.put(Tuple.of(1), true);
+                ageInterpretation.put(Tuple.of(0), 3);
+                ageInterpretation.put(Tuple.of(1), 1);
+                friendInterpretation.put(Tuple.of(0, 1), true);
+                friendInterpretation.put(Tuple.of(1, 0), true);
+
+                assertTrue(personInterpretation.get(Tuple.of(0)));
+                assertTrue(personInterpretation.get(Tuple.of(1)));
+                assertFalse(personInterpretation.get(Tuple.of(2)));
+
+                assertEquals(3, ageInterpretation.get(Tuple.of(0)));
+                assertEquals(1, ageInterpretation.get(Tuple.of(1)));
+                assertNull(ageInterpretation.get( Tuple.of(2)));
+
+                assertTrue(friendInterpretation.get(Tuple.of(0, 1)));
+                assertFalse(friendInterpretation.get(Tuple.of(0, 5)));
         }
 
         @Test
         void modelBuildingArityFailTest() {
-                Relation<Boolean> person = new Relation<>("Person", 1, Boolean.class, false);
+                var person = new Symbol<>("Person", 1, Boolean.class, false);
 
-                ModelStore store = new ModelStoreImpl(Set.of(person));
-                Model model = store.createModel();
+                var store = ModelStore.builder().symbols(person).build();
+                var model = store.createModel();
+                var personInterpretation = model.getInterpretation(person);
 
                 final Tuple tuple3 = Tuple.of(1, 1, 1);
-                assertThrows(IllegalArgumentException.class, () -> model.put(person, tuple3, true));
-                assertThrows(IllegalArgumentException.class, () -> model.get(person, tuple3));
+                assertThrows(IllegalArgumentException.class, () -> personInterpretation.put(tuple3, true));
+                assertThrows(IllegalArgumentException.class, () -> personInterpretation.get(tuple3));
         }
 
         @Test
         void modelBuildingNullFailTest() {
-                Relation<Integer> age = new Relation<Integer>("age", 1, Integer.class, null);
-                ModelStore store = new ModelStoreImpl(Set.of(age));
-                Model model = store.createModel();
+                var age = new Symbol<>("age", 1, Integer.class, null);
+
+                var store = ModelStore.builder().symbols(age).build();
+                var model = store.createModel();
+                var ageInterpretation = model.getInterpretation(age);
 
-                model.put(age, Tuple.of(1), null); // valid
-                assertThrows(IllegalArgumentException.class, () -> model.put(age, null, 1));
-                assertThrows(IllegalArgumentException.class, () -> model.get(age, null));
+                ageInterpretation.put(Tuple.of(1), null); // valid
+                assertThrows(IllegalArgumentException.class, () -> ageInterpretation.put(null, 1));
+                assertThrows(IllegalArgumentException.class, () -> ageInterpretation.get(null));
 
         }
 
         @Test
         void modelUpdateTest() {
-                Relation<Boolean> person = new Relation<>("Person", 1, Boolean.class, false);
-                Relation<Integer> age = new Relation<Integer>("age", 1, Integer.class, null);
-                Relation<Boolean> friend = new Relation<>("friend", 2, Boolean.class, false);
-
-                ModelStore store = new ModelStoreImpl(Set.of(person, age, friend));
-                Model model = store.createModel();
-
-                model.put(person, Tuple.of(0), true);
-                model.put(person, Tuple.of(1), true);
-                model.put(age, Tuple.of(0), 3);
-                model.put(age, Tuple.of(1), 1);
-                model.put(friend, Tuple.of(0, 1), true);
-                model.put(friend, Tuple.of(1, 0), true);
-
-                assertEquals(3, model.get(age, Tuple.of(0)));
-                assertTrue(model.get(friend, Tuple.of(0, 1)));
-
-                model.put(age, Tuple.of(0), 4);
-                model.put(friend, Tuple.of(0, 1), false);
-
-                assertEquals(4, model.get(age, Tuple.of(0)));
-                assertFalse(model.get(friend, Tuple.of(0, 1)));
+                var person = new Symbol<>("Person", 1, Boolean.class, false);
+                var age = new Symbol<>("age", 1, Integer.class, null);
+                var friend = new Symbol<>("friend", 2, Boolean.class, false);
+
+                var store = ModelStore.builder().symbols(person, age, friend).build();
+                var model = store.createModel();
+                var personInterpretation = model.getInterpretation(person);
+                var ageInterpretation = model.getInterpretation(age);
+                var friendInterpretation = model.getInterpretation(friend);
+
+                personInterpretation.put(Tuple.of(0), true);
+                personInterpretation.put(Tuple.of(1), true);
+                ageInterpretation.put(Tuple.of(0), 3);
+                ageInterpretation.put(Tuple.of(1), 1);
+                friendInterpretation.put(Tuple.of(0, 1), true);
+                friendInterpretation.put(Tuple.of(1, 0), true);
+
+                assertEquals(3, ageInterpretation.get(Tuple.of(0)));
+                assertTrue(friendInterpretation.get(Tuple.of(0, 1)));
+
+                ageInterpretation.put(Tuple.of(0), 4);
+                friendInterpretation.put(Tuple.of(0, 1), false);
+
+                assertEquals(4, ageInterpretation.get(Tuple.of(0)));
+                assertFalse(friendInterpretation.get(Tuple.of(0, 1)));
         }
 
         @Test
         void restoreTest() {
-                Relation<Boolean> person = new Relation<Boolean>("Person", 1, Boolean.class, false);
-                Relation<Boolean> friend = new Relation<Boolean>("friend", 2, Boolean.class, false);
-
-                ModelStore store = new ModelStoreImpl(Set.of(person, friend));
-                Model model = store.createModel();
-
-                model.put(person, Tuple.of(0), true);
-                model.put(person, Tuple.of(1), true);
-                model.put(friend, Tuple.of(0, 1), true);
-                model.put(friend, Tuple.of(1, 0), true);
+                var person = new Symbol<>("Person", 1, Boolean.class, false);
+                var friend = new Symbol<>("friend", 2, Boolean.class, false);
+
+                var store = ModelStore.builder().symbols(person, friend).build();
+                var model = store.createModel();
+                var personInterpretation = model.getInterpretation(person);
+                var friendInterpretation = model.getInterpretation(friend);
+
+                personInterpretation.put(Tuple.of(0), true);
+                personInterpretation.put(Tuple.of(1), true);
+                friendInterpretation.put(Tuple.of(0, 1), true);
+                friendInterpretation.put(Tuple.of(1, 0), true);
                 long state1 = model.commit();
 
-                assertFalse(model.get(person, Tuple.of(2)));
-                assertFalse(model.get(friend, Tuple.of(0, 2)));
+                assertFalse(personInterpretation.get(Tuple.of(2)));
+                assertFalse(friendInterpretation.get(Tuple.of(0, 2)));
 
-                model.put(person, Tuple.of(2), true);
-                model.put(friend, Tuple.of(0, 2), true);
+                personInterpretation.put(Tuple.of(2), true);
+                friendInterpretation.put(Tuple.of(0, 2), true);
                 long state2 = model.commit();
 
-                assertTrue(model.get(person, Tuple.of(2)));
-                assertTrue(model.get(friend, Tuple.of(0, 2)));
+                assertTrue(personInterpretation.get(Tuple.of(2)));
+                assertTrue(friendInterpretation.get(Tuple.of(0, 2)));
 
                 model.restore(state1);
 
-                assertFalse(model.get(person, Tuple.of(2)));
-                assertFalse(model.get(friend, Tuple.of(0, 2)));
+                assertFalse(personInterpretation.get(Tuple.of(2)));
+                assertFalse(friendInterpretation.get(Tuple.of(0, 2)));
 
                 model.restore(state2);
 
-                assertTrue(model.get(person, Tuple.of(2)));
-                assertTrue(model.get(friend, Tuple.of(0, 2)));
+                assertTrue(personInterpretation.get(Tuple.of(2)));
+                assertTrue(friendInterpretation.get(Tuple.of(0, 2)));
         }
 }
diff --git a/subprojects/store/src/test/java/tools/refinery/store/model/representation/cardinality/CardinalityIntervalTest.java b/subprojects/store/src/test/java/tools/refinery/store/representation/cardinality/CardinalityIntervalTest.java
index 8a39b9b5..96fdc49e 100644
--- a/subprojects/store/src/test/java/tools/refinery/store/model/representation/cardinality/CardinalityIntervalTest.java
+++ b/subprojects/store/src/test/java/tools/refinery/store/representation/cardinality/CardinalityIntervalTest.java
@@ -1,14 +1,15 @@
-package tools.refinery.store.model.representation.cardinality;
+package tools.refinery.store.representation.cardinality;
 
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
+import tools.refinery.store.representation.cardinality.CardinalityInterval;
 
 import java.util.stream.Stream;
 
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.equalTo;
-import static tools.refinery.store.model.representation.cardinality.CardinalityIntervals.*;
+import static tools.refinery.store.representation.cardinality.CardinalityIntervals.*;
 
 class CardinalityIntervalTest {
         @ParameterizedTest(name = "min({0}, {1}) == {2}")
diff --git a/subprojects/store/src/test/java/tools/refinery/store/model/representation/cardinality/CardinalityIntervalsTest.java b/subprojects/store/src/test/java/tools/refinery/store/representation/cardinality/CardinalityIntervalsTest.java
index ef68a607..4a9ef8da 100644
--- a/subprojects/store/src/test/java/tools/refinery/store/model/representation/cardinality/CardinalityIntervalsTest.java
+++ b/subprojects/store/src/test/java/tools/refinery/store/representation/cardinality/CardinalityIntervalsTest.java
@@ -1,6 +1,8 @@
-package tools.refinery.store.model.representation.cardinality;
+package tools.refinery.store.representation.cardinality;
 
 import org.junit.jupiter.api.Test;
+import tools.refinery.store.representation.cardinality.CardinalityIntervals;
+import tools.refinery.store.representation.cardinality.UpperCardinalities;
 
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.*;
diff --git a/subprojects/store/src/test/java/tools/refinery/store/model/representation/cardinality/EmptyCardinalityIntervalTest.java b/subprojects/store/src/test/java/tools/refinery/store/representation/cardinality/EmptyCardinalityIntervalTest.java
index 41c884ec..e8b77b9f 100644
--- a/subprojects/store/src/test/java/tools/refinery/store/model/representation/cardinality/EmptyCardinalityIntervalTest.java
+++ b/subprojects/store/src/test/java/tools/refinery/store/representation/cardinality/EmptyCardinalityIntervalTest.java
@@ -1,6 +1,7 @@
-package tools.refinery.store.model.representation.cardinality;
+package tools.refinery.store.representation.cardinality;
 
 import org.junit.jupiter.api.Test;
+import tools.refinery.store.representation.cardinality.CardinalityIntervals;
 
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.lessThan;
diff --git a/subprojects/store/src/test/java/tools/refinery/store/model/representation/cardinality/FiniteCardinalityIntervalTest.java b/subprojects/store/src/test/java/tools/refinery/store/representation/cardinality/FiniteCardinalityIntervalTest.java
index dfb37786..9a190818 100644
--- a/subprojects/store/src/test/java/tools/refinery/store/model/representation/cardinality/FiniteCardinalityIntervalTest.java
+++ b/subprojects/store/src/test/java/tools/refinery/store/representation/cardinality/FiniteCardinalityIntervalTest.java
@@ -1,6 +1,9 @@
-package tools.refinery.store.model.representation.cardinality;
+package tools.refinery.store.representation.cardinality;
 
 import org.junit.jupiter.api.Test;
+import tools.refinery.store.representation.cardinality.NonEmptyCardinalityInterval;
+import tools.refinery.store.representation.cardinality.UpperCardinalities;
+import tools.refinery.store.representation.cardinality.UpperCardinality;
 
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
diff --git a/subprojects/store/src/test/java/tools/refinery/store/model/representation/cardinality/FiniteUpperCardinalityTest.java b/subprojects/store/src/test/java/tools/refinery/store/representation/cardinality/FiniteUpperCardinalityTest.java
index 3f0f7a4a..90c21759 100644
--- a/subprojects/store/src/test/java/tools/refinery/store/model/representation/cardinality/FiniteUpperCardinalityTest.java
+++ b/subprojects/store/src/test/java/tools/refinery/store/representation/cardinality/FiniteUpperCardinalityTest.java
@@ -1,6 +1,7 @@
-package tools.refinery.store.model.representation.cardinality;
+package tools.refinery.store.representation.cardinality;
 
 import org.junit.jupiter.api.Test;
+import tools.refinery.store.representation.cardinality.FiniteUpperCardinality;
 
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
diff --git a/subprojects/store/src/test/java/tools/refinery/store/model/representation/cardinality/UpperCardinalitiesTest.java b/subprojects/store/src/test/java/tools/refinery/store/representation/cardinality/UpperCardinalitiesTest.java
index 13171ae5..3c7c0320 100644
--- a/subprojects/store/src/test/java/tools/refinery/store/model/representation/cardinality/UpperCardinalitiesTest.java
+++ b/subprojects/store/src/test/java/tools/refinery/store/representation/cardinality/UpperCardinalitiesTest.java
@@ -1,8 +1,11 @@
-package tools.refinery.store.model.representation.cardinality;
+package tools.refinery.store.representation.cardinality;
 
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.ValueSource;
+import tools.refinery.store.representation.cardinality.FiniteUpperCardinality;
+import tools.refinery.store.representation.cardinality.UnboundedUpperCardinality;
+import tools.refinery.store.representation.cardinality.UpperCardinalities;
 
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.equalTo;
diff --git a/subprojects/store/src/test/java/tools/refinery/store/model/representation/cardinality/UpperCardinalityTest.java b/subprojects/store/src/test/java/tools/refinery/store/representation/cardinality/UpperCardinalityTest.java
index f5763c2d..e87ce29b 100644
--- a/subprojects/store/src/test/java/tools/refinery/store/model/representation/cardinality/UpperCardinalityTest.java
+++ b/subprojects/store/src/test/java/tools/refinery/store/representation/cardinality/UpperCardinalityTest.java
@@ -1,8 +1,10 @@
-package tools.refinery.store.model.representation.cardinality;
+package tools.refinery.store.representation.cardinality;
 
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
+import tools.refinery.store.representation.cardinality.UpperCardinalities;
+import tools.refinery.store.representation.cardinality.UpperCardinality;
 
 import java.util.stream.Stream;