diff --git a/Sources/Composed/Core/Section.swift b/Sources/Composed/Core/Section.swift
index d240971..2524b29 100644
--- a/Sources/Composed/Core/Section.swift
+++ b/Sources/Composed/Core/Section.swift
@@ -82,4 +82,13 @@ public protocol SectionUpdateDelegate: class {
     ///   - destinationIndex: The final index where the element will be moved to
     func section(_ section: Section, move sourceIndex: Int, to destinationIndex: Int)
 
+    /// Notifies the delegate that the section invalidated its header.
+    /// - Parameters:
+    ///   - section: The section that invalidated its header.
+    func sectionDidInvalidateHeader(_ section: Section)
+
+    /// Notifies the delegate that the section invalidated its footer.
+    /// - Parameters:
+    ///   - section: The section that invalidated its footer.
+    func sectionDidInvalidateFooter(_ section: Section)
 }
diff --git a/Sources/Composed/Core/SectionProviderMapping.swift b/Sources/Composed/Core/SectionProviderMapping.swift
index 303fab4..d3eaa11 100644
--- a/Sources/Composed/Core/SectionProviderMapping.swift
+++ b/Sources/Composed/Core/SectionProviderMapping.swift
@@ -82,6 +82,16 @@ public protocol SectionProviderMappingDelegate: class {
     ///   - destinationIndexPath: The final indexPath
     func mapping(_ mapping: SectionProviderMapping, move sourceIndexPath: IndexPath, to destinationIndexPath: IndexPath)
 
+    /// Notifies the delegate that the section invalidated its header.
+    /// - Parameters:
+    ///   - sectionIndex: The index of the section that invalidated its header.
+    func mappingDidInvalidateHeader(at sectionIndex: Int)
+
+    /// Notifies the delegate that the section invalidated its footer.
+    /// - Parameters:
+    ///   - sectionIndex: The index of the section that invalidated its footer.
+    func mappingDidInvalidateFooter(at sectionIndex: Int)
+
 }
 
 /// An object that encapsulates the logic required to map `SectionProvider`s to a global context,
@@ -229,6 +239,16 @@ public final class SectionProviderMapping: SectionProviderUpdateDelegate, Sectio
         delegate?.mapping(self, didMoveElementsAt: [(source, destination)])
     }
 
+    public func sectionDidInvalidateHeader(_ section: Section) {
+        guard let sectionOffset = self.sectionOffset(of: section) else { return }
+        delegate?.mappingDidInvalidateHeader(at: sectionOffset)
+    }
+
+    public func sectionDidInvalidateFooter(_ section: Section) {
+        guard let sectionOffset = self.sectionOffset(of: section) else { return }
+        delegate?.mappingDidInvalidateFooter(at: sectionOffset)
+    }
+
     // Rebuilds the cached providers to improve lookup performance.
     // This is generally only required when a sections are either inserted or removed, so it should be fairly efficient.
     private func rebuildSectionOffsets() {
diff --git a/Sources/Composed/Sections/FlatSection+SelectionHandler.swift b/Sources/Composed/Sections/FlatSection+SelectionHandler.swift
new file mode 100644
index 0000000..44502a6
--- /dev/null
+++ b/Sources/Composed/Sections/FlatSection+SelectionHandler.swift
@@ -0,0 +1,105 @@
+extension FlatSection: SelectionHandler {
+    public final var selectionHandlingSections: [SelectionHandler] {
+        sections.compactMap { $0 as? SelectionHandler }
+    }
+
+    open var allowsMultipleSelection: Bool {
+        let selectionHandlingSection = sections.compactMap { $0 as? SelectionHandler }
+        if selectionHandlingSection.isEmpty {
+            return false
+        } else if selectionHandlingSection.count == 1 {
+            return selectionHandlingSection.first!.allowsMultipleSelection
+        } else {
+            return true
+        }
+    }
+
+    /// Returns all element indexes that are currently selected
+    open var selectedIndexes: [Int] {
+        return sections.flatMap { section -> [Int] in
+            guard let section = section as? SelectionHandler else { return [] }
+            let offset = self.indexForFirstElement(of: section)!
+            return section.selectedIndexes.map { $0 + offset }
+        }
+    }
+
+    /// When a highlight is attempted, this method will be called giving the caller a chance to prevent it
+    /// - Parameter index: The element index
+    open func shouldHighlight(at index: Int) -> Bool {
+        guard let sectionMeta = self.sectionForElementIndex(index) else { return false }
+        guard let section = sectionMeta.section as? SelectionHandler else { return false }
+
+        let sectionIndex = index - sectionMeta.offset
+        return section.shouldHighlight(at: sectionIndex)
+    }
+
+    /// When a selection is attempted, this method will be called giving the caller a chance to prevent it
+    /// - Parameter index: The element index
+    open func shouldSelect(at index: Int) -> Bool {
+        guard let sectionMeta = self.sectionForElementIndex(index) else { return false }
+        guard let section = sectionMeta.section as? SelectionHandler else { return false }
+
+        let sectionIndex = index - sectionMeta.offset
+        return section.shouldSelect(at: sectionIndex)
+    }
+
+    /// When a selection occurs, this method will be called to notify the section
+    /// - Parameter index: The element index
+    open func didSelect(at index: Int) {
+        guard let sectionMeta = self.sectionForElementIndex(index) else { return }
+        guard let section = sectionMeta.section as? SelectionHandler else { return }
+
+        let sectionIndex = index - sectionMeta.offset
+        section.didSelect(at: sectionIndex)
+    }
+
+    /// When a deselection is attempted, this method will be called giving the caller a chance to prevent it
+    /// - Parameter index: The element index
+    open func shouldDeselect(at index: Int) -> Bool {
+        guard let sectionMeta = self.sectionForElementIndex(index) else { return false }
+        guard let section = sectionMeta.section as? SelectionHandler else { return false }
+
+        let sectionIndex = index - sectionMeta.offset
+        return section.shouldDeselect(at: sectionIndex)
+    }
+
+    /// When a deselection occurs, this method will be called to notify the section
+    /// - Parameter index: The element index
+    open func didDeselect(at index: Int) {
+        guard let sectionMeta = self.sectionForElementIndex(index) else { return }
+        guard let section = sectionMeta.section as? SelectionHandler else { return }
+
+        let sectionIndex = index - sectionMeta.offset
+        return section.didDeselect(at: sectionIndex)
+    }
+
+    /// Selects the element at the specified index
+    /// - Parameter index: The element index
+    open func select(index: Int) {
+        guard let sectionMeta = self.sectionForElementIndex(index) else { return }
+        guard let section = sectionMeta.section as? SelectionHandler else { return }
+
+        let sectionIndex = index - sectionMeta.offset
+        section.select(index: sectionIndex)
+    }
+
+    /// Deselects the element at the specified index
+    /// - Parameter index: The element index
+    open func deselect(index: Int) {
+        guard let sectionMeta = self.sectionForElementIndex(index) else { return }
+        guard let section = sectionMeta.section as? SelectionHandler else { return }
+
+        let sectionIndex = index - sectionMeta.offset
+        section.deselect(index: sectionIndex)
+    }
+
+    /// Selects all elements in this section
+    open func selectAll() {
+        selectionHandlingSections.forEach { $0.selectAll() }
+    }
+
+    /// Deselects all elements in this section
+    open func deselectAll() {
+        selectionHandlingSections.forEach { $0.deselectAll() }
+    }
+}
diff --git a/Sources/Composed/Sections/FlatSection.swift b/Sources/Composed/Sections/FlatSection.swift
new file mode 100644
index 0000000..e51b5f8
--- /dev/null
+++ b/Sources/Composed/Sections/FlatSection.swift
@@ -0,0 +1,433 @@
+import Foundation
+
+/// A section that flattens each of its children in to a single section.
+open class FlatSection: Section, CustomReflectable {
+    private enum Child {
+        /// A single section.
+        case section(Section)
+
+        /// An object that provides 0 or more sections.
+        case sectionProvider(SectionProvider)
+    }
+
+    public private(set) var sections: ContiguousArray<Section> = []
+
+    public var numberOfElements: Int {
+        sections.map(\.numberOfElements).reduce(0, +)
+    }
+
+    public weak var updateDelegate: SectionUpdateDelegate?
+
+    public var customMirror: Mirror {
+        Mirror(
+            self,
+            children: [
+                "children": children,
+            ]
+        )
+    }
+
+    private var children: [Child] = []
+
+    public init() {}
+
+    public func append(_ section: Section) {
+        updateDelegate?.willBeginUpdating(self)
+
+        let indexOfFirstChildElement = numberOfElements
+        children.append(.section(section))
+        sections.append(section)
+        section.updateDelegate = self
+
+        (0..<section.numberOfElements)
+            .map { $0 + indexOfFirstChildElement }
+            .forEach { index in
+                updateDelegate?.section(self, didInsertElementAt: index)
+            }
+
+        updateDelegate?.didEndUpdating(self)
+    }
+
+    public func append(_ sectionProvider: SectionProvider) {
+        updateDelegate?.willBeginUpdating(self)
+
+        var indexOfFirstSectionElement = numberOfElements
+
+        children.append(.sectionProvider(sectionProvider))
+        sections.append(contentsOf: sectionProvider.sections)
+
+        sectionProvider.sections.forEach { section in
+            section.updateDelegate = self
+
+            (0..<section.numberOfElements)
+                .map { $0 + indexOfFirstSectionElement }
+                .forEach { index in
+                    updateDelegate?.section(self, didInsertElementAt: index)
+                }
+
+            indexOfFirstSectionElement += section.numberOfElements
+        }
+
+        sectionProvider.updateDelegate = self
+
+        updateDelegate?.didEndUpdating(self)
+    }
+
+    public func insert(_ section: Section, at childIndex: Int) {
+        updateDelegate?.willBeginUpdating(self)
+
+        let elementOffset: Int = {
+            if childIndex == 0 {
+                return 0
+            } else if childIndex == children.count {
+                return self.numberOfElements
+            }
+
+            let childAtInsertedSection = children[childIndex]
+            return indexForFirstElement(of: childAtInsertedSection)!
+        }()
+
+        let indexInSectionArray = (0..<childIndex).map { children[$0] }.reduce(into: 0) { index, child in
+            switch child {
+            case .section:
+                index += 1
+            case .sectionProvider(let sectionProvider):
+                index += sectionProvider.numberOfSections
+            }
+        }
+
+        sections.insert(section, at: indexInSectionArray)
+        children.insert(.section(section), at: childIndex)
+        section.updateDelegate = self
+
+        (0..<section.numberOfElements)
+            .map { $0 + elementOffset }
+            .forEach { index in
+                updateDelegate?.section(self, didInsertElementAt: index)
+            }
+
+        updateDelegate?.didEndUpdating(self)
+    }
+
+    public func insert(_ section: Section, after existingSection: Section) {
+        guard let existingSectionIndex = childIndex(of: existingSection) else { return }
+
+        insert(section, at: existingSectionIndex + 1)
+    }
+
+    public func remove(_ section: Section) {
+        guard let childIndex = childIndex(of: section) else { return }
+
+        updateDelegate?.willBeginUpdating(self)
+
+        let sectionOffset = indexForFirstElement(of: section)!
+        children.remove(at: childIndex)
+        sections = sections.filter { $0 !== section }
+        if section.updateDelegate === self {
+            section.updateDelegate = nil
+        }
+
+        (0..<section.numberOfElements).reversed().forEach { index in
+            updateDelegate?.section(self, didRemoveElementAt: index + sectionOffset)
+        }
+
+        updateDelegate?.didEndUpdating(self)
+    }
+
+    public func remove(_ sectionProvider: SectionProvider) {
+        guard let childIndex = self.childIndex(of: sectionProvider) else { return }
+
+        updateDelegate?.willBeginUpdating(self)
+        sectionProvider.sections.reversed().forEach { section in
+            section.updateDelegate = nil
+
+            let sectionOffset = indexForFirstElement(of: section)!
+            sections = sections.filter { $0 !== section }
+
+            (0..<section.numberOfElements).reversed().forEach { index in
+                updateDelegate?.section(self, didRemoveElementAt: index + sectionOffset)
+            }
+        }
+        if sectionProvider.updateDelegate === self {
+            sectionProvider.updateDelegate = nil
+        }
+
+        children.remove(at: childIndex)
+
+        updateDelegate?.didEndUpdating(self)
+    }
+
+    public func sectionForElementIndex(_ index: Int) -> (section: Section, offset: Int)? {
+        var offset = 0
+
+        for child in children {
+            switch child {
+            case .section(let section):
+                if !section.isEmpty, offset == index {
+                    return (section, offset)
+                } else if index < offset + section.numberOfElements {
+                    return (section, offset)
+                }
+
+                offset += section.numberOfElements
+            case .sectionProvider(let sectionProvider):
+                for section in sectionProvider.sections {
+                    if !section.isEmpty, offset == index {
+                        return (section, offset)
+                    } else if index < offset + section.numberOfElements {
+                        return (section, offset)
+                    }
+
+                    offset += section.numberOfElements
+                }
+            }
+        }
+
+        return nil
+    }
+
+    public final func indexForFirstElement(of section: Section) -> Int? {
+        var offset = 0
+
+        for childSection in sections {
+            if childSection === section {
+                return offset
+            }
+
+            offset += childSection.numberOfElements
+        }
+
+        return nil
+    }
+
+    public final func indexForFirstElement(of sectionProvider: SectionProvider) -> Int? {
+        var offset = 0
+
+        for child in children {
+            switch child {
+            case .section(let section):
+                offset += section.numberOfElements
+            case .sectionProvider(let childSectionProvider):
+                if childSectionProvider === sectionProvider {
+                    return offset
+                } else if let aggregate = childSectionProvider as? AggregateSectionProvider, let sectionOffset = aggregate.sectionOffset(for: sectionProvider) {
+                    return childSectionProvider.sections[0..<sectionOffset].reduce(into: offset, { $0 += $1.numberOfElements })
+                }
+
+                offset += childSectionProvider.sections.reduce(into: 0, { $0 += $1.numberOfElements })
+            }
+        }
+
+        return nil
+    }
+
+    public final func indexesRange(for section: Section) -> Range<Int>? {
+        guard let sectionOffset = indexForFirstElement(of: section) else { return nil }
+        return (sectionOffset..<sectionOffset + section.numberOfElements)
+    }
+
+    public final func childIndex(of section: Section) -> Int? {
+        var index = 0
+
+        for child in children {
+            switch child {
+            case .section(let childSection):
+                if childSection === section {
+                    return index
+                }
+            case .sectionProvider:
+                break
+            }
+
+            index += 1
+        }
+
+        return nil
+    }
+
+    public final func childIndex(of sectionProvider: SectionProvider) -> Int? {
+        var index = 0
+
+        for child in children {
+            switch child {
+            case .section:
+                break
+            case .sectionProvider(let childSectionProvider):
+                if childSectionProvider === sectionProvider {
+                    return index
+                }
+            }
+
+            index += 1
+        }
+
+        return nil
+    }
+
+    private func indexForFirstElement(of child: Child) -> Int? {
+        switch child {
+        case .section(let childSection):
+            return indexForFirstElement(of: childSection)
+        case .sectionProvider(let sectionProvider):
+            return indexForFirstElement(of: sectionProvider)
+        }
+    }
+
+    /// The index of the first section of `sectionProvider` in the `sections` array.
+    ///
+    /// - parameter sectionProvider: The section provider to calculate the section index of.
+    /// - returns: The index of the first section of `sectionProvider` in the `sections` array, or `nil` if it is not in the hierarchy.
+    private func sectionIndex(of sectionProvider: SectionProvider) -> Int? {
+        var index = 0
+
+        for child in children {
+            switch child {
+            case .section:
+                index += 1
+            case .sectionProvider(let childSectionProvider):
+                if childSectionProvider === sectionProvider {
+                    return index
+                } else if let aggregate = childSectionProvider as? AggregateSectionProvider, let offset = aggregate.sectionOffset(for: sectionProvider) {
+                    return index + offset
+                }
+
+                index += childSectionProvider.numberOfSections
+            }
+        }
+
+        return nil
+    }
+}
+
+extension FlatSection: SectionUpdateDelegate {
+    public func willBeginUpdating(_ section: Section) {
+        updateDelegate?.willBeginUpdating(self)
+    }
+
+    public func didEndUpdating(_ section: Section) {
+        updateDelegate?.didEndUpdating(self)
+    }
+
+    public func invalidateAll(_ section: Section) {
+        updateDelegate?.invalidateAll(self)
+    }
+
+    public func section(_ section: Section, didInsertElementAt index: Int) {
+        guard let sectionOffset = indexForFirstElement(of: section) else { return }
+        updateDelegate?.section(self, didInsertElementAt: sectionOffset + index)
+    }
+
+    public func section(_ section: Section, didRemoveElementAt index: Int) {
+        guard let sectionOffset = indexForFirstElement(of: section) else { return }
+        updateDelegate?.section(self, didRemoveElementAt: sectionOffset + index)
+    }
+
+    public func section(_ section: Section, didUpdateElementAt index: Int) {
+        guard let sectionOffset = indexForFirstElement(of: section) else { return }
+        updateDelegate?.section(self, didUpdateElementAt: sectionOffset + index)
+    }
+
+    public func section(_ section: Section, didMoveElementAt index: Int, to newIndex: Int) {
+        guard let sectionOffset = indexForFirstElement(of: section) else { return }
+        updateDelegate?.section(self, didMoveElementAt: sectionOffset + index, to: newIndex + index)
+    }
+
+    public func selectedIndexes(in section: Section) -> [Int] {
+        guard let allSelectedIndexes = updateDelegate?.selectedIndexes(in: self) else { return [] }
+        guard let sectionIndexes = indexesRange(for: section) else { return [] }
+
+        return allSelectedIndexes
+            .filter(sectionIndexes.contains(_:))
+            .map { $0 - sectionIndexes.startIndex }
+    }
+
+    public func section(_ section: Section, select index: Int) {
+        guard let sectionOffset = indexForFirstElement(of: section) else { return }
+        updateDelegate?.section(self, select: sectionOffset + index)
+    }
+
+    public func section(_ section: Section, deselect index: Int) {
+        guard let sectionOffset = indexForFirstElement(of: section) else { return }
+        updateDelegate?.section(self, deselect: sectionOffset + index)
+    }
+
+    public func section(_ section: Section, move sourceIndex: Int, to destinationIndex: Int) {
+        guard let sectionOffset = indexForFirstElement(of: section) else { return }
+        updateDelegate?.section(self, move: sourceIndex + sectionOffset, to: destinationIndex + sectionOffset)
+    }
+
+    public func sectionDidInvalidateHeader(_ section: Section) {
+        // Headers of children are currently ignored.
+    }
+
+    public func sectionDidInvalidateFooter(_ section: Section) {
+        // Footers of children are currently ignored.
+    }
+}
+
+extension FlatSection: SectionProviderUpdateDelegate {
+    public func willBeginUpdating(_ provider: SectionProvider) {
+        updateDelegate?.willBeginUpdating(self)
+    }
+
+    public func didEndUpdating(_ provider: SectionProvider) {
+        updateDelegate?.didEndUpdating(self)
+    }
+
+    public func invalidateAll(_ provider: SectionProvider) {
+        sections = ContiguousArray(children.flatMap { child -> [Section] in
+            switch child {
+            case .section(let section):
+                return [section]
+            case .sectionProvider(let sectionProvider):
+                return sectionProvider.sections
+            }
+        })
+        updateDelegate?.invalidateAll(self)
+    }
+
+    public func provider(_ provider: SectionProvider, didInsertSections sections: [Section], at indexes: IndexSet) {
+        guard let providerSectionIndex = sectionIndex(of: provider) else {
+            assertionFailure(#function + " has been called for a provider that is not a child")
+            return
+        }
+
+        updateDelegate?.willBeginUpdating(self)
+
+        for (section, index) in zip(sections, indexes) {
+            section.updateDelegate = self
+
+            let sectionIndex = index + providerSectionIndex
+            self.sections.insert(section, at: sectionIndex)
+            let firstSectionIndex = self.indexForFirstElement(of: section)!
+
+            (firstSectionIndex..<firstSectionIndex + section.numberOfElements).forEach { elementIndex in
+                updateDelegate?.section(self, didInsertElementAt: elementIndex)
+            }
+        }
+
+        updateDelegate?.didEndUpdating(self)
+    }
+
+    public func provider(_ provider: SectionProvider, didRemoveSections sections: [Section], at indexes: IndexSet) {
+        guard let providerSectionIndex = sectionIndex(of: provider) else {
+            assertionFailure(#function + " has been called for a provider that is not a child")
+            return
+        }
+
+        updateDelegate?.willBeginUpdating(self)
+
+        for (section, sectionIndexInProvider) in zip(sections, indexes).reversed() {
+            let localSectionIndex = sectionIndexInProvider + providerSectionIndex
+            let sectionFirstElementIndex = self.indexForFirstElement(of: section)!
+
+            self.sections.remove(at: localSectionIndex)
+
+            (sectionFirstElementIndex..<sectionFirstElementIndex + section.numberOfElements).reversed().forEach { elementIndex in
+                updateDelegate?.section(self, didRemoveElementAt: elementIndex)
+            }
+        }
+
+        updateDelegate?.didEndUpdating(self)
+    }
+}
diff --git a/Sources/ComposedLayouts/CollectionCompositionalLayoutHandler.swift b/Sources/ComposedLayouts/CollectionCompositionalLayoutHandler.swift
index 8b91d37..43f1337 100644
--- a/Sources/ComposedLayouts/CollectionCompositionalLayoutHandler.swift
+++ b/Sources/ComposedLayouts/CollectionCompositionalLayoutHandler.swift
@@ -3,7 +3,7 @@ import ComposedUI
 
 @available(iOS 13.0, *)
 /// Conform your section to this protocol to provide a layout section for a `UICollectionViewCompositionalLayout`
-public protocol CompositionalLayoutHandler: CollectionSectionProvider {
+public protocol CompositionalLayoutHandler: UICollectionViewSection {
 
     /// Return a layout section for this section
     /// - Parameter environment: The current environment for this layout
diff --git a/Sources/ComposedLayouts/CollectionFlowLayoutHandler.swift b/Sources/ComposedLayouts/CollectionFlowLayoutHandler.swift
index 1758453..3f06580 100644
--- a/Sources/ComposedLayouts/CollectionFlowLayoutHandler.swift
+++ b/Sources/ComposedLayouts/CollectionFlowLayoutHandler.swift
@@ -31,7 +31,7 @@ public struct CollectionFlowLayoutEnvironment {
 }
 
 /// Conform your section to this protocol to override sizing and metric values for a `UICollectionViewFlowLayout`
-public protocol CollectionFlowLayoutHandler: CollectionSectionProvider {
+public protocol CollectionFlowLayoutHandler: UICollectionViewSection {
 
     /// Return the size for the element at the specified index
     /// - Parameters:
diff --git a/Sources/ComposedUI/CollectionView/CollectionCoordinator.swift b/Sources/ComposedUI/CollectionView/CollectionCoordinator.swift
index a04ab4f..e5c4673 100644
--- a/Sources/ComposedUI/CollectionView/CollectionCoordinator.swift
+++ b/Sources/ComposedUI/CollectionView/CollectionCoordinator.swift
@@ -64,7 +64,8 @@ open class CollectionCoordinator: NSObject {
     private weak var originalDropDelegate: UICollectionViewDropDelegate?
     private var dropDelegateObserver: NSKeyValueObservation?
 
-    private var cachedProviders: [CollectionElementsProvider] = []
+    private var cachedElementsProviders: [UICollectionViewSectionElementsProvider] = []
+    private var cellSectionMap = [UICollectionViewCell: (CollectionCellElement, Section)]()
     private var nibRegistrations = Set<NIBRegistration>()
 
     /// Make a new coordinator with the specified collectionView and sectionProvider
@@ -153,44 +154,55 @@ open class CollectionCoordinator: NSObject {
     open func invalidateVisibleCells() {
         for (indexPath, cell) in zip(collectionView.indexPathsForVisibleItems, collectionView.visibleCells) {
             let elements = elementsProvider(for: indexPath.section)
-            elements.cell.configure(cell, indexPath.item, mapper.provider.sections[indexPath.section])
+            elements.cell(for: indexPath.item).configure(cell, indexPath.item, mapper.provider.sections[indexPath.section])
         }
     }
 
     // Prepares and caches the section to improve performance
     private func prepareSections() {
-        cachedProviders.removeAll()
+        cachedElementsProviders.removeAll()
         mapper.delegate = self
 
         for index in 0..<mapper.numberOfSections {
-            guard let section = (mapper.provider.sections[index] as? CollectionSectionProvider)?.section(with: collectionView.traitCollection) else {
+            guard let section = mapper.provider.sections[index] as? UICollectionViewSection else {
                 fatalError("No provider available for section: \(index), or it does not conform to CollectionSectionProvider")
             }
 
-            switch section.cell.dequeueMethod {
-            case let .fromNib(type):
-                // `UINib(nibName:bundle:)` is an expensive call because it reads the NIB from the
-                // disk, which can have a large impact on performance when this is called multiple times.
-                //
-                // Each registration is cached to ensure that the same nib is not read from disk multiple times.
+            let elementsProvider = section.collectionViewElementsProvider(with: collectionView.traitCollection)
+            let cells = (0..<section.numberOfElements).reduce(into: [CollectionCellElement](), { cells, index in
+                let cell = elementsProvider.cell(for: index)
 
-                let nibName = String(describing: type)
-                let nibBundle = Bundle(for: type)
-                let nibRegistration = NIBRegistration(nibName: nibName, bundle: nibBundle, reuseIdentifier: section.cell.reuseIdentifier)
+                guard !cells.contains(where: { $0.reuseIdentifier == cell.reuseIdentifier }) else { return }
 
-                guard !nibRegistrations.contains(nibRegistration) else { break }
+                cells.append(cell)
+            })
 
-                let nib = UINib(nibName: nibName, bundle: nibBundle)
-                collectionView.register(nib, forCellWithReuseIdentifier: section.cell.reuseIdentifier)
-                nibRegistrations.insert(nibRegistration)
-            case let .fromClass(type):
-                collectionView.register(type, forCellWithReuseIdentifier: section.cell.reuseIdentifier)
-            case .fromStoryboard:
-                break
+            for cell in cells {
+                switch cell.dequeueMethod.method {
+                case let .fromNib(type):
+                    // `UINib(nibName:bundle:)` is an expensive call because it reads the NIB from the
+                    // disk, which can have a large impact on performance when this is called multiple times.
+                    //
+                    // Each registration is cached to ensure that the same nib is not read from disk multiple times.
+
+                    let nibName = String(describing: type)
+                    let nibBundle = Bundle(for: type)
+                    let nibRegistration = NIBRegistration(nibName: nibName, bundle: nibBundle, reuseIdentifier: cell.reuseIdentifier)
+
+                    guard !nibRegistrations.contains(nibRegistration) else { break }
+
+                    let nib = UINib(nibName: nibName, bundle: nibBundle)
+                    collectionView.register(nib, forCellWithReuseIdentifier: cell.reuseIdentifier)
+                    nibRegistrations.insert(nibRegistration)
+                case let .fromClass(type):
+                    collectionView.register(type, forCellWithReuseIdentifier: cell.reuseIdentifier)
+                case .fromStoryboard:
+                    break
+                }
             }
 
-            [section.header, section.footer].compactMap { $0 }.forEach {
-                switch $0.dequeueMethod {
+            [elementsProvider.header, elementsProvider.footer].compactMap { $0 }.forEach {
+                switch $0.dequeueMethod.method {
                 case let .fromNib(type):
                     let nib = UINib(nibName: String(describing: type), bundle: Bundle(for: type))
                     collectionView.register(nib, forSupplementaryViewOfKind: $0.kind.rawValue, withReuseIdentifier: $0.reuseIdentifier)
@@ -201,7 +213,7 @@ open class CollectionCoordinator: NSObject {
                 }
             }
 
-            cachedProviders.append(section)
+            cachedElementsProviders.append(elementsProvider)
         }
 
         collectionView.allowsMultipleSelection = true
@@ -331,7 +343,7 @@ extension CollectionCoordinator: SectionProviderMappingDelegate {
                         continue
                 }
 
-                self.cachedProviders[indexPath.section].cell.configure(cell, indexPath.item, self.mapper.provider.sections[indexPath.section])
+                self.cachedElementsProviders[indexPath.section].cell(for: indexPath.item).configure(cell, indexPath.item, self.mapper.provider.sections[indexPath.section])
             }
 
             guard !indexPathsToReload.isEmpty else { return }
@@ -376,6 +388,62 @@ extension CollectionCoordinator: SectionProviderMappingDelegate {
         collectionView.moveItem(at: sourceIndexPath, to: destinationIndexPath)
     }
 
+    public func mappingDidInvalidateHeader(at sectionIndex: Int) {
+        let elementsProvider = self.elementsProvider(for: sectionIndex)
+
+        if let header = elementsProvider.header {
+            switch header.dequeueMethod.method {
+            case let .fromNib(type):
+                let nib = UINib(nibName: String(describing: type), bundle: Bundle(for: type))
+                collectionView.register(nib, forSupplementaryViewOfKind: header.kind.rawValue, withReuseIdentifier: header.reuseIdentifier)
+            case let .fromClass(type):
+                collectionView.register(type, forSupplementaryViewOfKind: header.kind.rawValue, withReuseIdentifier: header.reuseIdentifier)
+            case .fromStoryboard:
+                break
+            }
+        }
+
+        let context = UICollectionViewFlowLayoutInvalidationContext()
+        context.invalidateSupplementaryElements(ofKind: UICollectionView.elementKindSectionHeader, at: [IndexPath(item: 0, section: sectionIndex)])
+        invalidateLayout(with: context)
+
+        guard let headerView = collectionView.supplementaryView(forElementKind: UICollectionView.elementKindSectionHeader, at: IndexPath(item: 0, section: sectionIndex)) else { return }
+
+        let section = mapper.provider.sections[sectionIndex]
+
+        if let header = elementsProvider.header, header.kind.rawValue == UICollectionView.elementKindSectionHeader {
+            header.configure(headerView, sectionIndex, section)
+        }
+    }
+
+    public func mappingDidInvalidateFooter(at sectionIndex: Int) {
+        let elementsProvider = self.elementsProvider(for: sectionIndex)
+
+        if let footer = elementsProvider.footer {
+            switch footer.dequeueMethod.method {
+            case let .fromNib(type):
+                let nib = UINib(nibName: String(describing: type), bundle: Bundle(for: type))
+                collectionView.register(nib, forSupplementaryViewOfKind: footer.kind.rawValue, withReuseIdentifier: footer.reuseIdentifier)
+            case let .fromClass(type):
+                collectionView.register(type, forSupplementaryViewOfKind: footer.kind.rawValue, withReuseIdentifier: footer.reuseIdentifier)
+            case .fromStoryboard:
+                break
+            }
+        }
+
+        let context = UICollectionViewFlowLayoutInvalidationContext()
+        context.invalidateSupplementaryElements(ofKind: UICollectionView.elementKindSectionFooter, at: [IndexPath(item: 0, section: sectionIndex)])
+        invalidateLayout(with: context)
+
+        guard let footerView = collectionView.supplementaryView(forElementKind: UICollectionView.elementKindSectionFooter, at: IndexPath(item: 0, section: sectionIndex)) else { return }
+
+        let section = mapper.provider.sections[sectionIndex]
+
+        if let footer = elementsProvider.footer, footer.kind.rawValue == UICollectionView.elementKindSectionFooter {
+            footer.configure(footerView, sectionIndex, section)
+        }
+    }
+
 }
 
 // MARK: - UICollectionViewDataSource
@@ -398,7 +466,7 @@ extension CollectionCoordinator: UICollectionViewDataSource {
 
         let elements = elementsProvider(for: indexPath.section)
         let section = mapper.provider.sections[indexPath.section]
-        elements.cell.willAppear(cell, indexPath.item, section)
+        elements.cell(for: indexPath.item).willAppear?(cell, indexPath.item, section)
     }
 
     public func collectionView(_ collectionView: UICollectionView, didEndDisplaying cell: UICollectionViewCell, forItemAt indexPath: IndexPath) {
@@ -406,17 +474,17 @@ extension CollectionCoordinator: UICollectionViewDataSource {
         defer {
             originalDelegate?.collectionView?(collectionView, didEndDisplaying: cell, forItemAt: indexPath)
         }
-
-        guard indexPath.section < sectionProvider.numberOfSections else { return }
-        let elements = elementsProvider(for: indexPath.section)
-        let section = mapper.provider.sections[indexPath.section]
-        elements.cell.didDisappear(cell, indexPath.item, section)
+        if let (cellElement, section) = cellSectionMap[cell] {
+            cellElement.didDisappear?(cell, indexPath.item, section)
+	        cellSectionMap.removeValue(forKey: cell)
+        }
     }
 
     public func collectionView(_ collectionView: UICollectionView, cellForItemAt indexPath: IndexPath) -> UICollectionViewCell {
         assert(Thread.isMainThread)
         let elements = elementsProvider(for: indexPath.section)
-        let cell = collectionView.dequeueReusableCell(withReuseIdentifier: elements.cell.reuseIdentifier, for: indexPath)
+        let cellElement = elements.cell(for: indexPath.item)
+        let cell = collectionView.dequeueReusableCell(withReuseIdentifier: cellElement.reuseIdentifier, for: indexPath)
 
         if let handler = sectionProvider.sections[indexPath.section] as? EditingHandler {
             if let handler = sectionProvider.sections[indexPath.section] as? CollectionEditingHandler {
@@ -426,7 +494,9 @@ extension CollectionCoordinator: UICollectionViewDataSource {
             }
         }
 
-        elements.cell.configure(cell, indexPath.item, mapper.provider.sections[indexPath.section])
+        let section = mapper.provider.sections[indexPath.section]
+        cellSectionMap[cell] = (cellElement, section)
+        cellElement.configure(cell, indexPath.item, section)
         return cell
     }
 
@@ -436,14 +506,17 @@ extension CollectionCoordinator: UICollectionViewDataSource {
             originalDelegate?.collectionView?(collectionView, willDisplaySupplementaryView: view, forElementKind: elementKind, at: indexPath)
         }
 
-        guard indexPath.section > sectionProvider.numberOfSections else { return }
+        guard indexPath.section < sectionProvider.numberOfSections else { return }
+
         let elements = elementsProvider(for: indexPath.section)
         let section = mapper.provider.sections[indexPath.section]
 
         if let header = elements.header, header.kind.rawValue == elementKind {
-            elements.header?.willAppear?(view, indexPath.section, section)
+            header.willAppear?(view, indexPath.section, section)
+            header.configure(view, indexPath.section, section)
         } else if let footer = elements.footer, footer.kind.rawValue == elementKind {
-            elements.footer?.willAppear?(view, indexPath.section, section)
+            footer.willAppear?(view, indexPath.section, section)
+            footer.configure(view, indexPath.section, section)
         } else {
             // the original delegate can handle this
         }
@@ -465,7 +538,7 @@ extension CollectionCoordinator: UICollectionViewDataSource {
         } else {
             guard let view = originalDataSource?.collectionView?(collectionView, viewForSupplementaryElementOfKind: kind, at: indexPath) else {
                 // when in production its better to return 'something' to prevent crashing
-                assertionFailure("Unsupported supplementary kind: \(kind) at indexPath: \(indexPath). Did you forget to register your header or footer?")
+                assertionFailure("Unsupported supplementary kind: \(kind) at indexPath: \(indexPath). Check if your layout it returning attributes for the supplementary element at \(indexPath)")
                 return collectionView.dequeue(supplementary: PlaceholderSupplementaryView.self, ofKind: PlaceholderSupplementaryView.kind, for: indexPath)
             }
 
@@ -492,11 +565,11 @@ extension CollectionCoordinator: UICollectionViewDataSource {
         }
     }
 
-    private func elementsProvider(for section: Int) -> CollectionElementsProvider {
-        guard cachedProviders.indices.contains(section) else {
+    private func elementsProvider(for section: Int) -> UICollectionViewSectionElementsProvider {
+        guard cachedElementsProviders.indices.contains(section) else {
             fatalError("No UI configuration available for section \(section)")
         }
-        return cachedProviders[section]
+        return cachedElementsProviders[section]
     }
 
 }
diff --git a/Sources/ComposedUI/CollectionView/CollectionElement.swift b/Sources/ComposedUI/CollectionView/CollectionElement.swift
index 7f25546..fbcd116 100644
--- a/Sources/ComposedUI/CollectionView/CollectionElement.swift
+++ b/Sources/ComposedUI/CollectionView/CollectionElement.swift
@@ -20,11 +20,8 @@ public enum CollectionElementKind {
 /// Defines an element used by a `CollectionSection` to provide configurations for a cell, header and/or footer.
 public protocol CollectionElement {
 
-    /// A typealias for representing a `UICollectionReusableView`
-    associatedtype View: UICollectionReusableView
-
     /// The method to use for registering and dequeueing a view for this element
-    var dequeueMethod: DequeueMethod<View> { get }
+    var dequeueMethod: AnyDequeueMethod { get }
 
     /// A closure that will be called whenever the elements view needs to be configured
     var configure: (UICollectionReusableView, Int, Section) -> Void { get }
@@ -32,19 +29,30 @@ public protocol CollectionElement {
     /// The reuseIdentifier to use for this element
     var reuseIdentifier: String { get }
 
+    /// A closure that will be called before the elements view is appeared
+    var willAppear: ((UICollectionReusableView, Int, Section) -> Void)? { get }
+
+    /// A closure that will be called after the elements view has disappeared
+    var didDisappear: ((UICollectionReusableView, Int, Section) -> Void)? { get }
+
+}
+
+extension CollectionElement {
+    public var willAppear: ((UICollectionReusableView, Int, Section) -> Void)? { nil }
+    public var didDisappear: ((UICollectionReusableView, Int, Section) -> Void)? { nil }
 }
 
 /// Defines a cell element to be used by a `CollectionSection` to provide a configuration for a cell
-public final class CollectionCellElement<View>: CollectionElement where View: UICollectionViewCell {
+open class CollectionCellElement: CollectionElement {
 
-    public let dequeueMethod: DequeueMethod<View>
+    public let dequeueMethod: AnyDequeueMethod
     public let configure: (UICollectionReusableView, Int, Section) -> Void
     public let reuseIdentifier: String
 
     /// The closure that will be called before the elements view appears
-    public let willAppear: (UICollectionReusableView, Int, Section) -> Void
+    public let willAppear: ((UICollectionReusableView, Int, Section) -> Void)?
     /// The closure that will be called after the elements view disappears
-    public let didDisappear: (UICollectionReusableView, Int, Section) -> Void
+    public let didDisappear: ((UICollectionReusableView, Int, Section) -> Void)?
 
     /// Makes a new element for representing a cell
     /// - Parameters:
@@ -52,22 +60,46 @@ public final class CollectionCellElement<View>: CollectionElement where View: UI
     ///   - dequeueMethod: The method to use for registering and dequeueing a cell for this element
     ///   - reuseIdentifier: The reuseIdentifier to use for this element
     ///   - configure: A closure that will be called whenever the elements view needs to be configured
-    public init<Section>(section: Section,
+    public init<Section, View: UICollectionViewCell>(section: Section,
                          dequeueMethod: DequeueMethod<View>,
                          reuseIdentifier: String? = nil,
                          configure: @escaping (View, Int, Section) -> Void)
-        where Section: Composed.Section {
-            self.reuseIdentifier = reuseIdentifier ?? View.reuseIdentifier
-            self.dequeueMethod = dequeueMethod
+    where Section: Composed.Section {
+        self.reuseIdentifier = reuseIdentifier ?? View.reuseIdentifier
+        self.dequeueMethod = dequeueMethod.erasedAsAnyDequeueMethod
 
-            // swiftlint:disable force_cast
+        // swiftlint:disable force_cast
+
+        self.configure = { view, index, section in
+            configure(view as! View, index, section as! Section)
+        }
 
-            self.configure = { view, index, section in
-                configure(view as! View, index, section as! Section)
-            }
+        willAppear = nil
+        didDisappear = nil
+    }
+
+    /// Makes a new element for representing a cell
+    /// - Parameters:
+    ///   - section: The section where this element's cell will be shown in
+    ///   - dequeueMethod: The method to use for registering and dequeueing a cell for this element
+    ///   - reuseIdentifier: The reuseIdentifier to use for this element
+    ///   - configure: A closure that will be called whenever the elements view needs to be configured
+    public init<Section, View: UICollectionViewCell>(section: Section,
+                                                     dequeueMethod: AnyDequeueMethod,
+                                                     reuseIdentifier: String? = nil,
+                                                     configure: @escaping (View, Int, Section) -> Void)
+    where Section: Composed.Section {
+        self.reuseIdentifier = reuseIdentifier ?? View.reuseIdentifier
+        self.dequeueMethod = dequeueMethod
+
+        // swiftlint:disable force_cast
+
+        self.configure = { view, index, section in
+            configure(view as! View, index, section as! Section)
+        }
 
-            willAppear = { _, _, _ in }
-            didDisappear = { _, _, _ in }
+        willAppear = nil
+        didDisappear = nil
     }
 
     /// Makes a new element for representing a cell
@@ -78,37 +110,101 @@ public final class CollectionCellElement<View>: CollectionElement where View: UI
     ///   - configure: A closure that will be called whenever the elements view needs to be configured
     ///   - willAppear: A closure that will be called before the elements view appears
     ///   - didDisappear: A closure that will be called after the elements view disappears
-    public init<Section>(section: Section,
+    public init<Section, View: UICollectionViewCell>(section: Section,
                          dequeueMethod: DequeueMethod<View>,
                          reuseIdentifier: String? = nil,
                          configure: @escaping (View, Int, Section) -> Void,
                          willAppear: ((View, Int, Section) -> Void)? = nil,
                          didDisappear: ((View, Int, Section) -> Void)? = nil)
-        where Section: Composed.Section {
-            self.reuseIdentifier = reuseIdentifier ?? View.reuseIdentifier
-            self.dequeueMethod = dequeueMethod
+    where Section: Composed.Section {
+        self.reuseIdentifier = reuseIdentifier ?? View.reuseIdentifier
+        self.dequeueMethod = dequeueMethod.erasedAsAnyDequeueMethod
 
-            // swiftlint:disable force_cast
+        // swiftlint:disable force_cast
+
+        self.configure = { view, index, section in
+            configure(view as! View, index, section as! Section)
+        }
 
-            self.configure = { view, index, section in
-                configure(view as! View, index, section as! Section)
-            }
+        self.willAppear = { view, index, section in
+            willAppear?(view as! View, index, section as! Section)
+        }
+
+        self.didDisappear = { view, index, section in
+            didDisappear?(view as! View, index, section as! Section)
+        }
+    }
+
+    /// Makes a new element for representing a cell
+    /// - Parameters:
+    ///   - section: The section where this element's cell will be shown in
+    ///   - dequeueMethod: The method to use for registering and dequeueing a cell for this element
+    ///   - reuseIdentifier: The reuseIdentifier to use for this element
+    ///   - configure: A closure that will be called whenever the elements view needs to be configured
+    ///   - willAppear: A closure that will be called before the elements view appears
+    ///   - didDisappear: A closure that will be called after the elements view disappears
+    public init<Section, View: UICollectionViewCell>(section: Section,
+                                                     dequeueMethod: AnyDequeueMethod,
+                                                     reuseIdentifier: String? = nil,
+                                                     configure: @escaping (View, Int, Section) -> Void,
+                                                     willAppear: ((View, Int, Section) -> Void)? = nil,
+                                                     didDisappear: ((View, Int, Section) -> Void)? = nil)
+    where Section: Composed.Section {
+        self.reuseIdentifier = reuseIdentifier ?? View.reuseIdentifier
+        self.dequeueMethod = dequeueMethod
+
+        // swiftlint:disable force_cast
+
+        self.configure = { view, index, section in
+            configure(view as! View, index, section as! Section)
+        }
+
+        self.willAppear = { view, index, section in
+            willAppear?(view as! View, index, section as! Section)
+        }
+
+        self.didDisappear = { view, index, section in
+            didDisappear?(view as! View, index, section as! Section)
+        }
+    }
+
+    /// Makes a new element for representing a cell
+    /// - Parameters:
+    ///   - dequeueMethod: The method to use for registering and dequeueing a cell for this element
+    ///   - reuseIdentifier: The reuseIdentifier to use for this element
+    ///   - configure: A closure that will be called whenever the elements view needs to be configured
+    ///   - willAppear: A closure that will be called before the elements view appears
+    ///   - didDisappear: A closure that will be called after the elements view disappears
+    public init<View: UICollectionViewCell>(
+        dequeueMethod: AnyDequeueMethod,
+        reuseIdentifier: String? = nil,
+        configure: @escaping (View, Int) -> Void,
+        willAppear: ((View, Int) -> Void)? = nil,
+        didDisappear: ((View, Int) -> Void)? = nil) {
+        self.reuseIdentifier = reuseIdentifier ?? View.reuseIdentifier
+        self.dequeueMethod = dequeueMethod
+
+        // swiftlint:disable force_cast
+
+        self.configure = { view, index, _ in
+            configure(view as! View, index)
+        }
 
-            self.willAppear = { view, index, section in
-                willAppear?(view as! View, index, section as! Section)
-            }
+        self.willAppear = { view, index, _ in
+            willAppear?(view as! View, index)
+        }
 
-            self.didDisappear = { view, index, section in
-                didDisappear?(view as! View, index, section as! Section)
-            }
+        self.didDisappear = { view, index, _ in
+            didDisappear?(view as! View, index)
+        }
     }
 
 }
 
 /// Defines a supplementary element to be used by a `CollectionSection` to provide a configuration for a supplementary view
-public final class CollectionSupplementaryElement<View>: CollectionElement where View: UICollectionReusableView {
+public final class CollectionSupplementaryElement: CollectionElement {
 
-    public let dequeueMethod: DequeueMethod<View>
+    public let dequeueMethod: AnyDequeueMethod
     public let configure: (UICollectionReusableView, Int, Section) -> Void
     public let reuseIdentifier: String
 
@@ -127,23 +223,51 @@ public final class CollectionSupplementaryElement<View>: CollectionElement where
     ///   - reuseIdentifier: The reuseIdentifier to use for this element
     ///   - kind: The `elementKind` this element represents
     ///   - configure: A closure that will be called whenever the elements view needs to be configured
-    public init<Section>(section: Section,
-                         dequeueMethod: DequeueMethod<View>,
-                         reuseIdentifier: String? = nil,
-                         kind: CollectionElementKind = .automatic,
-                         configure: @escaping (View, Int, Section) -> Void)
-        where Section: Composed.Section {
-            self.kind = kind
-            self.reuseIdentifier = reuseIdentifier ?? View.reuseIdentifier
-            self.dequeueMethod = dequeueMethod
-
-            self.configure = { view, index, section in
-                // swiftlint:disable force_cast
-                configure(view as! View, index, section as! Section)
-            }
-
-            willAppear = nil
-            didDisappear = nil
+    public init<Section, View: UICollectionReusableView>(
+        section: Section,
+        dequeueMethod: DequeueMethod<View>,
+        reuseIdentifier: String? = nil,
+        kind: CollectionElementKind = .automatic,
+        configure: @escaping (_ view: View, _ sectionIndex: Int, _ section: Section) -> Void
+    ) where Section: Composed.Section {
+        self.kind = kind
+        self.reuseIdentifier = reuseIdentifier ?? View.reuseIdentifier
+        self.dequeueMethod = dequeueMethod.erasedAsAnyDequeueMethod
+
+        self.configure = { view, index, section in
+            // swiftlint:disable force_cast
+            configure(view as! View, index, section as! Section)
+        }
+
+        willAppear = nil
+        didDisappear = nil
+    }
+
+    /// Makes a new element for representing a supplementary view
+    /// - Parameters:
+    ///   - section: The section where this element's view will be shown in
+    ///   - dequeueMethod: The method to use for registering and dequeueing a view for this element
+    ///   - reuseIdentifier: The reuseIdentifier to use for this element
+    ///   - kind: The `elementKind` this element represents
+    ///   - configure: A closure that will be called whenever the elements view needs to be configured
+    public init<Section, View: UICollectionReusableView>(
+        section: Section,
+        dequeueMethod: AnyDequeueMethod,
+        reuseIdentifier: String? = nil,
+        kind: CollectionElementKind = .automatic,
+        configure: @escaping (_ view: View, _ sectionIndex: Int, _ section: Section) -> Void
+    ) where Section: Composed.Section {
+        self.kind = kind
+        self.reuseIdentifier = reuseIdentifier ?? View.reuseIdentifier
+        self.dequeueMethod = dequeueMethod
+
+        self.configure = { view, index, section in
+            // swiftlint:disable force_cast
+            configure(view as! View, index, section as! Section)
+        }
+
+        willAppear = nil
+        didDisappear = nil
     }
 
     /// Makes a new element for representing a supplementary view
@@ -155,31 +279,68 @@ public final class CollectionSupplementaryElement<View>: CollectionElement where
     ///   - configure: A closure that will be called whenever the elements view needs to be configured
     ///   - willAppear: A closure that will be called before the elements view appears
     ///   - didDisappear: A closure that will be called after the elements view disappears
-    public init<Section>(section: Section,
+    public init<Section, View: UICollectionReusableView>(
+        section: Section,
                          dequeueMethod: DequeueMethod<View>,
                          reuseIdentifier: String? = nil,
                          kind: CollectionElementKind = .automatic,
                          configure: @escaping (View, Int, Section) -> Void,
                          willAppear: ((View, Int, Section) -> Void)? = nil,
-                         didDisappear: ((View, Int, Section) -> Void)? = nil)
-        where Section: Composed.Section {
-            self.kind = kind
-            self.reuseIdentifier = reuseIdentifier ?? View.reuseIdentifier
-            self.dequeueMethod = dequeueMethod
+                         didDisappear: ((View, Int, Section) -> Void)? = nil
+    ) where Section: Composed.Section {
+        self.kind = kind
+        self.reuseIdentifier = reuseIdentifier ?? View.reuseIdentifier
+        self.dequeueMethod = dequeueMethod.erasedAsAnyDequeueMethod
 
-            // swiftlint:disable force_cast
+        // swiftlint:disable force_cast
+
+        self.configure = { view, index, section in
+            configure(view as! View, index, section as! Section)
+        }
 
-            self.configure = { view, index, section in
-                configure(view as! View, index, section as! Section)
-            }
+        self.willAppear = { view, index, section in
+            willAppear?(view as! View, index, section as! Section)
+        }
 
-            self.willAppear = { view, index, section in
-                willAppear?(view as! View, index, section as! Section)
-            }
+        self.didDisappear = { view, index, section in
+            didDisappear?(view as! View, index, section as! Section)
+        }
+    }
 
-            self.didDisappear = { view, index, section in
-                didDisappear?(view as! View, index, section as! Section)
-            }
+    /// Makes a new element for representing a supplementary view
+    /// - Parameters:
+    ///   - section: The section where this element's view will be shown in
+    ///   - dequeueMethod: The method to use for registering and dequeueing a view for this element
+    ///   - reuseIdentifier: The reuseIdentifier to use for this element
+    ///   - kind: The `elementKind` this element represents
+    ///   - configure: A closure that will be called whenever the elements view needs to be configured
+    ///   - willAppear: A closure that will be called before the elements view appears
+    ///   - didDisappear: A closure that will be called after the elements view disappears
+    public init<View: UICollectionReusableView>(
+        dequeueMethod: DequeueMethod<View>,
+        reuseIdentifier: String? = nil,
+        kind: CollectionElementKind = .automatic,
+        configure: @escaping (View, Int) -> Void,
+        willAppear: ((View, Int) -> Void)? = nil,
+        didDisappear: ((View, Int) -> Void)? = nil
+    ) {
+        self.kind = kind
+        self.reuseIdentifier = reuseIdentifier ?? View.reuseIdentifier
+        self.dequeueMethod = dequeueMethod.erasedAsAnyDequeueMethod
+
+        // swiftlint:disable force_cast
+
+        self.configure = { view, index, _ in
+            configure(view as! View, index)
+        }
+
+        self.willAppear = { view, index, _ in
+            willAppear?(view as! View, index)
+        }
+
+        self.didDisappear = { view, index, _ in
+            didDisappear?(view as! View, index)
+        }
     }
 
 }
diff --git a/Sources/ComposedUI/CollectionView/CollectionSection.swift b/Sources/ComposedUI/CollectionView/CollectionSection.swift
index 02261ba..9718f5c 100644
--- a/Sources/ComposedUI/CollectionView/CollectionSection.swift
+++ b/Sources/ComposedUI/CollectionView/CollectionSection.swift
@@ -3,16 +3,16 @@ import Composed
 
 /// Defines a configuration for a section in a `UICollectionView`.
 /// The section must contain a cell element, but can also optionally include a header and/or footer element.
-open class CollectionSection: CollectionElementsProvider {
+open class CollectionSection: SingleUICollectionViewSectionElementsProvider {
 
     /// The cell configuration element
-    public let cell: CollectionCellElement<UICollectionViewCell>
+    public let cell: CollectionCellElement
 
     /// The header configuration element
-    public let header: CollectionSupplementaryElement<UICollectionReusableView>?
+    public let header: CollectionSupplementaryElement?
 
     /// The footer configuration element
-    public let footer: CollectionSupplementaryElement<UICollectionReusableView>?
+    public let footer: CollectionSupplementaryElement?
 
     /// The number of elements in this section
     open var numberOfElements: Int {
@@ -28,76 +28,56 @@ open class CollectionSection: CollectionElementsProvider {
     ///   - cell: The cell configuration element
     ///   - header: The header configuration element
     ///   - footer: The footer configuration element
-    public init<Section, Cell, Header, Footer>(section: Section,
-                                               cell: CollectionCellElement<Cell>,
-                                               header: CollectionSupplementaryElement<Header>? = nil,
-                                               footer: CollectionSupplementaryElement<Footer>? = nil)
-        where Header: UICollectionReusableView, Footer: UICollectionReusableView, Cell: UICollectionViewCell, Section: Composed.Section {
-            self.section = section
-
-            // The code below copies the relevent elements to erase type-safety
-
-            let dequeueMethod: DequeueMethod<UICollectionViewCell>
-            switch cell.dequeueMethod {
-            case .fromClass: dequeueMethod = .fromClass(Cell.self)
-            case .fromNib: dequeueMethod = .fromNib(Cell.self)
-            case .fromStoryboard: dequeueMethod = .fromStoryboard(Cell.self)
-            }
-
-            self.cell = CollectionCellElement(section: section,
-                                              dequeueMethod: dequeueMethod,
-                                              reuseIdentifier: cell.reuseIdentifier,
-                                              configure: cell.configure,
-                                              willAppear: cell.willAppear,
-                                              didDisappear: cell.didDisappear)
-
-            if let header = header {
-                let dequeueMethod: DequeueMethod<UICollectionReusableView>
-                switch header.dequeueMethod {
-                case .fromClass: dequeueMethod = .fromClass(Header.self)
-                case .fromNib: dequeueMethod = .fromNib(Header.self)
-                case .fromStoryboard: dequeueMethod = .fromStoryboard(Header.self)
-                }
-
-                let kind: CollectionElementKind
-                if case .automatic = header.kind {
-                    kind = .custom(kind: UICollectionView.elementKindSectionHeader)
-                } else {
-                    kind = header.kind
-                }
-
-                self.header = CollectionSupplementaryElement(section: section,
-                                                             dequeueMethod: dequeueMethod,
-                                                             reuseIdentifier: header.reuseIdentifier,
-                                                             kind: kind,
-                                                             configure: header.configure)
+    public init<Section>(
+        section: Section,
+        cell: CollectionCellElement,
+        header: CollectionSupplementaryElement? = nil,
+        footer: CollectionSupplementaryElement? = nil
+    ) where Section: Composed.Section {
+        self.section = section
+
+        // The code below copies the relevent elements to erase type-safety
+
+        self.cell = CollectionCellElement(section: section,
+                                          dequeueMethod: cell.dequeueMethod,
+                                          reuseIdentifier: cell.reuseIdentifier,
+                                          configure: cell.configure,
+                                          willAppear: cell.willAppear,
+                                          didDisappear: cell.didDisappear)
+
+        if let header = header {
+            let kind: CollectionElementKind
+            if case .automatic = header.kind {
+                kind = .custom(kind: UICollectionView.elementKindSectionHeader)
             } else {
-                self.header = nil
+                kind = header.kind
             }
 
-            if let footer = footer {
-                let dequeueMethod: DequeueMethod<UICollectionReusableView>
-                switch footer.dequeueMethod {
-                case .fromClass: dequeueMethod = .fromClass(Footer.self)
-                case .fromNib: dequeueMethod = .fromNib(Footer.self)
-                case .fromStoryboard: dequeueMethod = .fromStoryboard(Footer.self)
-                }
-
-                let kind: CollectionElementKind
-                if case .automatic = footer.kind {
-                    kind = .custom(kind: UICollectionView.elementKindSectionFooter)
-                } else {
-                    kind = footer.kind
-                }
-
-                self.footer = CollectionSupplementaryElement(section: section,
-                                                             dequeueMethod: dequeueMethod,
-                                                             reuseIdentifier: footer.reuseIdentifier,
-                                                             kind: kind,
-                                                             configure: footer.configure)
+            self.header = CollectionSupplementaryElement(section: section,
+                                                         dequeueMethod: header.dequeueMethod,
+                                                         reuseIdentifier: header.reuseIdentifier,
+                                                         kind: kind,
+                                                         configure: header.configure)
+        } else {
+            self.header = nil
+        }
+
+        if let footer = footer {
+            let kind: CollectionElementKind
+            if case .automatic = footer.kind {
+                kind = .custom(kind: UICollectionView.elementKindSectionFooter)
             } else {
-                self.footer = nil
+                kind = footer.kind
             }
+
+            self.footer = CollectionSupplementaryElement(section: section,
+                                                         dequeueMethod: footer.dequeueMethod,
+                                                         reuseIdentifier: footer.reuseIdentifier,
+                                                         kind: kind,
+                                                         configure: footer.configure)
+        } else {
+            self.footer = nil
+        }
     }
 
 }
diff --git a/Sources/ComposedUI/CollectionView/CollectionSectionProvider.swift b/Sources/ComposedUI/CollectionView/CollectionSectionProvider.swift
deleted file mode 100644
index 3b31fc7..0000000
--- a/Sources/ComposedUI/CollectionView/CollectionSectionProvider.swift
+++ /dev/null
@@ -1,22 +0,0 @@
-import UIKit
-import Composed
-
-/// Provides a section to a collection view. Conform to this protool to use your section with a `UICollectionView`
-public protocol CollectionSectionProvider: Section {
-
-    /// Return a section cofiguration for the collection view.
-    /// - Parameter traitCollection: The trait collection being applied to the view
-    func section(with traitCollection: UITraitCollection) -> CollectionSection
-
-}
-
-internal protocol CollectionElementsProvider {
-    var cell: CollectionCellElement<UICollectionViewCell> { get }
-    var header: CollectionSupplementaryElement<UICollectionReusableView>? { get }
-    var footer: CollectionSupplementaryElement<UICollectionReusableView>? { get }
-    var numberOfElements: Int { get }
-}
-
-extension CollectionElementsProvider {
-    var isEmpty: Bool { return numberOfElements == 0 }
-}
diff --git a/Sources/ComposedUI/CollectionView/FlatUICollectionViewSection.swift b/Sources/ComposedUI/CollectionView/FlatUICollectionViewSection.swift
new file mode 100644
index 0000000..c65836d
--- /dev/null
+++ b/Sources/ComposedUI/CollectionView/FlatUICollectionViewSection.swift
@@ -0,0 +1,54 @@
+import Composed
+import UIKit
+
+/// A `Composed.FlatSection` conforming to `UICollectionViewSection`
+open class FlatUICollectionViewSection: FlatSection, UICollectionViewSection {
+    public var header: CollectionSupplementaryElement? {
+        didSet {
+            updateDelegate?.sectionDidInvalidateHeader(self)
+        }
+    }
+
+    public var footer: CollectionSupplementaryElement? {
+        didSet {
+            updateDelegate?.sectionDidInvalidateFooter(self)
+        }
+    }
+
+    public init(header: CollectionSupplementaryElement? = nil, footer: CollectionSupplementaryElement? = nil) {
+        self.header = header
+        self.footer = footer
+
+        super.init()
+    }
+
+    open func collectionViewElementsProvider(with traitCollection: UITraitCollection) -> UICollectionViewSectionElementsProvider {
+        FlatUICollectionViewSectionElementsProvider(section: self, traitCollection: traitCollection)
+    }
+}
+
+extension FlatUICollectionViewSection: CollectionSelectionHandler {
+    open func didSelect(at index: Int, cell: UICollectionViewCell) {
+        guard let sectionMeta = self.sectionForElementIndex(index) else { return }
+
+        let sectionIndex = index - sectionMeta.offset
+
+        if let section = sectionMeta.section as? CollectionSelectionHandler {
+            section.didSelect(at: sectionIndex, cell: cell)
+        } else if let section = sectionMeta.section as? SelectionHandler {
+            section.didSelect(at: sectionIndex)
+        }
+    }
+
+    open func didDeselect(at index: Int, cell: UICollectionViewCell) {
+        guard let sectionMeta = self.sectionForElementIndex(index) else { return }
+
+        let sectionIndex = index - sectionMeta.offset
+
+        if let section = sectionMeta.section as? CollectionSelectionHandler {
+            section.didDeselect(at: sectionIndex, cell: cell)
+        } else if let section = sectionMeta.section as? SelectionHandler {
+            section.didDeselect(at: sectionIndex)
+        }
+    }
+}
diff --git a/Sources/ComposedUI/CollectionView/FlatUICollectionViewSectionElementsProvider.swift b/Sources/ComposedUI/CollectionView/FlatUICollectionViewSectionElementsProvider.swift
new file mode 100644
index 0000000..02f25d6
--- /dev/null
+++ b/Sources/ComposedUI/CollectionView/FlatUICollectionViewSectionElementsProvider.swift
@@ -0,0 +1,110 @@
+import UIKit
+import Composed
+
+open class FlatUICollectionViewSectionElementsProvider: UICollectionViewSectionElementsProvider {
+    /// The header configuration element
+    public var header: CollectionSupplementaryElement? {
+        guard let flatSection = flatSection else { return nil }
+        guard let header = flatSection.header else { return nil }
+        let kind: CollectionElementKind
+        if case .automatic = header.kind {
+            kind = .custom(kind: UICollectionView.elementKindSectionHeader)
+        } else {
+            kind = header.kind
+        }
+
+        return CollectionSupplementaryElement(
+            section: flatSection,
+            dequeueMethod: header.dequeueMethod,
+            reuseIdentifier: header.reuseIdentifier,
+            kind: kind,
+            configure: header.configure
+        )
+    }
+
+    /// The footer configuration element
+    public var footer: CollectionSupplementaryElement? {
+        guard let flatSection = flatSection else { return nil }
+        guard let footer = flatSection.footer else { return nil }
+        let kind: CollectionElementKind
+        if case .automatic = footer.kind {
+            kind = .custom(kind: UICollectionView.elementKindSectionFooter)
+        } else {
+            kind = footer.kind
+        }
+
+        return CollectionSupplementaryElement(
+            section: flatSection,
+            dequeueMethod: footer.dequeueMethod,
+            reuseIdentifier: footer.reuseIdentifier,
+            kind: kind,
+            configure: footer.configure
+        )
+    }
+
+    /// The number of elements in this section
+    open var numberOfElements: Int {
+        return flatSection?.numberOfElements ?? 0
+    }
+
+    // The underlying section associated with this section
+    private weak var flatSection: FlatUICollectionViewSection?
+
+    private let traitCollection: UITraitCollection
+
+    /// Makes a new configuration with the specified cell, header and/or footer elements
+    /// - Parameters:
+    ///   - section: The section this will be associated with
+    ///   - cell: The cell configuration element
+    ///   - header: The header configuration element
+    ///   - footer: The footer configuration element
+    public init(
+        section: FlatUICollectionViewSection,
+        traitCollection: UITraitCollection
+    ) {
+        self.flatSection = section
+        self.traitCollection = traitCollection
+    }
+
+    open func cell(for index: Int) -> CollectionCellElement {
+        guard let (section, offset) = flatSection?.sectionForElementIndex(index) else {
+            fatalError("No section for index \(index) exists")
+        }
+
+        guard let collectionSectionProvider = section as? UICollectionViewSection else {
+            fatalError("Child must conform to `CollectionSectionProvider`")
+        }
+
+        let indexInSection = index - offset
+        let collectionSection = collectionSectionProvider.collectionViewElementsProvider(with: traitCollection)
+        let collectionCellElement = collectionSection.cell(for: indexInSection)
+        return FlattenedCollectionCellElement(collectionElement: collectionCellElement, section: section, sectionOffset: offset)
+    }
+}
+
+private final class FlattenedCollectionCellElement: CollectionCellElement {
+    fileprivate init(collectionElement element: CollectionCellElement, section: Section, sectionOffset: Int) {
+        super.init(
+            dequeueMethod: element.dequeueMethod,
+            reuseIdentifier: element.reuseIdentifier,
+            configure: { [weak section] cell, index in
+                guard let section = section else { return }
+
+                let sectionIndex = index - sectionOffset
+                element.configure(cell, sectionIndex, section)
+            },
+            willAppear: { [weak section] cell, index in
+                guard let section = section else { return }
+
+                let sectionIndex = index - sectionOffset
+                element.willAppear?(cell, sectionIndex, section)
+            },
+            didDisappear: { [weak section] cell, index in
+                guard let section = section else { return }
+
+                let sectionIndex = index - sectionOffset
+                element.didDisappear?(cell, sectionIndex, section)
+            }
+        )
+    }
+}
diff --git a/Sources/ComposedUI/CollectionView/Handlers/CollectionContextMenuHandler.swift b/Sources/ComposedUI/CollectionView/Handlers/CollectionContextMenuHandler.swift
index 7c82aa3..2f46b5c 100644
--- a/Sources/ComposedUI/CollectionView/Handlers/CollectionContextMenuHandler.swift
+++ b/Sources/ComposedUI/CollectionView/Handlers/CollectionContextMenuHandler.swift
@@ -3,7 +3,7 @@ import Composed
 
 /// Provides context menu handling for `UICollectionView`'s
 @available(iOS 13.0, *)
-public protocol CollectionContextMenuHandler: CollectionSectionProvider {
+public protocol CollectionContextMenuHandler: UICollectionViewSection {
 
     /// Specifies whether or not a specific element allows showing a context menu. If you want UIKit to indicate that a menu is usually provided for this element, true `true` and simply return `nil` for `contextMenu(forElementAt:cell:suggestedActions:)`
     /// - Parameter index: The index of the element
diff --git a/Sources/ComposedUI/CollectionView/Handlers/CollectionDragHandler.swift b/Sources/ComposedUI/CollectionView/Handlers/CollectionDragHandler.swift
index 643435a..56030ee 100644
--- a/Sources/ComposedUI/CollectionView/Handlers/CollectionDragHandler.swift
+++ b/Sources/ComposedUI/CollectionView/Handlers/CollectionDragHandler.swift
@@ -2,7 +2,7 @@ import UIKit
 import CoreData
 import Composed
 
-public protocol CollectionDragHandler: CollectionSectionProvider {
+public protocol CollectionDragHandler: UICollectionViewSection {
 
     func dragSessionWillBegin(_ session: UIDragSession)
     func dragSessionDidEnd(_ session: UIDragSession)
@@ -26,5 +26,5 @@ public extension CollectionDragHandler {
         return dragSession(session, dragItemsForBeginning: index)
     }
     func dragSession(previewParametersForElementAt index: Int, cell: UICollectionViewCell) -> UIDragPreviewParameters? { return nil }
-
+    
 }
diff --git a/Sources/ComposedUI/CollectionView/Handlers/CollectionDropHandler.swift b/Sources/ComposedUI/CollectionView/Handlers/CollectionDropHandler.swift
index 692c61a..2ce4c47 100644
--- a/Sources/ComposedUI/CollectionView/Handlers/CollectionDropHandler.swift
+++ b/Sources/ComposedUI/CollectionView/Handlers/CollectionDropHandler.swift
@@ -3,7 +3,7 @@ import CoreData
 import Composed
 
 /// Provides drag and drop handling for `UICollectionView`'s
-public protocol CollectionDropHandler: CollectionSectionProvider {
+public protocol CollectionDropHandler: UICollectionViewSection {
 
     func dropSessionWillBegin(_ session: UIDropSession)
     func dropSessionDidEnd(_ session: UIDropSession)
diff --git a/Sources/ComposedUI/CollectionView/Handlers/CollectionEditingHandler.swift b/Sources/ComposedUI/CollectionView/Handlers/CollectionEditingHandler.swift
index eaece63..f5378f1 100644
--- a/Sources/ComposedUI/CollectionView/Handlers/CollectionEditingHandler.swift
+++ b/Sources/ComposedUI/CollectionView/Handlers/CollectionEditingHandler.swift
@@ -2,7 +2,7 @@ import UIKit
 import Composed
 
 /// Provides edit handling for `UICollectionView`'s
-public protocol CollectionEditingHandler: EditingHandler, CollectionSectionProvider {
+public protocol CollectionEditingHandler: EditingHandler, UICollectionViewSection {
 
     /// When editing is toggled, this method will be called to notify the section
     /// - Parameters:
diff --git a/Sources/ComposedUI/CollectionView/Handlers/CollectionSelectionHandler.swift b/Sources/ComposedUI/CollectionView/Handlers/CollectionSelectionHandler.swift
index d37603d..863ffae 100644
--- a/Sources/ComposedUI/CollectionView/Handlers/CollectionSelectionHandler.swift
+++ b/Sources/ComposedUI/CollectionView/Handlers/CollectionSelectionHandler.swift
@@ -2,7 +2,7 @@ import UIKit
 import Composed
 
 /// Provides selection handling for `UICollectionView`'s
-public protocol CollectionSelectionHandler: SelectionHandler, CollectionSectionProvider {
+public protocol CollectionSelectionHandler: SelectionHandler, UICollectionViewSection {
 
     /// When a selection occurs, this method will be called to notify the section
     /// - Parameters:
@@ -22,7 +22,7 @@ public extension CollectionSelectionHandler {
     func didSelect(at index: Int, cell: UICollectionViewCell) {
         didSelect(at: index)
     }
-
+    
     func didDeselect(at index: Int, cell: UICollectionViewCell) {
         didSelect(at: index)
     }
diff --git a/Sources/ComposedUI/CollectionView/Handlers/CollectionUpdateHandler.swift b/Sources/ComposedUI/CollectionView/Handlers/CollectionUpdateHandler.swift
index 1da52b7..a425d78 100644
--- a/Sources/ComposedUI/CollectionView/Handlers/CollectionUpdateHandler.swift
+++ b/Sources/ComposedUI/CollectionView/Handlers/CollectionUpdateHandler.swift
@@ -1,7 +1,7 @@
 import UIKit
 
 /// Conform your section to this to signal to the Coordinator that you want to handle updates manually for the cells in this section. Your cell configuration closure will be called instead of `reloadItems`
-public protocol CollectionUpdateHandler: CollectionSectionProvider {
+public protocol CollectionUpdateHandler: UICollectionViewSection {
 
     /// Return true to signal to the view that it should reload the cell vs re-calling the cell configuration handler on `CollectionElement`
     /// - Parameter index: The element index
diff --git a/Sources/ComposedUI/CollectionView/UICollectionViewSection.swift b/Sources/ComposedUI/CollectionView/UICollectionViewSection.swift
new file mode 100644
index 0000000..3426f36
--- /dev/null
+++ b/Sources/ComposedUI/CollectionView/UICollectionViewSection.swift
@@ -0,0 +1,45 @@
+import UIKit
+import Composed
+
+@available(*, deprecated, renamed: "SingleUICollectionViewSection")
+public typealias CollectionSectionProvider = SingleUICollectionViewSection
+
+/// A section in a `UICollectionView`.
+public protocol UICollectionViewSection: Section {
+    func collectionViewElementsProvider(with traitCollection: UITraitCollection) -> UICollectionViewSectionElementsProvider
+}
+
+public protocol SingleUICollectionViewSection: UICollectionViewSection {
+    func section(with traitCollection: UITraitCollection) -> CollectionSection
+}
+
+extension SingleUICollectionViewSection {
+    public func collectionViewElementsProvider(with traitCollection: UITraitCollection) -> UICollectionViewSectionElementsProvider {
+        return section(with: traitCollection)
+    }
+}
+
+@available(*, deprecated, renamed: "UICollectionViewSectionElementsProvider")
+public typealias CollectionElementsProvider = UICollectionViewSectionElementsProvider
+
+public protocol UICollectionViewSectionElementsProvider {
+    var header: CollectionSupplementaryElement? { get }
+    var footer: CollectionSupplementaryElement? { get }
+    var numberOfElements: Int { get }
+
+    func cell(for index: Int) -> CollectionCellElement
+}
+
+extension UICollectionViewSectionElementsProvider {
+    public var isEmpty: Bool { return numberOfElements == 0 }
+}
+
+public protocol SingleUICollectionViewSectionElementsProvider: UICollectionViewSectionElementsProvider {
+    var cell: CollectionCellElement { get }
+}
+
+extension SingleUICollectionViewSectionElementsProvider {
+    public func cell(for index: Int) -> CollectionCellElement {
+        return cell
+    }
+}
diff --git a/Sources/ComposedUI/Common/Types.swift b/Sources/ComposedUI/Common/Types.swift
index 5f89c74..29f7ff8 100644
--- a/Sources/ComposedUI/Common/Types.swift
+++ b/Sources/ComposedUI/Common/Types.swift
@@ -11,4 +11,28 @@ public enum DequeueMethod<View: UIView> {
     case fromClass(View.Type)
     /// Load from a storyboard
     case fromStoryboard(View.Type)
+
+    internal var erasedAsAnyDequeueMethod: AnyDequeueMethod {
+        switch self {
+        case .fromNib(let viewType):
+            return AnyDequeueMethod(method: .fromNib(viewType))
+        case .fromClass(let viewType):
+            return AnyDequeueMethod(method: .fromClass(viewType))
+        case .fromStoryboard(let viewType):
+            return AnyDequeueMethod(method: .fromStoryboard(viewType))
+        }
+    }
+}
+
+public struct AnyDequeueMethod {
+    internal enum Method {
+        /// Load from a nib
+        case fromNib(UIView.Type)
+        // Load from a class
+        case fromClass(UIView.Type)
+        /// Load from a storyboard
+        case fromStoryboard(UIView.Type)
+    }
+
+    internal let method: Method
 }
diff --git a/Sources/ComposedUI/StackView/StackCoordinator.swift b/Sources/ComposedUI/StackView/StackCoordinator.swift
index bc81ab3..a4bebb3 100644
--- a/Sources/ComposedUI/StackView/StackCoordinator.swift
+++ b/Sources/ComposedUI/StackView/StackCoordinator.swift
@@ -135,6 +135,8 @@ extension StackCoordinator: SectionProviderMappingDelegate {
     public func mapping(_ mapping: SectionProviderMapping, select indexPath: IndexPath) { }
     public func mapping(_ mapping: SectionProviderMapping, deselect indexPath: IndexPath) { }
     public func mapping(_ mapping: SectionProviderMapping, move sourceIndexPath: IndexPath, to destinationIndexPath: IndexPath) { }
+    public func mappingDidInvalidateHeader(at sectionIndex: Int) {}
+    public func mappingDidInvalidateFooter(at sectionIndex: Int) {}
 
 }
 
diff --git a/Sources/ComposedUI/TableView/TableCoordinator.swift b/Sources/ComposedUI/TableView/TableCoordinator.swift
index 3a7f8b8..692e188 100644
--- a/Sources/ComposedUI/TableView/TableCoordinator.swift
+++ b/Sources/ComposedUI/TableView/TableCoordinator.swift
@@ -153,7 +153,6 @@ open class TableCoordinator: NSObject {
 // MARK: - SectionProviderMappingDelegate
 
 extension TableCoordinator: SectionProviderMappingDelegate {
-
     private func reset() {
         removes.removeAll()
         inserts.removeAll()
@@ -304,6 +303,14 @@ extension TableCoordinator: SectionProviderMappingDelegate {
         tableView.moveRow(at: sourceIndexPath, to: destinationIndexPath)
     }
 
+    public func mappingDidInvalidateHeader(at sectionIndex: Int) {
+        // TODO: Reload header
+    }
+
+    public func mappingDidInvalidateFooter(at sectionIndex: Int) {
+        // TODO: Reload header
+    }
+    
 }
 
 // MARK: - UITableViewDataSource
diff --git a/Tests/ComposedTests/ComposedSectionProvider.swift b/Tests/ComposedTests/ComposedSectionProvider+Spec.swift
similarity index 100%
rename from Tests/ComposedTests/ComposedSectionProvider.swift
rename to Tests/ComposedTests/ComposedSectionProvider+Spec.swift
diff --git a/Tests/ComposedTests/FlatSection+Spec.swift b/Tests/ComposedTests/FlatSection+Spec.swift
new file mode 100644
index 0000000..ce61c70
--- /dev/null
+++ b/Tests/ComposedTests/FlatSection+Spec.swift
@@ -0,0 +1,837 @@
+import Quick
+import Nimble
+import Foundation
+
+@testable import Composed
+
+final class FlatSection_Spec: QuickSpec {
+
+    override func spec() {
+        describe("FlatSection") {
+            var global: FlatSection!
+            var child1: ComposedSectionProvider!
+                var child1a: ArraySection<String>!
+                var child1b: ArraySection<String>!
+            var child2: ComposedSectionProvider!
+                var child2a: ComposedSectionProvider!
+                    var child2b: ArraySection<String>!
+                    var child2c: ArraySection<String>!
+                    var child2d: ArraySection<String>!
+                var child2e: ComposedSectionProvider!
+                var child2f: ArraySection<String>!
+                var child2g: ComposedSectionProvider!
+                    var child2h: ArraySection<String>!
+            var child3: ArraySection<String>!
+            var child4: ArraySection<String>!
+            var child5: ComposedSectionProvider!
+
+            beforeEach {
+                global = FlatSection()
+
+                child1 = ComposedSectionProvider()
+                    child1a = ArraySection<String>(["child1a index 0", "child1a index 1"])
+                    child1b = ArraySection<String>(["child1b index 0", "child1b index 1", "child1b index 2"])
+                child2 = ComposedSectionProvider()
+                    child2a = ComposedSectionProvider()
+                        child2b = ArraySection<String>(["child2b index 0"])
+                        child2c = ArraySection<String>()
+                        child2d = ArraySection<String>(["child2d index 0", "child2d index 1", "child2d index 2"])
+                    child2e = ComposedSectionProvider()
+                    child2f = ArraySection<String>(["child2f index 0", "child2f index 1", "child2f index 2"])
+                    child2g = ComposedSectionProvider()
+                        child2h = ArraySection<String>(["child2h index 0", "child2h index 1", "child2h index 2"])
+                child3 = ArraySection<String>(["child3 index 0", "child3 index 1", "child3 index 2"])
+                child4 = ArraySection<String>(["child4 index 0", "child4 index 1"])
+                child5 = ComposedSectionProvider()
+
+                child1.append(child1a)
+                child1.insert(child1b, after: child1a)
+
+                child2.append(child2a)
+                child2a.append(child2c)
+                child2a.insert(child2b, before: child2c)
+                child2a.insert(child2d, after: child2c)
+
+                child2.insert(child2e, after: child2a)
+                child2.append(child2f)
+                child2g.append(child2h)
+                child2.append(child2g)
+                global.append(child1)
+                global.append(child2)
+                global.append(child3)
+                global.append(child4)
+                global.append(child5)
+            }
+
+            it("should contain 20 elements") {
+                expect(global.numberOfElements) == 20
+            }
+
+            it("should return the correct first element indexes") {
+                expect(global.indexForFirstElement(of: child1)) == 0
+                expect(global.indexForFirstElement(of: child1a)) == 0
+                expect(global.indexForFirstElement(of: child1b)) == 2
+                expect(global.indexForFirstElement(of: child2)) == 5
+                expect(global.indexForFirstElement(of: child2a)) == 5
+                expect(global.indexForFirstElement(of: child2b)) == 5
+                expect(global.indexForFirstElement(of: child2c)) == 6
+                expect(global.indexForFirstElement(of: child2d)) == 6
+                expect(global.indexForFirstElement(of: child2e)) == 9
+                expect(global.indexForFirstElement(of: child2f)) == 9
+                expect(global.indexForFirstElement(of: child2g)) == 12
+                expect(global.indexForFirstElement(of: child2h)) == 12
+                expect(global.indexForFirstElement(of: child3)) == 15
+                expect(global.indexForFirstElement(of: child4)) == 18
+                expect(global.indexForFirstElement(of: child5)) == 20
+            }
+
+            it("should return the correct section for element index") {
+                expect(global.sectionForElementIndex(0)?.section) === child1a
+                expect(global.sectionForElementIndex(1)?.section) === child1a
+                expect(global.sectionForElementIndex(2)?.section) === child1b
+                expect(global.sectionForElementIndex(3)?.section) === child1b
+                expect(global.sectionForElementIndex(4)?.section) === child1b
+                expect(global.sectionForElementIndex(5)?.section) === child2b
+                expect(global.sectionForElementIndex(6)?.section) === child2d
+                expect(global.sectionForElementIndex(7)?.section) === child2d
+                expect(global.sectionForElementIndex(8)?.section) === child2d
+                expect(global.sectionForElementIndex(9)?.section) === child2f
+                expect(global.sectionForElementIndex(10)?.section) === child2f
+                expect(global.sectionForElementIndex(11)?.section) === child2f
+                expect(global.sectionForElementIndex(12)?.section) === child2h
+                expect(global.sectionForElementIndex(13)?.section) === child2h
+                expect(global.sectionForElementIndex(14)?.section) === child2h
+                expect(global.sectionForElementIndex(15)?.section) === child3
+                expect(global.sectionForElementIndex(16)?.section) === child3
+                expect(global.sectionForElementIndex(17)?.section) === child3
+                expect(global.sectionForElementIndex(18)?.section) === child4
+                expect(global.sectionForElementIndex(19)?.section) === child4
+            }
+
+            it("should return the correct child indexes") {
+                expect(global.childIndex(of: child1)) == 0
+                expect(global.childIndex(of: child1a)).to(beNil())
+                expect(global.childIndex(of: child1b)).to(beNil())
+                expect(global.childIndex(of: child2)) == 1
+                expect(global.childIndex(of: child2a)).to(beNil())
+                expect(global.childIndex(of: child2b)).to(beNil())
+                expect(global.childIndex(of: child2c)).to(beNil())
+                expect(global.childIndex(of: child2d)).to(beNil())
+                expect(global.childIndex(of: child2e)).to(beNil())
+                expect(global.childIndex(of: child2f)).to(beNil())
+                expect(global.childIndex(of: child2g)).to(beNil())
+                expect(global.childIndex(of: child2h)).to(beNil())
+                expect(global.childIndex(of: child3)) == 2
+                expect(global.childIndex(of: child4)) == 3
+                expect(global.childIndex(of: child5)) == 4
+            }
+
+            context("after child `ComposedSectionProvider` has been removed") {
+                beforeEach {
+                    global.remove(child2)
+                }
+
+                it("should contain 10 elements") {
+                    expect(global.numberOfElements) == 10
+                }
+
+                it("should return the correct first element indexes") {
+                    expect(global.indexForFirstElement(of: child1)) == 0
+                    expect(global.indexForFirstElement(of: child1a)) == 0
+                    expect(global.indexForFirstElement(of: child1b)) == 2
+                    expect(global.indexForFirstElement(of: child3)) == 5
+                    expect(global.indexForFirstElement(of: child4)) == 8
+                    expect(global.indexForFirstElement(of: child5)) == 10
+                }
+
+                it("should return the correct section for element index") {
+                    expect(global.sectionForElementIndex(0)?.section) === child1a
+                    expect(global.sectionForElementIndex(1)?.section) === child1a
+                    expect(global.sectionForElementIndex(2)?.section) === child1b
+                    expect(global.sectionForElementIndex(3)?.section) === child1b
+                    expect(global.sectionForElementIndex(4)?.section) === child1b
+                    expect(global.sectionForElementIndex(5)?.section) === child3
+                    expect(global.sectionForElementIndex(6)?.section) === child3
+                    expect(global.sectionForElementIndex(7)?.section) === child3
+                    expect(global.sectionForElementIndex(8)?.section) === child4
+                    expect(global.sectionForElementIndex(9)?.section) === child4
+                }
+
+                it("should return the correct child indexes") {
+                    expect(global.childIndex(of: child1)) == 0
+                    expect(global.childIndex(of: child1a)).to(beNil())
+                    expect(global.childIndex(of: child1b)).to(beNil())
+                    expect(global.childIndex(of: child3)) == 1
+                    expect(global.childIndex(of: child4)) == 2
+                    expect(global.childIndex(of: child5)) == 3
+                }
+            }
+
+            context("after child `Section` has been removed") {
+                beforeEach {
+                    global.remove(child3)
+                }
+
+                it("should contain 17 elements") {
+                    expect(global.numberOfElements) == 17
+                }
+
+                it("should return the correct first element indexes") {
+                    expect(global.indexForFirstElement(of: child1)) == 0
+                    expect(global.indexForFirstElement(of: child1a)) == 0
+                    expect(global.indexForFirstElement(of: child1b)) == 2
+                    expect(global.indexForFirstElement(of: child2)) == 5
+                    expect(global.indexForFirstElement(of: child2a)) == 5
+                    expect(global.indexForFirstElement(of: child2b)) == 5
+                    expect(global.indexForFirstElement(of: child2c)) == 6
+                    expect(global.indexForFirstElement(of: child2d)) == 6
+                    expect(global.indexForFirstElement(of: child2e)) == 9
+                    expect(global.indexForFirstElement(of: child2f)) == 9
+                    expect(global.indexForFirstElement(of: child2g)) == 12
+                    expect(global.indexForFirstElement(of: child2h)) == 12
+                    expect(global.indexForFirstElement(of: child4)) == 15
+                    expect(global.indexForFirstElement(of: child5)) == 17
+                }
+
+                it("should return the correct section for element index") {
+                    expect(global.sectionForElementIndex(0)?.section) === child1a
+                    expect(global.sectionForElementIndex(1)?.section) === child1a
+                    expect(global.sectionForElementIndex(2)?.section) === child1b
+                    expect(global.sectionForElementIndex(3)?.section) === child1b
+                    expect(global.sectionForElementIndex(4)?.section) === child1b
+                    expect(global.sectionForElementIndex(5)?.section) === child2b
+                    expect(global.sectionForElementIndex(6)?.section) === child2d
+                    expect(global.sectionForElementIndex(7)?.section) === child2d
+                    expect(global.sectionForElementIndex(8)?.section) === child2d
+                    expect(global.sectionForElementIndex(9)?.section) === child2f
+                    expect(global.sectionForElementIndex(10)?.section) === child2f
+                    expect(global.sectionForElementIndex(11)?.section) === child2f
+                    expect(global.sectionForElementIndex(12)?.section) === child2h
+                    expect(global.sectionForElementIndex(13)?.section) === child2h
+                    expect(global.sectionForElementIndex(14)?.section) === child2h
+                    expect(global.sectionForElementIndex(15)?.section) === child4
+                    expect(global.sectionForElementIndex(16)?.section) === child4
+                }
+
+                it("should return the correct child indexes") {
+                    expect(global.childIndex(of: child1)) == 0
+                    expect(global.childIndex(of: child1a)).to(beNil())
+                    expect(global.childIndex(of: child1b)).to(beNil())
+                    expect(global.childIndex(of: child2)) == 1
+                    expect(global.childIndex(of: child2a)).to(beNil())
+                    expect(global.childIndex(of: child2b)).to(beNil())
+                    expect(global.childIndex(of: child2c)).to(beNil())
+                    expect(global.childIndex(of: child2d)).to(beNil())
+                    expect(global.childIndex(of: child2e)).to(beNil())
+                    expect(global.childIndex(of: child2f)).to(beNil())
+                    expect(global.childIndex(of: child2g)).to(beNil())
+                    expect(global.childIndex(of: child2h)).to(beNil())
+                    expect(global.childIndex(of: child4)) == 2
+                    expect(global.childIndex(of: child5)) == 3
+                }
+            }
+
+            context("after a section has been inserted after a child") {
+                var mockDelegate: MockSectionUpdateDelegate!
+                var newSection: ArraySection<String>!
+
+                beforeEach {
+                    mockDelegate = MockSectionUpdateDelegate()
+                    global.updateDelegate = mockDelegate
+
+                    newSection = ArraySection(["new section index 0", "new section index 1"])
+
+                    global.insert(newSection, after: child3)
+                }
+
+                it("should contain 22 elements") {
+                    expect(global.numberOfElements) == 22
+                }
+
+                it("should return the correct first element indexes") {
+                    expect(global.indexForFirstElement(of: child1)) == 0
+                    expect(global.indexForFirstElement(of: child1a)) == 0
+                    expect(global.indexForFirstElement(of: child1b)) == 2
+                    expect(global.indexForFirstElement(of: child2)) == 5
+                    expect(global.indexForFirstElement(of: child2a)) == 5
+                    expect(global.indexForFirstElement(of: child2b)) == 5
+                    expect(global.indexForFirstElement(of: child2c)) == 6
+                    expect(global.indexForFirstElement(of: child2d)) == 6
+                    expect(global.indexForFirstElement(of: child2e)) == 9
+                    expect(global.indexForFirstElement(of: child2f)) == 9
+                    expect(global.indexForFirstElement(of: child2g)) == 12
+                    expect(global.indexForFirstElement(of: child2h)) == 12
+                    expect(global.indexForFirstElement(of: child3)) == 15
+                    expect(global.indexForFirstElement(of: newSection)) == 18
+                    expect(global.indexForFirstElement(of: child4)) == 20
+                    expect(global.indexForFirstElement(of: child5)) == 22
+                }
+
+                it("should return the correct section for element index") {
+                    expect(global.sectionForElementIndex(0)?.section) === child1a
+                    expect(global.sectionForElementIndex(1)?.section) === child1a
+                    expect(global.sectionForElementIndex(2)?.section) === child1b
+                    expect(global.sectionForElementIndex(3)?.section) === child1b
+                    expect(global.sectionForElementIndex(4)?.section) === child1b
+                    expect(global.sectionForElementIndex(5)?.section) === child2b
+                    expect(global.sectionForElementIndex(6)?.section) === child2d
+                    expect(global.sectionForElementIndex(7)?.section) === child2d
+                    expect(global.sectionForElementIndex(8)?.section) === child2d
+                    expect(global.sectionForElementIndex(9)?.section) === child2f
+                    expect(global.sectionForElementIndex(10)?.section) === child2f
+                    expect(global.sectionForElementIndex(11)?.section) === child2f
+                    expect(global.sectionForElementIndex(12)?.section) === child2h
+                    expect(global.sectionForElementIndex(13)?.section) === child2h
+                    expect(global.sectionForElementIndex(14)?.section) === child2h
+                    expect(global.sectionForElementIndex(15)?.section) === child3
+                    expect(global.sectionForElementIndex(16)?.section) === child3
+                    expect(global.sectionForElementIndex(17)?.section) === child3
+                    expect(global.sectionForElementIndex(18)?.section) === newSection
+                    expect(global.sectionForElementIndex(19)?.section) === newSection
+                    expect(global.sectionForElementIndex(20)?.section) === child4
+                    expect(global.sectionForElementIndex(21)?.section) === child4
+                }
+
+                it("should return the correct child indexes") {
+                    expect(global.childIndex(of: child1)) == 0
+                    expect(global.childIndex(of: child1a)).to(beNil())
+                    expect(global.childIndex(of: child1b)).to(beNil())
+                    expect(global.childIndex(of: child2)) == 1
+                    expect(global.childIndex(of: child2a)).to(beNil())
+                    expect(global.childIndex(of: child2b)).to(beNil())
+                    expect(global.childIndex(of: child2c)).to(beNil())
+                    expect(global.childIndex(of: child2d)).to(beNil())
+                    expect(global.childIndex(of: child2e)).to(beNil())
+                    expect(global.childIndex(of: child2f)).to(beNil())
+                    expect(global.childIndex(of: child2g)).to(beNil())
+                    expect(global.childIndex(of: child2h)).to(beNil())
+                    expect(global.childIndex(of: child3)) == 2
+                    expect(global.childIndex(of: newSection)) == 3
+                    expect(global.childIndex(of: child4)) == 4
+                    expect(global.childIndex(of: child5)) == 5
+                }
+
+                it("should make correct delegate calls") {
+                    expect(mockDelegate.didInsertElementCalls.count) == 2
+                    expect(mockDelegate.didInsertElementCalls[0].section) === global
+                    expect(mockDelegate.didInsertElementCalls[0].index) == 18
+                    expect(mockDelegate.didInsertElementCalls[1].section) === global
+                    expect(mockDelegate.didInsertElementCalls[1].index) == 19
+                }
+            }
+
+            context("after a section has been inserted at a set index") {
+                var mockDelegate: MockSectionUpdateDelegate!
+                var newSection: ArraySection<String>!
+
+                beforeEach {
+                    mockDelegate = MockSectionUpdateDelegate()
+                    global.updateDelegate = mockDelegate
+
+                    newSection = ArraySection(["new section index 0", "new section index 1"])
+
+                    global.insert(newSection, at: 3)
+                }
+
+                it("should contain 22 elements") {
+                    expect(global.numberOfElements) == 22
+                }
+
+                it("should return the correct first element indexes") {
+                    expect(global.indexForFirstElement(of: child1)) == 0
+                    expect(global.indexForFirstElement(of: child1a)) == 0
+                    expect(global.indexForFirstElement(of: child1b)) == 2
+                    expect(global.indexForFirstElement(of: child2)) == 5
+                    expect(global.indexForFirstElement(of: child2a)) == 5
+                    expect(global.indexForFirstElement(of: child2b)) == 5
+                    expect(global.indexForFirstElement(of: child2c)) == 6
+                    expect(global.indexForFirstElement(of: child2d)) == 6
+                    expect(global.indexForFirstElement(of: child2e)) == 9
+                    expect(global.indexForFirstElement(of: child2f)) == 9
+                    expect(global.indexForFirstElement(of: child2g)) == 12
+                    expect(global.indexForFirstElement(of: child2h)) == 12
+                    expect(global.indexForFirstElement(of: child3)) == 15
+                    expect(global.indexForFirstElement(of: newSection)) == 18
+                    expect(global.indexForFirstElement(of: child4)) == 20
+                    expect(global.indexForFirstElement(of: child5)) == 22
+                }
+
+                it("should return the correct section for element index") {
+                    expect(global.sectionForElementIndex(0)?.section) === child1a
+                    expect(global.sectionForElementIndex(1)?.section) === child1a
+                    expect(global.sectionForElementIndex(2)?.section) === child1b
+                    expect(global.sectionForElementIndex(3)?.section) === child1b
+                    expect(global.sectionForElementIndex(4)?.section) === child1b
+                    expect(global.sectionForElementIndex(5)?.section) === child2b
+                    expect(global.sectionForElementIndex(6)?.section) === child2d
+                    expect(global.sectionForElementIndex(7)?.section) === child2d
+                    expect(global.sectionForElementIndex(8)?.section) === child2d
+                    expect(global.sectionForElementIndex(9)?.section) === child2f
+                    expect(global.sectionForElementIndex(10)?.section) === child2f
+                    expect(global.sectionForElementIndex(11)?.section) === child2f
+                    expect(global.sectionForElementIndex(12)?.section) === child2h
+                    expect(global.sectionForElementIndex(13)?.section) === child2h
+                    expect(global.sectionForElementIndex(14)?.section) === child2h
+                    expect(global.sectionForElementIndex(15)?.section) === child3
+                    expect(global.sectionForElementIndex(16)?.section) === child3
+                    expect(global.sectionForElementIndex(17)?.section) === child3
+                    expect(global.sectionForElementIndex(18)?.section) === newSection
+                    expect(global.sectionForElementIndex(19)?.section) === newSection
+                    expect(global.sectionForElementIndex(20)?.section) === child4
+                    expect(global.sectionForElementIndex(21)?.section) === child4
+                }
+
+                it("should return the correct child indexes") {
+                    expect(global.childIndex(of: child1)) == 0
+                    expect(global.childIndex(of: child1a)).to(beNil())
+                    expect(global.childIndex(of: child1b)).to(beNil())
+                    expect(global.childIndex(of: child2)) == 1
+                    expect(global.childIndex(of: child2a)).to(beNil())
+                    expect(global.childIndex(of: child2b)).to(beNil())
+                    expect(global.childIndex(of: child2c)).to(beNil())
+                    expect(global.childIndex(of: child2d)).to(beNil())
+                    expect(global.childIndex(of: child2e)).to(beNil())
+                    expect(global.childIndex(of: child2f)).to(beNil())
+                    expect(global.childIndex(of: child2g)).to(beNil())
+                    expect(global.childIndex(of: child2h)).to(beNil())
+                    expect(global.childIndex(of: child3)) == 2
+                    expect(global.childIndex(of: newSection)) == 3
+                    expect(global.childIndex(of: child4)) == 4
+                    expect(global.childIndex(of: child5)) == 5
+                }
+
+                it("should make correct delegate calls") {
+                    expect(mockDelegate.didInsertElementCalls.count) == 2
+                    expect(mockDelegate.didInsertElementCalls[0].section) === global
+                    expect(mockDelegate.didInsertElementCalls[0].index) == 18
+                    expect(mockDelegate.didInsertElementCalls[1].section) === global
+                    expect(mockDelegate.didInsertElementCalls[1].index) == 19
+                }
+            }
+
+            context("after a section has been inserted at index 0") {
+                var mockDelegate: MockSectionUpdateDelegate!
+                var newSection: ArraySection<String>!
+
+                beforeEach {
+                    mockDelegate = MockSectionUpdateDelegate()
+                    global.updateDelegate = mockDelegate
+
+                    newSection = ArraySection(["new section index 0", "new section index 1"])
+
+                    global.insert(newSection, at: 0)
+                }
+
+                it("should contain 22 elements") {
+                    expect(global.numberOfElements) == 22
+                }
+
+                it("should return the correct first element indexes") {
+                    expect(global.indexForFirstElement(of: newSection)) == 0
+                    expect(global.indexForFirstElement(of: child1)) == 2
+                    expect(global.indexForFirstElement(of: child1a)) == 2
+                    expect(global.indexForFirstElement(of: child1b)) == 4
+                    expect(global.indexForFirstElement(of: child2)) == 7
+                    expect(global.indexForFirstElement(of: child2a)) == 7
+                    expect(global.indexForFirstElement(of: child2b)) == 7
+                    expect(global.indexForFirstElement(of: child2c)) == 8
+                    expect(global.indexForFirstElement(of: child2d)) == 8
+                    expect(global.indexForFirstElement(of: child2e)) == 11
+                    expect(global.indexForFirstElement(of: child2f)) == 11
+                    expect(global.indexForFirstElement(of: child2g)) == 14
+                    expect(global.indexForFirstElement(of: child2h)) == 14
+                    expect(global.indexForFirstElement(of: child3)) == 17
+                    expect(global.indexForFirstElement(of: child4)) == 20
+                    expect(global.indexForFirstElement(of: child5)) == 22
+                }
+
+                it("should return the correct section for element index") {
+                    expect(global.sectionForElementIndex(0)?.section) === newSection
+                    expect(global.sectionForElementIndex(1)?.section) === newSection
+                    expect(global.sectionForElementIndex(2)?.section) === child1a
+                    expect(global.sectionForElementIndex(3)?.section) === child1a
+                    expect(global.sectionForElementIndex(4)?.section) === child1b
+                    expect(global.sectionForElementIndex(5)?.section) === child1b
+                    expect(global.sectionForElementIndex(6)?.section) === child1b
+                    expect(global.sectionForElementIndex(7)?.section) === child2b
+                    expect(global.sectionForElementIndex(8)?.section) === child2d
+                    expect(global.sectionForElementIndex(9)?.section) === child2d
+                    expect(global.sectionForElementIndex(10)?.section) === child2d
+                    expect(global.sectionForElementIndex(11)?.section) === child2f
+                    expect(global.sectionForElementIndex(12)?.section) === child2f
+                    expect(global.sectionForElementIndex(13)?.section) === child2f
+                    expect(global.sectionForElementIndex(14)?.section) === child2h
+                    expect(global.sectionForElementIndex(15)?.section) === child2h
+                    expect(global.sectionForElementIndex(16)?.section) === child2h
+                    expect(global.sectionForElementIndex(17)?.section) === child3
+                    expect(global.sectionForElementIndex(18)?.section) === child3
+                    expect(global.sectionForElementIndex(19)?.section) === child3
+                    expect(global.sectionForElementIndex(20)?.section) === child4
+                    expect(global.sectionForElementIndex(21)?.section) === child4
+                }
+
+                it("should return the correct child indexes") {
+                    expect(global.childIndex(of: newSection)) == 0
+                    expect(global.childIndex(of: child1)) == 1
+                    expect(global.childIndex(of: child1a)).to(beNil())
+                    expect(global.childIndex(of: child1b)).to(beNil())
+                    expect(global.childIndex(of: child2)) == 2
+                    expect(global.childIndex(of: child2a)).to(beNil())
+                    expect(global.childIndex(of: child2b)).to(beNil())
+                    expect(global.childIndex(of: child2c)).to(beNil())
+                    expect(global.childIndex(of: child2d)).to(beNil())
+                    expect(global.childIndex(of: child2e)).to(beNil())
+                    expect(global.childIndex(of: child2f)).to(beNil())
+                    expect(global.childIndex(of: child2g)).to(beNil())
+                    expect(global.childIndex(of: child2h)).to(beNil())
+                    expect(global.childIndex(of: child3)) == 3
+                    expect(global.childIndex(of: child4)) == 4
+                    expect(global.childIndex(of: child5)) == 5
+                }
+
+                it("should make correct delegate calls") {
+                    expect(mockDelegate.didInsertElementCalls.count) == 2
+                    expect(mockDelegate.didInsertElementCalls[0].section) === global
+                    expect(mockDelegate.didInsertElementCalls[0].index) == 0
+                    expect(mockDelegate.didInsertElementCalls[1].section) === global
+                    expect(mockDelegate.didInsertElementCalls[1].index) == 1
+                }
+            }
+
+            context("after a section has been inserted at a final index") {
+                var mockDelegate: MockSectionUpdateDelegate!
+                var newSection: ArraySection<String>!
+
+                beforeEach {
+                    mockDelegate = MockSectionUpdateDelegate()
+                    global.updateDelegate = mockDelegate
+
+                    newSection = ArraySection(["new section index 0", "new section index 1"])
+
+                    global.insert(newSection, at: 5)
+                }
+
+                it("should contain 22 elements") {
+                    expect(global.numberOfElements) == 22
+                }
+
+                it("should return the correct first element indexes") {
+                    expect(global.indexForFirstElement(of: child1)) == 0
+                    expect(global.indexForFirstElement(of: child1a)) == 0
+                    expect(global.indexForFirstElement(of: child1b)) == 2
+                    expect(global.indexForFirstElement(of: child2)) == 5
+                    expect(global.indexForFirstElement(of: child2a)) == 5
+                    expect(global.indexForFirstElement(of: child2b)) == 5
+                    expect(global.indexForFirstElement(of: child2c)) == 6
+                    expect(global.indexForFirstElement(of: child2d)) == 6
+                    expect(global.indexForFirstElement(of: child2e)) == 9
+                    expect(global.indexForFirstElement(of: child2f)) == 9
+                    expect(global.indexForFirstElement(of: child2g)) == 12
+                    expect(global.indexForFirstElement(of: child2h)) == 12
+                    expect(global.indexForFirstElement(of: child3)) == 15
+                    expect(global.indexForFirstElement(of: child4)) == 18
+                    expect(global.indexForFirstElement(of: child5)) == 20
+                    expect(global.indexForFirstElement(of: newSection)) == 20
+                }
+
+                it("should return the correct section for element index") {
+                    expect(global.sectionForElementIndex(0)?.section) === child1a
+                    expect(global.sectionForElementIndex(1)?.section) === child1a
+                    expect(global.sectionForElementIndex(2)?.section) === child1b
+                    expect(global.sectionForElementIndex(3)?.section) === child1b
+                    expect(global.sectionForElementIndex(4)?.section) === child1b
+                    expect(global.sectionForElementIndex(5)?.section) === child2b
+                    expect(global.sectionForElementIndex(6)?.section) === child2d
+                    expect(global.sectionForElementIndex(7)?.section) === child2d
+                    expect(global.sectionForElementIndex(8)?.section) === child2d
+                    expect(global.sectionForElementIndex(9)?.section) === child2f
+                    expect(global.sectionForElementIndex(10)?.section) === child2f
+                    expect(global.sectionForElementIndex(11)?.section) === child2f
+                    expect(global.sectionForElementIndex(12)?.section) === child2h
+                    expect(global.sectionForElementIndex(13)?.section) === child2h
+                    expect(global.sectionForElementIndex(14)?.section) === child2h
+                    expect(global.sectionForElementIndex(15)?.section) === child3
+                    expect(global.sectionForElementIndex(16)?.section) === child3
+                    expect(global.sectionForElementIndex(17)?.section) === child3
+                    expect(global.sectionForElementIndex(18)?.section) === child4
+                    expect(global.sectionForElementIndex(19)?.section) === child4
+                    expect(global.sectionForElementIndex(20)?.section) === newSection
+                    expect(global.sectionForElementIndex(21)?.section) === newSection
+                }
+
+                it("should return the correct child indexes") {
+                    expect(global.childIndex(of: child1)) == 0
+                    expect(global.childIndex(of: child1a)).to(beNil())
+                    expect(global.childIndex(of: child1b)).to(beNil())
+                    expect(global.childIndex(of: child2)) == 1
+                    expect(global.childIndex(of: child2a)).to(beNil())
+                    expect(global.childIndex(of: child2b)).to(beNil())
+                    expect(global.childIndex(of: child2c)).to(beNil())
+                    expect(global.childIndex(of: child2d)).to(beNil())
+                    expect(global.childIndex(of: child2e)).to(beNil())
+                    expect(global.childIndex(of: child2f)).to(beNil())
+                    expect(global.childIndex(of: child2g)).to(beNil())
+                    expect(global.childIndex(of: child2h)).to(beNil())
+                    expect(global.childIndex(of: child3)) == 2
+                    expect(global.childIndex(of: child4)) == 3
+                    expect(global.childIndex(of: child5)) == 4
+                    expect(global.childIndex(of: newSection)) == 5
+                }
+
+                it("should make correct delegate calls") {
+                    expect(mockDelegate.didInsertElementCalls.count) == 2
+                    expect(mockDelegate.didInsertElementCalls[0].section) === global
+                    expect(mockDelegate.didInsertElementCalls[0].index) == 20
+                    expect(mockDelegate.didInsertElementCalls[1].section) === global
+                    expect(mockDelegate.didInsertElementCalls[1].index) == 21
+                }
+            }
+
+            context("after a section has been inserted in a child section provider") {
+                var mockDelegate: MockSectionUpdateDelegate!
+                var newSection: ArraySection<String>!
+
+                beforeEach {
+                    mockDelegate = MockSectionUpdateDelegate()
+                    global.updateDelegate = mockDelegate
+
+                    newSection = ArraySection(["new section index 0", "new section index 1"])
+
+                    child1.insert(newSection, at: 1)
+                }
+
+                it("should contain 22 elements") {
+                    expect(global.numberOfElements) == 22
+                }
+
+                it("should return the correct first element indexes") {
+                    expect(global.indexForFirstElement(of: child1)) == 0
+                    expect(global.indexForFirstElement(of: child1a)) == 0
+                    expect(global.indexForFirstElement(of: newSection)) == 2
+                    expect(global.indexForFirstElement(of: child1b)) == 4
+                    expect(global.indexForFirstElement(of: child2)) == 7
+                    expect(global.indexForFirstElement(of: child2a)) == 7
+                    expect(global.indexForFirstElement(of: child2b)) == 7
+                    expect(global.indexForFirstElement(of: child2c)) == 8
+                    expect(global.indexForFirstElement(of: child2d)) == 8
+                    expect(global.indexForFirstElement(of: child2e)) == 11
+                    expect(global.indexForFirstElement(of: child2f)) == 11
+                    expect(global.indexForFirstElement(of: child2g)) == 14
+                    expect(global.indexForFirstElement(of: child2h)) == 14
+                    expect(global.indexForFirstElement(of: child3)) == 17
+                    expect(global.indexForFirstElement(of: child4)) == 20
+                    expect(global.indexForFirstElement(of: child5)) == 22
+                }
+
+                it("should return the correct section for element index") {
+                    expect(global.sectionForElementIndex(0)?.section) === child1a
+                    expect(global.sectionForElementIndex(1)?.section) === child1a
+                    expect(global.sectionForElementIndex(2)?.section) === newSection
+                    expect(global.sectionForElementIndex(3)?.section) === newSection
+                    expect(global.sectionForElementIndex(4)?.section) === child1b
+                    expect(global.sectionForElementIndex(5)?.section) === child1b
+                    expect(global.sectionForElementIndex(6)?.section) === child1b
+                    expect(global.sectionForElementIndex(7)?.section) === child2b
+                    expect(global.sectionForElementIndex(8)?.section) === child2d
+                    expect(global.sectionForElementIndex(9)?.section) === child2d
+                    expect(global.sectionForElementIndex(10)?.section) === child2d
+                    expect(global.sectionForElementIndex(11)?.section) === child2f
+                    expect(global.sectionForElementIndex(12)?.section) === child2f
+                    expect(global.sectionForElementIndex(13)?.section) === child2f
+                    expect(global.sectionForElementIndex(14)?.section) === child2h
+                    expect(global.sectionForElementIndex(15)?.section) === child2h
+                    expect(global.sectionForElementIndex(16)?.section) === child2h
+                    expect(global.sectionForElementIndex(17)?.section) === child3
+                    expect(global.sectionForElementIndex(18)?.section) === child3
+                    expect(global.sectionForElementIndex(19)?.section) === child3
+                    expect(global.sectionForElementIndex(20)?.section) === child4
+                    expect(global.sectionForElementIndex(21)?.section) === child4
+                }
+
+                it("should return the correct child indexes") {
+                    expect(global.childIndex(of: child1)) == 0
+                    expect(global.childIndex(of: child1a)).to(beNil())
+                    expect(global.childIndex(of: newSection)).to(beNil())
+                    expect(global.childIndex(of: child1b)).to(beNil())
+                    expect(global.childIndex(of: child2)) == 1
+                    expect(global.childIndex(of: child2a)).to(beNil())
+                    expect(global.childIndex(of: child2b)).to(beNil())
+                    expect(global.childIndex(of: child2c)).to(beNil())
+                    expect(global.childIndex(of: child2d)).to(beNil())
+                    expect(global.childIndex(of: child2e)).to(beNil())
+                    expect(global.childIndex(of: child2f)).to(beNil())
+                    expect(global.childIndex(of: child2g)).to(beNil())
+                    expect(global.childIndex(of: child2h)).to(beNil())
+                    expect(global.childIndex(of: child3)) == 2
+                    expect(global.childIndex(of: child4)) == 3
+                    expect(global.childIndex(of: child5)) == 4
+                }
+
+                it("should make correct delegate calls") {
+                    expect(mockDelegate.didInsertElementCalls.count) == 2
+                    expect(mockDelegate.didInsertElementCalls[0].section) === global
+                    expect(mockDelegate.didInsertElementCalls[0].index) == 2
+                    expect(mockDelegate.didInsertElementCalls[1].section) === global
+                    expect(mockDelegate.didInsertElementCalls[1].index) == 3
+                }
+
+                context("elements inserted in that child should be propagated") {
+                    beforeEach {
+                        mockDelegate = MockSectionUpdateDelegate()
+                        global.updateDelegate = mockDelegate
+
+                        newSection.append("new section index 2")
+                    }
+
+                    it("should make correct delegate calls") {
+                        expect(mockDelegate.didInsertElementCalls.count) == 1
+                        expect(mockDelegate.didInsertElementCalls[0].section) === global
+                        expect(mockDelegate.didInsertElementCalls[0].index) == 4
+                    }
+                }
+
+                context("elements removed from that child should be propagated") {
+                    beforeEach {
+                        mockDelegate = MockSectionUpdateDelegate()
+                        global.updateDelegate = mockDelegate
+
+                        newSection.removeLast()
+                    }
+
+                    it("should make correct delegate calls") {
+                        expect(mockDelegate.didRemoveElementCalls.count) == 1
+                        expect(mockDelegate.didRemoveElementCalls[0].section) === global
+                        expect(mockDelegate.didRemoveElementCalls[0].index) == 3
+                    }
+                }
+            }
+
+            context("after a section has been removed from a child section provider") {
+                var mockDelegate: MockSectionUpdateDelegate!
+                var removedSection: ArraySection<String>!
+
+                beforeEach {
+                    mockDelegate = MockSectionUpdateDelegate()
+                    global.updateDelegate = mockDelegate
+
+                    removedSection = child1a
+
+                    child1.remove(removedSection)
+                }
+
+                it("should contain 18 elements") {
+                    expect(global.numberOfElements) == 18
+                }
+
+                it("should return the correct first element indexes") {
+                    expect(global.indexForFirstElement(of: child1)) == 0
+                    expect(global.indexForFirstElement(of: removedSection)).to(beNil())
+                    expect(global.indexForFirstElement(of: child1b)) == 0
+                    expect(global.indexForFirstElement(of: child2)) == 3
+                    expect(global.indexForFirstElement(of: child2a)) == 3
+                    expect(global.indexForFirstElement(of: child2b)) == 3
+                    expect(global.indexForFirstElement(of: child2c)) == 4
+                    expect(global.indexForFirstElement(of: child2d)) == 4
+                    expect(global.indexForFirstElement(of: child2e)) == 7
+                    expect(global.indexForFirstElement(of: child2f)) == 7
+                    expect(global.indexForFirstElement(of: child2g)) == 10
+                    expect(global.indexForFirstElement(of: child2h)) == 10
+                    expect(global.indexForFirstElement(of: child3)) == 13
+                    expect(global.indexForFirstElement(of: child4)) == 16
+                    expect(global.indexForFirstElement(of: child5)) == 18
+                }
+
+                it("should return the correct section for element index") {
+                    expect(global.sectionForElementIndex(0)?.section) === child1b
+                    expect(global.sectionForElementIndex(1)?.section) === child1b
+                    expect(global.sectionForElementIndex(2)?.section) === child1b
+                    expect(global.sectionForElementIndex(3)?.section) === child2b
+                    expect(global.sectionForElementIndex(4)?.section) === child2d
+                    expect(global.sectionForElementIndex(5)?.section) === child2d
+                    expect(global.sectionForElementIndex(6)?.section) === child2d
+                    expect(global.sectionForElementIndex(7)?.section) === child2f
+                    expect(global.sectionForElementIndex(8)?.section) === child2f
+                    expect(global.sectionForElementIndex(9)?.section) === child2f
+                    expect(global.sectionForElementIndex(10)?.section) === child2h
+                    expect(global.sectionForElementIndex(11)?.section) === child2h
+                    expect(global.sectionForElementIndex(12)?.section) === child2h
+                    expect(global.sectionForElementIndex(13)?.section) === child3
+                    expect(global.sectionForElementIndex(14)?.section) === child3
+                    expect(global.sectionForElementIndex(15)?.section) === child3
+                    expect(global.sectionForElementIndex(16)?.section) === child4
+                    expect(global.sectionForElementIndex(17)?.section) === child4
+                }
+
+                it("should return the correct child indexes") {
+                    expect(global.childIndex(of: child1)) == 0
+                    expect(global.childIndex(of: removedSection)).to(beNil())
+                    expect(global.childIndex(of: child1b)).to(beNil())
+                    expect(global.childIndex(of: child2)) == 1
+                    expect(global.childIndex(of: child2a)).to(beNil())
+                    expect(global.childIndex(of: child2b)).to(beNil())
+                    expect(global.childIndex(of: child2c)).to(beNil())
+                    expect(global.childIndex(of: child2d)).to(beNil())
+                    expect(global.childIndex(of: child2e)).to(beNil())
+                    expect(global.childIndex(of: child2f)).to(beNil())
+                    expect(global.childIndex(of: child2g)).to(beNil())
+                    expect(global.childIndex(of: child2h)).to(beNil())
+                    expect(global.childIndex(of: child3)) == 2
+                    expect(global.childIndex(of: child4)) == 3
+                    expect(global.childIndex(of: child5)) == 4
+                }
+
+                it("should make correct delegate calls") {
+                    expect(mockDelegate.didRemoveElementCalls.count) == 2
+                    expect(mockDelegate.didRemoveElementCalls[0].section) === global
+                    expect(mockDelegate.didRemoveElementCalls[0].index) == 1
+                    expect(mockDelegate.didRemoveElementCalls[1].section) === global
+                    expect(mockDelegate.didRemoveElementCalls[1].index) == 0
+                }
+            }
+        }
+    }
+
+}
+
+private final class MockSectionUpdateDelegate: SectionUpdateDelegate {
+    private(set) var willBeginUpdatingCalls: [Section] = []
+    private(set) var didEndUpdatingCalls: [Section] = []
+    private(set) var invalidateAllCalls: [Section] = []
+    private(set) var didInsertElementCalls: [(section: Section, index: Int)] = []
+    private(set) var didRemoveElementCalls: [(section: Section, index: Int)] = []
+
+    func willBeginUpdating(_ section: Section) {
+        willBeginUpdatingCalls.append(section)
+    }
+
+    func didEndUpdating(_ section: Section) {
+        didEndUpdatingCalls.append(section)
+    }
+
+    func invalidateAll(_ section: Section) {
+        invalidateAllCalls.append(section)
+    }
+
+    func section(_ section: Section, didInsertElementAt index: Int) {
+        didInsertElementCalls.append((section, index))
+    }
+
+    func section(_ section: Section, didRemoveElementAt index: Int) {
+        didRemoveElementCalls.append((section, index))
+    }
+
+    func section(_ section: Section, didUpdateElementAt index: Int) {}
+
+    func section(_ section: Section, didMoveElementAt index: Int, to newIndex: Int) {}
+
+    func selectedIndexes(in section: Section) -> [Int] { [] }
+
+    func section(_ section: Section, select index: Int) {}
+
+    func section(_ section: Section, deselect index: Int) {}
+
+    func section(_ section: Section, move sourceIndex: Int, to destinationIndex: Int) {}
+
+    func sectionDidInvalidateHeader(_ section: Section) {}
+    func sectionDidInvalidateFooter(_ section: Section) {}
+}
diff --git a/Tests/ComposedTests/SectionProviderMapper+Spec.swift b/Tests/ComposedTests/SectionProviderMapper+Spec.swift
index 299faf1..6d83abd 100644
--- a/Tests/ComposedTests/SectionProviderMapper+Spec.swift
+++ b/Tests/ComposedTests/SectionProviderMapper+Spec.swift
@@ -110,7 +110,6 @@ final class SectionProviderMapping_Spec: QuickSpec {
 }
 
 final class MockSectionProviderMappingDelegate: SectionProviderMappingDelegate {
-
     var didInsertSections: (mapping: SectionProviderMapping, sections: IndexSet)?
     var didInsertElements: (section: SectionProviderMapping, indexPaths: [IndexPath])?
 
@@ -167,4 +166,6 @@ final class MockSectionProviderMappingDelegate: SectionProviderMappingDelegate {
     func mappingDidInvalidate(_ mapping: SectionProviderMapping) {}
     func mapping(_ mapping: SectionProviderMapping, move sourceIndexPath: IndexPath, to destinationIndexPath: IndexPath) {}
 
+    func mappingDidInvalidateHeader(at sectionIndex: Int) {}
+    func mappingDidInvalidateFooter(at sectionIndex: Int) {}
 }