diff --git a/server/src/main/kotlin/com/larsreimann/api_editor/mutable_model/PythonAst.kt b/server/src/main/kotlin/com/larsreimann/api_editor/mutable_model/PythonAst.kt
new file mode 100644
index 000000000..bd5c0f197
--- /dev/null
+++ b/server/src/main/kotlin/com/larsreimann/api_editor/mutable_model/PythonAst.kt
@@ -0,0 +1,153 @@
+@file:Suppress("unused")
+
+package com.larsreimann.api_editor.mutable_model
+
+import com.larsreimann.api_editor.model.Boundary
+import com.larsreimann.api_editor.model.EditorAnnotation
+import com.larsreimann.api_editor.model.PythonEnumInstance
+import com.larsreimann.api_editor.model.PythonFromImport
+import com.larsreimann.api_editor.model.PythonImport
+import com.larsreimann.api_editor.model.PythonParameterAssignment
+
+private sealed class PythonAstNode : TreeNode()
+
+private sealed class PythonDeclaration(
+    var name: String,
+    val annotations: MutableList<EditorAnnotation> = mutableListOf()
+) : PythonAstNode() {
+
+    /**
+     * Returns the qualified name of the declaration.
+     */
+    fun qualifiedName(): String {
+        return ancestorsOrSelf()
+            .filterIsInstance<PythonDeclaration>()
+            .toList()
+            .asReversed()
+            .joinToString(separator = ".") { it.name }
+    }
+}
+
+private class PythonPackage(
+    var distribution: String,
+    name: String,
+    var version: String,
+    modules: List<PythonModule> = emptyList(),
+    annotations: MutableList<EditorAnnotation> = mutableListOf()
+) : PythonDeclaration(name, annotations) {
+
+    val modules = ContainmentList(modules)
+
+    override fun children() = sequence {
+        yieldAll(modules)
+    }
+}
+
+private class PythonModule(
+    name: String,
+    val imports: MutableList<PythonImport> = mutableListOf(),
+    val fromImports: MutableList<PythonFromImport> = mutableListOf(),
+    classes: List<PythonClass> = emptyList(),
+    enums: List<PythonEnum> = emptyList(),
+    functions: List<PythonFunction> = emptyList(),
+    annotations: MutableList<EditorAnnotation> = mutableListOf()
+) : PythonDeclaration(name, annotations) {
+
+    val classes = ContainmentList(classes)
+    val enums = ContainmentList(enums)
+    val functions = ContainmentList(functions)
+
+    override fun children() = sequence {
+        yieldAll(classes)
+        yieldAll(enums)
+        yieldAll(functions)
+    }
+}
+
+private class PythonClass(
+    name: String,
+    val decorators: MutableList<String> = mutableListOf(),
+    val superclasses: MutableList<String> = mutableListOf(),
+    attributes: List<PythonAttribute> = emptyList(),
+    methods: List<PythonFunction> = emptyList(),
+    var description: String = "",
+    var fullDocstring: String = "",
+    annotations: MutableList<EditorAnnotation> = mutableListOf()
+) : PythonDeclaration(name, annotations) {
+
+    val attributes = ContainmentList(attributes)
+    val methods = ContainmentList(methods)
+
+    override fun children() = sequence {
+        yieldAll(attributes)
+        yieldAll(methods)
+    }
+}
+
+private class PythonEnum(
+    name: String,
+    val instances: MutableList<PythonEnumInstance> = mutableListOf(),
+    annotations: MutableList<EditorAnnotation> = mutableListOf()
+) : PythonDeclaration(name, annotations)
+
+private class PythonFunction(
+    name: String,
+    val decorators: MutableList<String> = mutableListOf(),
+    parameters: List<PythonParameter> = emptyList(),
+    results: List<PythonResult> = emptyList(),
+    var isPublic: Boolean = true,
+    var description: String = "",
+    var fullDocstring: String = "",
+    val calledAfter: MutableList<String> = mutableListOf(), // TODO: should be cross-references
+    var isPure: Boolean = false,
+    annotations: MutableList<EditorAnnotation> = mutableListOf()
+) : PythonDeclaration(name, annotations) {
+
+    val parameters = ContainmentList(parameters)
+    val results = ContainmentList(results)
+
+    override fun children() = sequence {
+        yieldAll(parameters)
+        yieldAll(results)
+    }
+
+    fun isConstructor() = name == "__init__"
+}
+
+private class PythonAttribute(
+    name: String,
+    var defaultValue: String = "",
+    var isPublic: Boolean = true,
+    var typeInDocs: String = "",
+    var description: String = "",
+    var boundary: Boundary? = null,
+    annotations: MutableList<EditorAnnotation> = mutableListOf()
+) : PythonDeclaration(name, annotations)
+
+private class PythonParameter(
+    name: String,
+    var defaultValue: String? = null,
+    var assignedBy: PythonParameterAssignment = PythonParameterAssignment.POSITION_OR_NAME,
+    var isPublic: Boolean = true,
+    var typeInDocs: String = "",
+    var description: String = "",
+    var boundary: Boundary? = null,
+    annotations: MutableList<EditorAnnotation> = mutableListOf()
+) : PythonDeclaration(name, annotations)
+
+private class PythonResult(
+    name: String,
+    var type: String = "",
+    var typeInDocs: String = "",
+    var description: String = "",
+    var boundary: Boundary? = null,
+    annotations: MutableList<EditorAnnotation> = mutableListOf()
+) : PythonDeclaration(name, annotations)
+
+private sealed class PythonStatement : PythonAstNode() // TODO
+
+private class PythonExpressionStatement : PythonStatement() // TODO
+
+private sealed class PythonExpression : PythonAstNode() // TODO
+
+private class PythonCall : PythonStatement() // TODO
diff --git a/server/src/main/kotlin/com/larsreimann/api_editor/mutable_model/TreeNode.kt b/server/src/main/kotlin/com/larsreimann/api_editor/mutable_model/TreeNode.kt
new file mode 100644
index 000000000..1e697303e
--- /dev/null
+++ b/server/src/main/kotlin/com/larsreimann/api_editor/mutable_model/TreeNode.kt
@@ -0,0 +1,256 @@
+package com.larsreimann.api_editor.mutable_model
+
+import kotlin.reflect.KProperty
+
+/**
+ * A node in a tree. It has references to its parent and its children.
+ */
+open class TreeNode {
+
+    /**
+     * The parent of this node in the tree.
+     */
+    var parent: TreeNode? = null
+        private set
+
+    /**
+     * The container of this node in the tree.
+     */
+    var container: TreeNodeContainer<*>? = null
+        private set
+
+    /**
+     * Whether this node is the root of the tree.
+     */
+    fun isRoot(): Boolean {
+        return parent == null
+    }
+
+    /**
+     * The child nodes of this node.
+     */
+    open fun children() = emptySequence<TreeNode>()
+
+    /**
+     * Releases the subtree that has this node as root.
+     */
+    fun release() {
+        this.container?.releaseNode(this)
+    }
+
+    /**
+     * A container for [TreeNode]s of the given type.
+     */
+    sealed class TreeNodeContainer<T : TreeNode> {
+
+        /**
+         * Releases the subtree that has this node as root. If this container does not contain the node nothing should
+         * happen. Otherwise, the following links need to be removed:
+         *   - From the container to the node
+         *   - From the node to its parent
+         *   - From the node to its container
+         */
+        internal abstract fun releaseNode(node: TreeNode)
+
+        /**
+         * Sets parent and container properties of the node to `null`. This method can be called without causing cyclic
+         * updates.
+         */
+        protected fun nullifyUplinks(node: TreeNode?) {
+            node?.parent = null
+            node?.container = null
+        }
+
+        /**
+         * Sets parent and container properties of the node to this container. This method can be called without causing
+         * cyclic updates.
+         */
+        protected fun TreeNode?.pointUplinksToThisContainer(node: TreeNode?) {
+            node?.parent = this
+            node?.container = this@TreeNodeContainer
+        }
+    }
+
+    /**
+     * Stores a reference to a [TreeNode] and keeps uplinks (parent/container) and downlinks (container to node) updated
+     * on mutation.
+     *
+     * **Samples:**
+     *
+     * _Normal assignment:_
+     * ```kt
+     * object Root: TreeNode() {
+     *     private val child = ContainmentReference(TreeNode())
+     *
+     *     fun get(): TreeNode? {
+     *         return child.node
+     *     }
+     *
+     *     fun set(newNode: TreeNode?) {
+     *         child.node = newNode
+     *     }
+     * }
+     * ```
+     *
+     * _Mutable delegate:_
+     * ```kt
+     * object Root: TreeNode() {
+     *     private var child by ContainmentReference(TreeNode())
+     *
+     *     fun get(): TreeNode? {
+     *         return child
+     *     }
+     *
+     *     fun set(newNode: TreeNode?) {
+     *         child = newNode
+     *     }
+     * }
+     * ```
+     *
+     * _Immutable delegate:_
+     * ```kt
+     * object Root: TreeNode() {
+     *     private val child by ContainmentReference(TreeNode())
+     *
+     *     fun get(): TreeNode? {
+     *         return child
+     *     }
+     *
+     *     fun set(newNode: TreeNode?) {
+     *         // Not possible
+     *     }
+     * }
+     * ```
+     *
+     * @param node The initial value.
+     */
+    inner class ContainmentReference<T : TreeNode>(node: T?) : TreeNodeContainer<T>() {
+        var node: T? = null
+            set(value) {
+
+                // Prevents infinite recursion when releasing the new value
+                if (field == value) {
+                    return
+                }
+
+                // Release old value
+                nullifyUplinks(field)
+                field = null
+
+                // Release new value
+                value?.release()
+
+                // Store new value in this container
+                pointUplinksToThisContainer(value)
+                field = value
+            }
+
+        init {
+            this.node = node
+        }
+
+        override fun releaseNode(node: TreeNode) {
+            if (this.node == node) {
+                this.node = null
+            }
+        }
+
+        operator fun getValue(node: T, property: KProperty<*>): T? {
+            return this.node
+        }
+
+        operator fun setValue(oldNode: T, property: KProperty<*>, newNode: T?) {
+            this.node = newNode
+        }
+    }
+
+    /**
+     * Stores a list of references to [TreeNode]s and keeps uplinks (parent/container) and downlinks (container to node)
+     * updated on mutation.
+     *
+     * @param nodes The initial nodes.
+     */
+    inner class ContainmentList<T : TreeNode> private constructor(
+        nodes: Collection<T>,
+        private val delegate: MutableList<T>
+    ) : TreeNodeContainer<T>(), MutableList<T> by delegate {
+
+        constructor(nodes: Collection<T> = emptyList()) : this(nodes, mutableListOf())
+
+        init {
+            addAll(nodes)
+        }
+
+        override fun releaseNode(node: TreeNode) {
+            this.remove(node)
+        }
+
+        override fun add(element: T): Boolean {
+            element.release()
+            pointUplinksToThisContainer(element)
+            return delegate.add(element)
+        }
+
+        override fun add(index: Int, element: T) {
+            element.release()
+            pointUplinksToThisContainer(element)
+            delegate.add(index, element)
+        }
+
+        override fun addAll(elements: Collection<T>): Boolean {
+            elements.forEach {
+                it.release()
+                pointUplinksToThisContainer(it)
+            }
+            return delegate.addAll(elements)
+        }
+
+        override fun addAll(index: Int, elements: Collection<T>): Boolean {
+            elements.forEach {
+                it.release()
+                pointUplinksToThisContainer(it)
+            }
+            return delegate.addAll(index, elements)
+        }
+
+        override fun remove(element: T): Boolean {
+            val wasRemoved = delegate.remove(element)
+            if (wasRemoved) {
+                nullifyUplinks(element)
+            }
+            return wasRemoved
+        }
+
+        override fun removeAt(index: Int): T {
+            val removedElement = delegate.removeAt(index)
+            nullifyUplinks(removedElement)
+            return removedElement
+        }
+
+        override fun removeAll(elements: Collection<T>): Boolean {
+            return elements.fold(false) { accumulator, element ->
+                accumulator || remove(element)
+            }
+        }
+
+        override fun retainAll(elements: Collection<T>): Boolean {
+            val toRemove = subtract(elements.toSet())
+            return removeAll(toRemove)
+        }
+
+        override fun clear() {
+            forEach { nullifyUplinks(it) }
+            delegate.clear()
+        }
+
+        override fun set(index: Int, element: T): T {
+            val replacedElement = delegate.set(index, element)
+            nullifyUplinks(replacedElement)
+
+            element.release()
+            pointUplinksToThisContainer(element)
+
+            return replacedElement
+        }
+    }
+}
diff --git a/server/src/main/kotlin/com/larsreimann/api_editor/mutable_model/TreeNodeTraversal.kt b/server/src/main/kotlin/com/larsreimann/api_editor/mutable_model/TreeNodeTraversal.kt
new file mode 100644
index 000000000..a40ee787a
--- /dev/null
+++ b/server/src/main/kotlin/com/larsreimann/api_editor/mutable_model/TreeNodeTraversal.kt
@@ -0,0 +1,141 @@
+package com.larsreimann.api_editor.mutable_model
+
+/**
+ * Returns the root of the tree that contains this [TreeNode]. This may be this [TreeNode] itself.
+ */
+fun TreeNode.root(): TreeNode {
+    return parent?.root() ?: this
+}
+
+/**
+ * Returns the ancestors of this [TreeNode] starting with its parent (if we are not at the root already) and then
+ * walking up the tree to the root.
+ */
+fun TreeNode.ancestors(): Sequence<TreeNode> {
+    return sequence {
+        var current = parent
+        while (current != null) {
+            yield(current)
+            current = current.parent
+        }
+    }
+}
+
+/**
+ * Returns this [TreeNode] and its ancestors starting at this [TreeNode] and then walking up the tree to the root.
+ */
+fun TreeNode.ancestorsOrSelf(): Sequence<TreeNode> {
+    return sequence {
+        yield(this@ancestorsOrSelf)
+        yieldAll(ancestors())
+    }
+}
+
+/**
+ * Returns the siblings of this [TreeNode], i.e. the children of its parent excluding this [TreeNode]. The
+ * siblings are ordered like the children of the parent.
+ */
+fun TreeNode.siblings(): Sequence<TreeNode> {
+    return parent?.children()?.filterNot { it == this } ?: emptySequence()
+}
+
+/**
+ * Returns the children of the parent of this [TreeNode], including this [TreeNode]. The elements are ordered like
+ * the children of the parent.
+ */
+fun TreeNode.siblingsOrSelf(): Sequence<TreeNode> {
+    return parent?.children() ?: emptySequence()
+}
+
+/**
+ * Defines the order in which descendants are traversed by [descendants] or [descendantsOrSelf].
+ */
+enum class Traversal {
+
+    /**
+     * A parent is listed before any of its children.
+     */
+    PREORDER,
+
+    /**
+     * A parent is listed after all its children.
+     */
+    POSTORDER
+}
+
+/**
+ * Returns the descendants of this [TreeNode]. We can switch between preorder and postorder traversal.
+ *
+ * @param order
+ * The traversal order. Preorder means a parent is listed before any of its children and postorder means a parent is
+ * listed after all its children.
+ *
+ * @param shouldTraverse
+ * Whether the subtree should be traversed. If this function returns false for a concept none of its descendants will be
+ * returned.
+ */
+fun TreeNode.descendants(
+    order: Traversal = Traversal.PREORDER,
+    shouldTraverse: (TreeNode) -> Boolean = { true }
+): Sequence<TreeNode> {
+
+    // Prevent children from being traversed if this concept should be pruned
+    if (!shouldTraverse(this)) {
+        return emptySequence()
+    }
+
+    return sequence {
+        for (child in children()) {
+
+            // We must prune again here; otherwise the child would be yielded unchecked
+            if (!shouldTraverse(child)) {
+                continue
+            }
+
+            if (order == Traversal.PREORDER) {
+                yield(child)
+            }
+            yieldAll(child.descendants(order, shouldTraverse))
+            if (order == Traversal.POSTORDER) {
+                yield(child)
+            }
+        }
+    }
+}
+
+/**
+ * Returns this [TreeNode] and its descendants. We can switch between preorder and postorder traversal.
+ *
+ * @param order
+ * The traversal order. Preorder means a parent is listed before any of its children and postorder means a parent is
+ * listed after all its children.
+ *
+ * @param shouldTraverse
+ * Whether the subtree should be traversed. If this function returns false for a concept neither the concept itself nor
+ * any of its descendants will be traversed.
+ */
+fun TreeNode.descendantsOrSelf(
+    order: Traversal = Traversal.PREORDER,
+    shouldTraverse: (TreeNode) -> Boolean = { true }
+): Sequence<TreeNode> {
+    if (!shouldTraverse(this)) {
+        return emptySequence()
+    }
+
+    return sequence {
+        if (order == Traversal.PREORDER) {
+            yield(this@descendantsOrSelf)
+        }
+        yieldAll(descendants(order, shouldTraverse))
+        if (order == Traversal.POSTORDER) {
+            yield(this@descendantsOrSelf)
+        }
+    }
+}
+
+/**
+ * Returns this [TreeNode] or its nearest ancestor with the specified type.
+ */
+inline fun <reified T> TreeNode.closest(): T? {
+    return ancestorsOrSelf().firstOrNull { it is T } as T?
+}
diff --git a/server/src/test/kotlin/com/larsreimann/api_editor/mutable_model/ContainmentListTest.kt b/server/src/test/kotlin/com/larsreimann/api_editor/mutable_model/ContainmentListTest.kt
new file mode 100644
index 000000000..83faa95d7
--- /dev/null
+++ b/server/src/test/kotlin/com/larsreimann/api_editor/mutable_model/ContainmentListTest.kt
@@ -0,0 +1,262 @@
+package com.larsreimann.api_editor.mutable_model
+
+import io.kotest.matchers.collections.shouldBeEmpty
+import io.kotest.matchers.collections.shouldHaveSize
+import io.kotest.matchers.nulls.shouldBeNull
+import io.kotest.matchers.shouldBe
+import org.junit.jupiter.api.BeforeEach
+import org.junit.jupiter.api.Test
+
+class ContainmentListTest {
+
+    private class Root(children: List<TreeNode>, someMoreChildren: List<TreeNode>) : TreeNode() {
+        val children = ContainmentList(children)
+        val someMoreChildren = ContainmentList(someMoreChildren)
+    }
+
+    private lateinit var innerNode: TreeNode
+    private lateinit var someOtherInnerNode: TreeNode
+    private lateinit var root: Root
+
+    @BeforeEach
+    fun resetTestData() {
+        innerNode = TreeNode()
+        someOtherInnerNode = TreeNode()
+        root = Root(listOf(innerNode), listOf(someOtherInnerNode))
+    }
+
+    @Test
+    fun `constructor should correctly link initial values`() {
+        innerNode.parent shouldBe root
+        innerNode.container shouldBe root.children
+        root.children.shouldHaveSize(1)
+        root.children[0] shouldBe innerNode
+    }
+
+    @Test
+    fun `releaseNode should update links if a node is passed that is referenced`() {
+        root.children.releaseNode(innerNode)
+
+        innerNode.parent.shouldBeNull()
+        innerNode.container.shouldBeNull()
+        root.children.shouldBeEmpty()
+    }
+
+    @Test
+    fun `releaseNode should do nothing if a node is passed that is not referenced`() {
+        root.children.releaseNode(someOtherInnerNode)
+
+        innerNode.parent shouldBe root
+        innerNode.container shouldBe root.children
+        root.children.shouldHaveSize(1)
+        root.children[0] shouldBe innerNode
+
+        someOtherInnerNode.parent shouldBe root
+        someOtherInnerNode.container shouldBe root.someMoreChildren
+        root.someMoreChildren.shouldHaveSize(1)
+        root.someMoreChildren[0] shouldBe someOtherInnerNode
+    }
+
+    @Test
+    fun `add(T) should update links if a new node is passed`() {
+        root.children.add(someOtherInnerNode)
+
+        someOtherInnerNode.parent shouldBe root
+        someOtherInnerNode.container shouldBe root.children
+        root.children.shouldHaveSize(2)
+        root.children[1] shouldBe someOtherInnerNode
+        root.someMoreChildren.shouldBeEmpty()
+    }
+
+    @Test
+    fun `add(T) should update links if an existing node is passed`() {
+        root.children.add(innerNode)
+
+        innerNode.parent shouldBe root
+        innerNode.container shouldBe root.children
+        root.children.shouldHaveSize(1)
+        root.children[0] shouldBe innerNode
+    }
+
+    @Test
+    fun `add(Int, T) should update links if a new node is passed`() {
+        root.children.add(0, someOtherInnerNode)
+
+        someOtherInnerNode.parent shouldBe root
+        someOtherInnerNode.container shouldBe root.children
+        root.children.shouldHaveSize(2)
+        root.children[0] shouldBe someOtherInnerNode
+        root.someMoreChildren.shouldBeEmpty()
+    }
+
+    @Test
+    fun `add(Int, T) should update links if an existing node is passed`() {
+        root.children.add(0, innerNode)
+
+        innerNode.parent shouldBe root
+        innerNode.container shouldBe root.children
+        root.children.shouldHaveSize(1)
+        root.children[0] shouldBe innerNode
+    }
+
+    @Test
+    fun `addAll(Collection) should update links if new nodes are passed`() {
+        root.children.addAll(listOf(someOtherInnerNode))
+
+        someOtherInnerNode.parent shouldBe root
+        someOtherInnerNode.container shouldBe root.children
+        root.children.shouldHaveSize(2)
+        root.children[1] shouldBe someOtherInnerNode
+        root.someMoreChildren.shouldBeEmpty()
+    }
+
+    @Test
+    fun `addAll(Collection) should update links if existing nodes are passed`() {
+        root.children.addAll(listOf(innerNode))
+
+        innerNode.parent shouldBe root
+        innerNode.container shouldBe root.children
+        root.children.shouldHaveSize(1)
+        root.children[0] shouldBe innerNode
+    }
+
+    @Test
+    fun `addAll(Int, Collection) should update links if new nodes are passed`() {
+        root.children.addAll(0, listOf(someOtherInnerNode))
+
+        someOtherInnerNode.parent shouldBe root
+        someOtherInnerNode.container shouldBe root.children
+        root.children.shouldHaveSize(2)
+        root.children[0] shouldBe someOtherInnerNode
+        root.someMoreChildren.shouldBeEmpty()
+    }
+
+    @Test
+    fun `addAll(Int, Collection) should update links if existing nodes are passed`() {
+        root.children.addAll(0, listOf(innerNode))
+
+        innerNode.parent shouldBe root
+        innerNode.container shouldBe root.children
+        root.children.shouldHaveSize(1)
+        root.children[0] shouldBe innerNode
+    }
+
+    @Test
+    fun `remove(T) should update links if a node is removed that is referenced`() {
+        root.children.remove(innerNode)
+
+        innerNode.parent.shouldBeNull()
+        innerNode.container.shouldBeNull()
+        root.children.shouldBeEmpty()
+    }
+
+    @Test
+    fun `remove(T) should do nothing if a node is removed that is not referenced`() {
+        root.children.remove(someOtherInnerNode)
+
+        innerNode.parent shouldBe root
+        innerNode.container shouldBe root.children
+        root.children.shouldHaveSize(1)
+        root.children[0] shouldBe innerNode
+
+        someOtherInnerNode.parent shouldBe root
+        someOtherInnerNode.container shouldBe root.someMoreChildren
+        root.someMoreChildren.shouldHaveSize(1)
+        root.someMoreChildren[0] shouldBe someOtherInnerNode
+    }
+
+    @Test
+    fun `removeAt(Int) should update links if a node exists at the index`() {
+        root.children.removeAt(0)
+
+        innerNode.parent.shouldBeNull()
+        innerNode.container.shouldBeNull()
+        root.children.shouldBeEmpty()
+    }
+
+    @Test
+    fun `removeAll(Collection) should update links if nodes are removed that are referenced`() {
+        root.children.removeAll(listOf(innerNode))
+
+        innerNode.parent.shouldBeNull()
+        innerNode.container.shouldBeNull()
+        root.children.shouldBeEmpty()
+    }
+
+    @Test
+    fun `removeAll(Collection) should do nothing if nodes are removed that are not referenced`() {
+        root.children.removeAll(listOf(someOtherInnerNode))
+
+        innerNode.parent shouldBe root
+        innerNode.container shouldBe root.children
+        root.children.shouldHaveSize(1)
+        root.children[0] shouldBe innerNode
+
+        someOtherInnerNode.parent shouldBe root
+        someOtherInnerNode.container shouldBe root.someMoreChildren
+        root.someMoreChildren.shouldHaveSize(1)
+        root.someMoreChildren[0] shouldBe someOtherInnerNode
+    }
+
+    @Test
+    fun `retainAll(Collection) should update links for nodes that are not retained`() {
+        root.children.retainAll(listOf())
+
+        innerNode.parent.shouldBeNull()
+        innerNode.container.shouldBeNull()
+        root.children.shouldBeEmpty()
+    }
+
+    @Test
+    fun `retainAll(Collection) should not change the passed nodes`() {
+        root.children.retainAll(listOf(someOtherInnerNode))
+
+        someOtherInnerNode.parent shouldBe root
+        someOtherInnerNode.container shouldBe root.someMoreChildren
+        root.someMoreChildren.shouldHaveSize(1)
+        root.someMoreChildren[0] shouldBe someOtherInnerNode
+    }
+
+    @Test
+    fun `retainAll(Collection) should do nothing for nodes that are retained`() {
+        root.children.retainAll(listOf(innerNode))
+
+        innerNode.parent shouldBe root
+        innerNode.container shouldBe root.children
+        root.children.shouldHaveSize(1)
+        root.children[0] shouldBe innerNode
+    }
+
+    @Test
+    fun `clear() should update links for all nodes`() {
+        root.children.clear()
+
+        innerNode.parent.shouldBeNull()
+        innerNode.container.shouldBeNull()
+        root.children.shouldBeEmpty()
+    }
+
+    @Test
+    fun `set(Int, T) should update links if a new node is passed`() {
+        root.children[0] = someOtherInnerNode
+
+        innerNode.parent.shouldBeNull()
+        innerNode.container.shouldBeNull()
+
+        someOtherInnerNode.parent shouldBe root
+        someOtherInnerNode.container shouldBe root.children
+
+        root.children.shouldHaveSize(1)
+        root.children[0] shouldBe someOtherInnerNode
+    }
+
+    @Test
+    fun `set(Int, T) should update links if an existing node is passed`() {
+        root.children[0] = innerNode
+
+        innerNode.parent shouldBe root
+        innerNode.container shouldBe root.children
+        root.children.shouldHaveSize(1)
+        root.children[0] shouldBe innerNode
+    }
+}
diff --git a/server/src/test/kotlin/com/larsreimann/api_editor/mutable_model/ContainmentReferenceTest.kt b/server/src/test/kotlin/com/larsreimann/api_editor/mutable_model/ContainmentReferenceTest.kt
new file mode 100644
index 000000000..e42c5dbbf
--- /dev/null
+++ b/server/src/test/kotlin/com/larsreimann/api_editor/mutable_model/ContainmentReferenceTest.kt
@@ -0,0 +1,88 @@
+package com.larsreimann.api_editor.mutable_model
+
+import io.kotest.assertions.throwables.shouldNotThrowUnit
+import io.kotest.matchers.concurrent.shouldCompleteWithin
+import io.kotest.matchers.nulls.shouldBeNull
+import io.kotest.matchers.shouldBe
+import org.junit.jupiter.api.BeforeEach
+import org.junit.jupiter.api.Test
+import java.util.concurrent.TimeUnit
+
+class ContainmentReferenceTest {
+
+    private class Root(child: TreeNode, someOtherChild: TreeNode) : TreeNode() {
+        val child = ContainmentReference(child)
+        val someOtherChild = ContainmentReference(someOtherChild)
+    }
+
+    private lateinit var innerNode: TreeNode
+    private lateinit var someOtherInnerNode: TreeNode
+    private lateinit var root: Root
+
+    @BeforeEach
+    fun resetTestData() {
+        innerNode = TreeNode()
+        someOtherInnerNode = TreeNode()
+        root = Root(innerNode, someOtherInnerNode)
+    }
+
+    @Test
+    fun `constructor should correctly link initial value`() {
+        innerNode.parent shouldBe root
+        innerNode.container shouldBe root.child
+        root.child.node shouldBe innerNode
+    }
+
+    @Test
+    fun `setter should work if a new node is passed`() {
+        root.child.node = root.someOtherChild.node
+
+        innerNode.parent.shouldBeNull()
+        innerNode.container.shouldBeNull()
+        root.child.node shouldBe someOtherInnerNode
+
+        someOtherInnerNode.parent shouldBe root
+        someOtherInnerNode.container shouldBe root.child
+        root.someOtherChild.node.shouldBeNull()
+    }
+
+    @Test
+    fun `setter should work if null is passed`() {
+        root.child.node = null
+
+        innerNode.parent.shouldBeNull()
+        innerNode.container.shouldBeNull()
+        root.child.node.shouldBeNull()
+    }
+
+    @Test
+    fun `setter should not recurse infinitely if the same value is passed`() {
+        shouldCompleteWithin(1, TimeUnit.SECONDS) {
+            shouldNotThrowUnit<StackOverflowError> {
+                root.child.node = root.child.node
+            }
+        }
+    }
+
+    @Test
+    fun `releaseNode should remove links if a node is passed that is referenced`() {
+        root.child.releaseNode(innerNode)
+
+        innerNode.parent.shouldBeNull()
+        innerNode.container.shouldBeNull()
+        root.child.node.shouldBeNull()
+    }
+
+    @Test
+    fun `releaseNode should do nothing if a node is passed that is not referenced`() {
+        root.child.releaseNode(someOtherInnerNode)
+
+        innerNode.parent shouldBe root
+        innerNode.container shouldBe root.child
+        root.child.node shouldBe innerNode
+
+        someOtherInnerNode.parent shouldBe root
+        someOtherInnerNode.container shouldBe root.someOtherChild
+        root.someOtherChild.node shouldBe someOtherInnerNode
+    }
+}
diff --git a/server/src/test/kotlin/com/larsreimann/api_editor/mutable_model/TreeNodeTest.kt b/server/src/test/kotlin/com/larsreimann/api_editor/mutable_model/TreeNodeTest.kt
new file mode 100644
index 000000000..72d910a44
--- /dev/null
+++ b/server/src/test/kotlin/com/larsreimann/api_editor/mutable_model/TreeNodeTest.kt
@@ -0,0 +1,46 @@
+@file:Suppress("UNUSED_VARIABLE", "unused")
+
+package com.larsreimann.api_editor.mutable_model
+
+import io.kotest.matchers.booleans.shouldBeFalse
+import io.kotest.matchers.booleans.shouldBeTrue
+import io.kotest.matchers.nulls.shouldBeNull
+import io.kotest.matchers.sequences.shouldBeEmpty
+import org.junit.jupiter.api.Test
+
+class TreeNodeTest {
+
+    @Test
+    fun `isRoot() should be true by default`() {
+        TreeNode().isRoot().shouldBeTrue()
+    }
+
+    @Test
+    fun `isRoot() should indicate whether the node has a parent`() {
+        val innerNode = TreeNode()
+        val root = object : TreeNode() {
+            val child = ContainmentReference(innerNode)
+        }
+
+        innerNode.isRoot().shouldBeFalse()
+        root.isRoot().shouldBeTrue()
+    }
+
+    @Test
+    fun `children() should be empty by default`() {
+        TreeNode().children().shouldBeEmpty()
+    }
+
+    @Test
+    fun `release() should set parent and container to null`() {
+        val innerNode = TreeNode()
+        val root = object : TreeNode() {
+            val child = ContainmentReference(innerNode)
+        }
+
+        innerNode.release()
+
+        innerNode.parent.shouldBeNull()
+        innerNode.container.shouldBeNull()
+    }
+}
diff --git a/server/src/test/kotlin/com/larsreimann/api_editor/mutable_model/TreeNodeTraversalTest.kt b/server/src/test/kotlin/com/larsreimann/api_editor/mutable_model/TreeNodeTraversalTest.kt
new file mode 100644
index 000000000..8aa3a6b57
--- /dev/null
+++ b/server/src/test/kotlin/com/larsreimann/api_editor/mutable_model/TreeNodeTraversalTest.kt
@@ -0,0 +1,110 @@
+package com.larsreimann.api_editor.mutable_model
+
+import io.kotest.matchers.collections.shouldContainExactly
+import io.kotest.matchers.shouldBe
+import org.junit.jupiter.api.BeforeEach
+import org.junit.jupiter.api.Test
+
+class TreeNodeTraversalTest {
+
+    private class Root(children: List<TreeNode>) : TreeNode() {
+        val children = ContainmentList(children)
+
+        override fun children(): Sequence<TreeNode> {
+            return children.asSequence()
+        }
+    }
+
+    private class InnerNode(child: TreeNode) : TreeNode() {
+        val child by ContainmentReference(child)
+
+        override fun children() = sequence {
+            child?.let { yield(it) }
+        }
+    }
+
+    private lateinit var leaf1: TreeNode
+    private lateinit var leaf2: TreeNode
+    private lateinit var leaf3: TreeNode
+    private lateinit var inner: InnerNode
+    private lateinit var root: Root
+
+    @BeforeEach
+    fun resetTestData() {
+        leaf1 = TreeNode()
+        leaf2 = TreeNode()
+        leaf3 = TreeNode()
+        inner = InnerNode(leaf1)
+        root = Root(listOf(inner, leaf2, leaf3))
+    }
+
+    @Test
+    fun `root() should return the node itself for the root`() {
+        root.root() shouldBe root
+    }
+
+    @Test
+    fun `root() should return the root for an inner node`() {
+        leaf1.root() shouldBe root
+    }
+
+    @Test
+    fun `ancestor() should return all nodes along the path to the root`() {
+        leaf1.ancestors().toList().shouldContainExactly(inner, root)
+    }
+
+    @Test
+    fun `ancestorOrSelf() should return the node and all nodes along the path to the root`() {
+        leaf1.ancestorsOrSelf().toList().shouldContainExactly(leaf1, inner, root)
+    }
+
+    @Test
+    fun `siblings() should return the siblings of the node`() {
+        inner.siblings().toList().shouldContainExactly(leaf2, leaf3)
+    }
+
+    @Test
+    fun `siblingsOrSelf() should return all children of the parent`() {
+        inner.siblingsOrSelf().toList().shouldContainExactly(inner, leaf2, leaf3)
+    }
+
+    @Test
+    fun `descendant(PREORDER) should return all nodes below of the node in preorder`() {
+        root.descendants(Traversal.PREORDER).toList().shouldContainExactly(inner, leaf1, leaf2, leaf3)
+    }
+
+    @Test
+    fun `descendant(POSTORDER) should return all nodes below of the node in postorder`() {
+        root.descendants(Traversal.POSTORDER).toList().shouldContainExactly(leaf1, inner, leaf2, leaf3)
+    }
+
+    @Test
+    fun `descendant() should prune nodes if a filter is passed`() {
+        root.descendants { it !is InnerNode }.toList().shouldContainExactly(leaf2, leaf3)
+    }
+
+    @Test
+    fun `descendantOrSelf(PREORDER) should return the node and all nodes below it in preorder`() {
+        root.descendantsOrSelf(Traversal.PREORDER).toList().shouldContainExactly(root, inner, leaf1, leaf2, leaf3)
+    }
+
+    @Test
+    fun `descendantOrSelf(POSTORDER) should return the node and all nodes below it in postorder`() {
+        root.descendantsOrSelf(Traversal.POSTORDER).toList().shouldContainExactly(leaf1, inner, leaf2, leaf3, root)
+    }
+
+    @Test
+    fun `descendantOrSelf() should prune nodes if a filter is passed`() {
+        root.descendantsOrSelf { it !is InnerNode }.toList().shouldContainExactly(root, leaf2, leaf3)
+    }
+
+    @Test
+    fun `closest() should return the node itself if has the correct type`() {
+        inner.closest<InnerNode>() shouldBe inner
+    }
+
+    @Test
+    fun `closest() should return the first node with the correct type along the path to the root`() {
+        leaf1.closest<InnerNode>() shouldBe inner
+    }
+}