diff --git a/src/common/SerialMap.h b/src/common/SerialMap.h
index 93b0019789..fe3ca18891 100644
--- a/src/common/SerialMap.h
+++ b/src/common/SerialMap.h
@@ -20,54 +20,55 @@
 #include <map>
 #include <vector>
 
-template <typename T>
+template <typename Serial, typename Value>
 class SerialMap;
 
-template <typename T>
-struct SerialStorageTraits<SerialMap<T>> {
-    using Value = T;
-    using Storage = std::map<Serial, std::vector<T>>;
+template <typename SerialT, typename ValueT>
+struct SerialStorageTraits<SerialMap<SerialT, ValueT>> {
+    using Serial = SerialT;
+    using Value = ValueT;
+    using Storage = std::map<Serial, std::vector<Value>>;
     using StorageIterator = typename Storage::iterator;
     using ConstStorageIterator = typename Storage::const_iterator;
 };
 
-// SerialMap stores a map from Serial to T.
+// SerialMap stores a map from Serial to Value.
 // Unlike SerialQueue, items may be enqueued with Serials in any
 // arbitrary order. SerialMap provides useful iterators for iterating
-// through T items in order of increasing Serial.
-template <typename T>
-class SerialMap : public SerialStorage<SerialMap<T>> {
+// through Value items in order of increasing Serial.
+template <typename Serial, typename Value>
+class SerialMap : public SerialStorage<SerialMap<Serial, Value>> {
   public:
-    void Enqueue(const T& value, Serial serial);
-    void Enqueue(T&& value, Serial serial);
-    void Enqueue(const std::vector<T>& values, Serial serial);
-    void Enqueue(std::vector<T>&& values, Serial serial);
+    void Enqueue(const Value& value, Serial serial);
+    void Enqueue(Value&& value, Serial serial);
+    void Enqueue(const std::vector<Value>& values, Serial serial);
+    void Enqueue(std::vector<Value>&& values, Serial serial);
 };
 
 // SerialMap
 
-template <typename T>
-void SerialMap<T>::Enqueue(const T& value, Serial serial) {
+template <typename Serial, typename Value>
+void SerialMap<Serial, Value>::Enqueue(const Value& value, Serial serial) {
     this->mStorage[serial].emplace_back(value);
 }
 
-template <typename T>
-void SerialMap<T>::Enqueue(T&& value, Serial serial) {
+template <typename Serial, typename Value>
+void SerialMap<Serial, Value>::Enqueue(Value&& value, Serial serial) {
     this->mStorage[serial].emplace_back(value);
 }
 
-template <typename T>
-void SerialMap<T>::Enqueue(const std::vector<T>& values, Serial serial) {
+template <typename Serial, typename Value>
+void SerialMap<Serial, Value>::Enqueue(const std::vector<Value>& values, Serial serial) {
     DAWN_ASSERT(values.size() > 0);
-    for (const T& value : values) {
+    for (const Value& value : values) {
         Enqueue(value, serial);
     }
 }
 
-template <typename T>
-void SerialMap<T>::Enqueue(std::vector<T>&& values, Serial serial) {
+template <typename Serial, typename Value>
+void SerialMap<Serial, Value>::Enqueue(std::vector<Value>&& values, Serial serial) {
     DAWN_ASSERT(values.size() > 0);
-    for (const T& value : values) {
+    for (const Value& value : values) {
         Enqueue(value, serial);
     }
 }
diff --git a/src/common/SerialQueue.h b/src/common/SerialQueue.h
index 24303c7f60..5f2494786b 100644
--- a/src/common/SerialQueue.h
+++ b/src/common/SerialQueue.h
@@ -19,65 +19,65 @@
 
 #include <vector>
 
-template <typename T>
+template <typename Serial, typename Value>
 class SerialQueue;
 
-template <typename T>
-struct SerialStorageTraits<SerialQueue<T>> {
-    using Value = T;
-    using SerialPair = std::pair<Serial, std::vector<T>>;
+template <typename SerialT, typename ValueT>
+struct SerialStorageTraits<SerialQueue<SerialT, ValueT>> {
+    using Serial = SerialT;
+    using Value = ValueT;
+    using SerialPair = std::pair<Serial, std::vector<Value>>;
     using Storage = std::vector<SerialPair>;
     using StorageIterator = typename Storage::iterator;
     using ConstStorageIterator = typename Storage::const_iterator;
 };
 
-// SerialQueue stores an associative list mapping a Serial to T.
+// SerialQueue stores an associative list mapping a Serial to Value.
 // It enforces that the Serials enqueued are strictly non-decreasing.
 // This makes it very efficient iterate or clear all items added up
 // to some Serial value because they are stored contiguously in memory.
-template <typename T>
-class SerialQueue : public SerialStorage<SerialQueue<T>> {
+template <typename Serial, typename Value>
+class SerialQueue : public SerialStorage<SerialQueue<Serial, Value>> {
   public:
-    using SerialPair = typename SerialStorageTraits<SerialQueue<T>>::SerialPair;
 
     // The serial must be given in (not strictly) increasing order.
-    void Enqueue(const T& value, Serial serial);
-    void Enqueue(T&& value, Serial serial);
-    void Enqueue(const std::vector<T>& values, Serial serial);
-    void Enqueue(std::vector<T>&& values, Serial serial);
+    void Enqueue(const Value& value, Serial serial);
+    void Enqueue(Value&& value, Serial serial);
+    void Enqueue(const std::vector<Value>& values, Serial serial);
+    void Enqueue(std::vector<Value>&& values, Serial serial);
 };
 
 // SerialQueue
 
-template <typename T>
-void SerialQueue<T>::Enqueue(const T& value, Serial serial) {
+template <typename Serial, typename Value>
+void SerialQueue<Serial, Value>::Enqueue(const Value& value, Serial serial) {
     DAWN_ASSERT(this->Empty() || this->mStorage.back().first <= serial);
 
     if (this->Empty() || this->mStorage.back().first < serial) {
-        this->mStorage.emplace_back(serial, std::vector<T>{});
+        this->mStorage.emplace_back(serial, std::vector<Value>{});
     }
     this->mStorage.back().second.push_back(value);
 }
 
-template <typename T>
-void SerialQueue<T>::Enqueue(T&& value, Serial serial) {
+template <typename Serial, typename Value>
+void SerialQueue<Serial, Value>::Enqueue(Value&& value, Serial serial) {
     DAWN_ASSERT(this->Empty() || this->mStorage.back().first <= serial);
 
     if (this->Empty() || this->mStorage.back().first < serial) {
-        this->mStorage.emplace_back(serial, std::vector<T>{});
+        this->mStorage.emplace_back(serial, std::vector<Value>{});
     }
     this->mStorage.back().second.push_back(std::move(value));
 }
 
-template <typename T>
-void SerialQueue<T>::Enqueue(const std::vector<T>& values, Serial serial) {
+template <typename Serial, typename Value>
+void SerialQueue<Serial, Value>::Enqueue(const std::vector<Value>& values, Serial serial) {
     DAWN_ASSERT(values.size() > 0);
     DAWN_ASSERT(this->Empty() || this->mStorage.back().first <= serial);
     this->mStorage.emplace_back(serial, values);
 }
 
-template <typename T>
-void SerialQueue<T>::Enqueue(std::vector<T>&& values, Serial serial) {
+template <typename Serial, typename Value>
+void SerialQueue<Serial, Value>::Enqueue(std::vector<Value>&& values, Serial serial) {
     DAWN_ASSERT(values.size() > 0);
     DAWN_ASSERT(this->Empty() || this->mStorage.back().first <= serial);
     this->mStorage.emplace_back(serial, values);
diff --git a/src/common/SerialStorage.h b/src/common/SerialStorage.h
index d71c7dd07d..4ff18f2f09 100644
--- a/src/common/SerialStorage.h
+++ b/src/common/SerialStorage.h
@@ -27,6 +27,7 @@ struct SerialStorageTraits {};
 template <typename Derived>
 class SerialStorage {
   private:
+    using Serial = typename SerialStorageTraits<Derived>::Serial;
     using Value = typename SerialStorageTraits<Derived>::Value;
     using Storage = typename SerialStorageTraits<Derived>::Storage;
     using StorageIterator = typename SerialStorageTraits<Derived>::StorageIterator;
@@ -158,13 +159,13 @@ void SerialStorage<Derived>::ClearUpTo(Serial serial) {
 }
 
 template <typename Derived>
-Serial SerialStorage<Derived>::FirstSerial() const {
+typename SerialStorage<Derived>::Serial SerialStorage<Derived>::FirstSerial() const {
     DAWN_ASSERT(!Empty());
     return mStorage.begin()->first;
 }
 
 template <typename Derived>
-Serial SerialStorage<Derived>::LastSerial() const {
+typename SerialStorage<Derived>::Serial SerialStorage<Derived>::LastSerial() const {
     DAWN_ASSERT(!Empty());
     return mStorage.back().first;
 }
diff --git a/src/dawn_native/DynamicUploader.h b/src/dawn_native/DynamicUploader.h
index a652bd8853..d58e425a10 100644
--- a/src/dawn_native/DynamicUploader.h
+++ b/src/dawn_native/DynamicUploader.h
@@ -56,7 +56,7 @@ namespace dawn_native {
         ResultOrError<UploadHandle> AllocateInternal(uint64_t allocationSize, Serial serial);
 
         std::vector<std::unique_ptr<RingBuffer>> mRingBuffers;
-        SerialQueue<std::unique_ptr<StagingBufferBase>> mReleasedStagingBuffers;
+        SerialQueue<Serial, std::unique_ptr<StagingBufferBase>> mReleasedStagingBuffers;
         DeviceBase* mDevice;
     };
 }  // namespace dawn_native
diff --git a/src/dawn_native/ErrorScopeTracker.h b/src/dawn_native/ErrorScopeTracker.h
index 2ca651198f..ddedbcdf8b 100644
--- a/src/dawn_native/ErrorScopeTracker.h
+++ b/src/dawn_native/ErrorScopeTracker.h
@@ -34,7 +34,7 @@ namespace dawn_native {
 
       protected:
         DeviceBase* mDevice;
-        SerialQueue<Ref<ErrorScope>> mScopesInFlight;
+        SerialQueue<Serial, Ref<ErrorScope>> mScopesInFlight;
     };
 
 }  // namespace dawn_native
diff --git a/src/dawn_native/Fence.h b/src/dawn_native/Fence.h
index f5596599fe..b4fb821412 100644
--- a/src/dawn_native/Fence.h
+++ b/src/dawn_native/Fence.h
@@ -61,7 +61,7 @@ namespace dawn_native {
         uint64_t mSignalValue;
         uint64_t mCompletedValue;
         Ref<QueueBase> mQueue;
-        SerialMap<OnCompletionData> mRequests;
+        SerialMap<Serial, OnCompletionData> mRequests;
     };
 
 }  // namespace dawn_native
diff --git a/src/dawn_native/FenceSignalTracker.h b/src/dawn_native/FenceSignalTracker.h
index 10026a44ef..623140f316 100644
--- a/src/dawn_native/FenceSignalTracker.h
+++ b/src/dawn_native/FenceSignalTracker.h
@@ -39,7 +39,7 @@ namespace dawn_native {
 
       private:
         DeviceBase* mDevice;
-        SerialQueue<FenceInFlight> mFencesInFlight;
+        SerialQueue<Serial, FenceInFlight> mFencesInFlight;
     };
 
 }  // namespace dawn_native
diff --git a/src/dawn_native/MapRequestTracker.h b/src/dawn_native/MapRequestTracker.h
index 78744e05e9..06eae3dbad 100644
--- a/src/dawn_native/MapRequestTracker.h
+++ b/src/dawn_native/MapRequestTracker.h
@@ -35,7 +35,7 @@ namespace dawn_native {
             Ref<BufferBase> buffer;
             uint32_t mapSerial;
         };
-        SerialQueue<Request> mInflightRequests;
+        SerialQueue<Serial, Request> mInflightRequests;
     };
 
 }  // namespace dawn_native
diff --git a/src/dawn_native/RingBufferAllocator.h b/src/dawn_native/RingBufferAllocator.h
index 50b0f15d00..0b9682a180 100644
--- a/src/dawn_native/RingBufferAllocator.h
+++ b/src/dawn_native/RingBufferAllocator.h
@@ -44,8 +44,8 @@ namespace dawn_native {
             uint64_t size;
         };
 
-        SerialQueue<Request> mInflightRequests;  // Queue of the recorded sub-alloc requests (e.g.
-                                                 // frame of resources).
+        SerialQueue<Serial, Request> mInflightRequests;  // Queue of the recorded sub-alloc requests
+                                                         // (e.g. frame of resources).
 
         uint64_t mUsedEndOffset = 0;    // Tail of used sub-alloc requests (in bytes).
         uint64_t mUsedStartOffset = 0;  // Head of used sub-alloc requests (in bytes).
diff --git a/src/dawn_native/d3d12/BufferD3D12.h b/src/dawn_native/d3d12/BufferD3D12.h
index d355e321f8..6bba440f82 100644
--- a/src/dawn_native/d3d12/BufferD3D12.h
+++ b/src/dawn_native/d3d12/BufferD3D12.h
@@ -15,9 +15,9 @@
 #ifndef DAWNNATIVE_D3D12_BUFFERD3D12_H_
 #define DAWNNATIVE_D3D12_BUFFERD3D12_H_
 
-#include "common/SerialQueue.h"
 #include "dawn_native/Buffer.h"
 
+#include "common/Serial.h"
 #include "dawn_native/d3d12/ResourceHeapAllocationD3D12.h"
 #include "dawn_native/d3d12/d3d12_platform.h"
 
diff --git a/src/dawn_native/d3d12/CommandAllocatorManager.h b/src/dawn_native/d3d12/CommandAllocatorManager.h
index 654d3be467..135ad208d0 100644
--- a/src/dawn_native/d3d12/CommandAllocatorManager.h
+++ b/src/dawn_native/d3d12/CommandAllocatorManager.h
@@ -49,7 +49,7 @@ namespace dawn_native { namespace d3d12 {
 
         ComPtr<ID3D12CommandAllocator> mCommandAllocators[kMaxCommandAllocators];
         std::bitset<kMaxCommandAllocators> mFreeAllocators;
-        SerialQueue<IndexedCommandAllocator> mInFlightCommandAllocators;
+        SerialQueue<Serial, IndexedCommandAllocator> mInFlightCommandAllocators;
     };
 
 }}  // namespace dawn_native::d3d12
diff --git a/src/dawn_native/d3d12/DeviceD3D12.h b/src/dawn_native/d3d12/DeviceD3D12.h
index 9e4399a6d8..a82dbfe75e 100644
--- a/src/dawn_native/d3d12/DeviceD3D12.h
+++ b/src/dawn_native/d3d12/DeviceD3D12.h
@@ -196,7 +196,7 @@ namespace dawn_native { namespace d3d12 {
 
         CommandRecordingContext mPendingCommands;
 
-        SerialQueue<ComPtr<IUnknown>> mUsedComObjectRefs;
+        SerialQueue<Serial, ComPtr<IUnknown>> mUsedComObjectRefs;
 
         std::unique_ptr<CommandAllocatorManager> mCommandAllocatorManager;
         std::unique_ptr<ResourceAllocatorManager> mResourceAllocatorManager;
diff --git a/src/dawn_native/d3d12/ResourceAllocatorManagerD3D12.h b/src/dawn_native/d3d12/ResourceAllocatorManagerD3D12.h
index 0bf2a02c61..b3900d35aa 100644
--- a/src/dawn_native/d3d12/ResourceAllocatorManagerD3D12.h
+++ b/src/dawn_native/d3d12/ResourceAllocatorManagerD3D12.h
@@ -98,7 +98,7 @@ namespace dawn_native { namespace d3d12 {
         std::array<std::unique_ptr<PooledResourceMemoryAllocator>, ResourceHeapKind::EnumCount>
             mPooledHeapAllocators;
 
-        SerialQueue<ResourceHeapAllocation> mAllocationsToDelete;
+        SerialQueue<Serial, ResourceHeapAllocation> mAllocationsToDelete;
     };
 
 }}  // namespace dawn_native::d3d12
diff --git a/src/dawn_native/d3d12/StagingDescriptorAllocatorD3D12.h b/src/dawn_native/d3d12/StagingDescriptorAllocatorD3D12.h
index 519920b465..24a76a446a 100644
--- a/src/dawn_native/d3d12/StagingDescriptorAllocatorD3D12.h
+++ b/src/dawn_native/d3d12/StagingDescriptorAllocatorD3D12.h
@@ -77,7 +77,7 @@ namespace dawn_native { namespace d3d12 {
 
         D3D12_DESCRIPTOR_HEAP_TYPE mHeapType;
 
-        SerialQueue<CPUDescriptorHeapAllocation> mAllocationsToDelete;
+        SerialQueue<Serial, CPUDescriptorHeapAllocation> mAllocationsToDelete;
     };
 
 }}  // namespace dawn_native::d3d12
diff --git a/src/dawn_native/vulkan/DescriptorSetAllocator.h b/src/dawn_native/vulkan/DescriptorSetAllocator.h
index 44ea4a4325..1113edb788 100644
--- a/src/dawn_native/vulkan/DescriptorSetAllocator.h
+++ b/src/dawn_native/vulkan/DescriptorSetAllocator.h
@@ -61,7 +61,7 @@ namespace dawn_native { namespace vulkan {
             PoolIndex poolIndex;
             SetIndex setIndex;
         };
-        SerialQueue<Deallocation> mPendingDeallocations;
+        SerialQueue<Serial, Deallocation> mPendingDeallocations;
         Serial mLastDeallocationSerial = 0;
     };
 
diff --git a/src/dawn_native/vulkan/DeviceVk.h b/src/dawn_native/vulkan/DeviceVk.h
index 1b44bb7e3c..68c53733ab 100644
--- a/src/dawn_native/vulkan/DeviceVk.h
+++ b/src/dawn_native/vulkan/DeviceVk.h
@@ -161,7 +161,7 @@ namespace dawn_native { namespace vulkan {
         VkQueue mQueue = VK_NULL_HANDLE;
         uint32_t mComputeSubgroupSize = 0;
 
-        SerialQueue<Ref<BindGroupLayout>> mBindGroupLayoutsPendingDeallocation;
+        SerialQueue<Serial, Ref<BindGroupLayout>> mBindGroupLayoutsPendingDeallocation;
         std::unique_ptr<FencedDeleter> mDeleter;
         std::unique_ptr<ResourceMemoryAllocator> mResourceMemoryAllocator;
         std::unique_ptr<RenderPassCache> mRenderPassCache;
@@ -187,7 +187,7 @@ namespace dawn_native { namespace vulkan {
             VkCommandPool pool = VK_NULL_HANDLE;
             VkCommandBuffer commandBuffer = VK_NULL_HANDLE;
         };
-        SerialQueue<CommandPoolAndBuffer> mCommandsInFlight;
+        SerialQueue<Serial, CommandPoolAndBuffer> mCommandsInFlight;
         // Command pools in the unused list haven't been reset yet.
         std::vector<CommandPoolAndBuffer> mUnusedCommands;
         // There is always a valid recording context stored in mRecordingContext
diff --git a/src/dawn_native/vulkan/FencedDeleter.h b/src/dawn_native/vulkan/FencedDeleter.h
index 9e516b1006..5f897e40a1 100644
--- a/src/dawn_native/vulkan/FencedDeleter.h
+++ b/src/dawn_native/vulkan/FencedDeleter.h
@@ -47,21 +47,21 @@ namespace dawn_native { namespace vulkan {
 
       private:
         Device* mDevice = nullptr;
-        SerialQueue<VkBuffer> mBuffersToDelete;
-        SerialQueue<VkDescriptorPool> mDescriptorPoolsToDelete;
-        SerialQueue<VkDeviceMemory> mMemoriesToDelete;
-        SerialQueue<VkFramebuffer> mFramebuffersToDelete;
-        SerialQueue<VkImage> mImagesToDelete;
-        SerialQueue<VkImageView> mImageViewsToDelete;
-        SerialQueue<VkPipeline> mPipelinesToDelete;
-        SerialQueue<VkPipelineLayout> mPipelineLayoutsToDelete;
-        SerialQueue<VkQueryPool> mQueryPoolsToDelete;
-        SerialQueue<VkRenderPass> mRenderPassesToDelete;
-        SerialQueue<VkSampler> mSamplersToDelete;
-        SerialQueue<VkSemaphore> mSemaphoresToDelete;
-        SerialQueue<VkShaderModule> mShaderModulesToDelete;
-        SerialQueue<VkSurfaceKHR> mSurfacesToDelete;
-        SerialQueue<VkSwapchainKHR> mSwapChainsToDelete;
+        SerialQueue<Serial, VkBuffer> mBuffersToDelete;
+        SerialQueue<Serial, VkDescriptorPool> mDescriptorPoolsToDelete;
+        SerialQueue<Serial, VkDeviceMemory> mMemoriesToDelete;
+        SerialQueue<Serial, VkFramebuffer> mFramebuffersToDelete;
+        SerialQueue<Serial, VkImage> mImagesToDelete;
+        SerialQueue<Serial, VkImageView> mImageViewsToDelete;
+        SerialQueue<Serial, VkPipeline> mPipelinesToDelete;
+        SerialQueue<Serial, VkPipelineLayout> mPipelineLayoutsToDelete;
+        SerialQueue<Serial, VkQueryPool> mQueryPoolsToDelete;
+        SerialQueue<Serial, VkRenderPass> mRenderPassesToDelete;
+        SerialQueue<Serial, VkSampler> mSamplersToDelete;
+        SerialQueue<Serial, VkSemaphore> mSemaphoresToDelete;
+        SerialQueue<Serial, VkShaderModule> mShaderModulesToDelete;
+        SerialQueue<Serial, VkSurfaceKHR> mSurfacesToDelete;
+        SerialQueue<Serial, VkSwapchainKHR> mSwapChainsToDelete;
     };
 
 }}  // namespace dawn_native::vulkan
diff --git a/src/dawn_native/vulkan/ResourceMemoryAllocatorVk.h b/src/dawn_native/vulkan/ResourceMemoryAllocatorVk.h
index 04176a3300..54a3aa9acb 100644
--- a/src/dawn_native/vulkan/ResourceMemoryAllocatorVk.h
+++ b/src/dawn_native/vulkan/ResourceMemoryAllocatorVk.h
@@ -49,7 +49,7 @@ namespace dawn_native { namespace vulkan {
         class SingleTypeAllocator;
         std::vector<std::unique_ptr<SingleTypeAllocator>> mAllocatorsPerType;
 
-        SerialQueue<ResourceMemoryAllocation> mSubAllocationsToDelete;
+        SerialQueue<Serial, ResourceMemoryAllocation> mSubAllocationsToDelete;
     };
 
 }}  // namespace dawn_native::vulkan
diff --git a/src/tests/unittests/SerialMapTests.cpp b/src/tests/unittests/SerialMapTests.cpp
index e5d23e9dba..d86b11c164 100644
--- a/src/tests/unittests/SerialMapTests.cpp
+++ b/src/tests/unittests/SerialMapTests.cpp
@@ -15,8 +15,9 @@
 #include <gtest/gtest.h>
 
 #include "common/SerialMap.h"
+#include "common/TypedInteger.h"
 
-using TestSerialMap = SerialMap<int>;
+using TestSerialMap = SerialMap<uint64_t, int>;
 
 // A number of basic tests for SerialMap that are difficult to split from one another
 TEST(SerialMap, BasicTest) {
@@ -162,3 +163,21 @@ TEST(SerialMap, FirstSerial) {
     map.Enqueue(vector1, 6);
     EXPECT_EQ(map.FirstSerial(), 6u);
 }
+
+// Test basic functionality with type integers
+TEST(SerialMap, TypedInteger) {
+    using MySerial = TypedInteger<struct MySerialT, uint64_t>;
+    using MySerialMap = SerialMap<MySerial, int>;
+
+    MySerialMap map;
+    map.Enqueue(1, MySerial(0));
+    map.Enqueue(2, MySerial(0));
+
+    std::vector<int> expectedValues = {1, 2};
+    for (int value : map.IterateAll()) {
+        EXPECT_EQ(expectedValues.front(), value);
+        ASSERT_FALSE(expectedValues.empty());
+        expectedValues.erase(expectedValues.begin());
+    }
+    ASSERT_TRUE(expectedValues.empty());
+}
diff --git a/src/tests/unittests/SerialQueueTests.cpp b/src/tests/unittests/SerialQueueTests.cpp
index 2545c51929..5161b81b71 100644
--- a/src/tests/unittests/SerialQueueTests.cpp
+++ b/src/tests/unittests/SerialQueueTests.cpp
@@ -15,8 +15,9 @@
 #include <gtest/gtest.h>
 
 #include "common/SerialQueue.h"
+#include "common/TypedInteger.h"
 
-using TestSerialQueue = SerialQueue<int>;
+using TestSerialQueue = SerialQueue<uint64_t, int>;
 
 // A number of basic tests for SerialQueue that are difficult to split from one another
 TEST(SerialQueue, BasicTest) {
@@ -154,3 +155,21 @@ TEST(SerialQueue, LastSerial) {
     queue.Enqueue({2}, 1);
     EXPECT_EQ(queue.LastSerial(), 1u);
 }
+
+// Test basic functionality with type integers
+TEST(SerialQueue, TypedInteger) {
+    using MySerial = TypedInteger<struct MySerialT, uint64_t>;
+    using MySerialQueue = SerialQueue<MySerial, int>;
+
+    MySerialQueue queue;
+    queue.Enqueue(1, MySerial(0));
+    queue.Enqueue(2, MySerial(0));
+
+    std::vector<int> expectedValues = {1, 2};
+    for (int value : queue.IterateAll()) {
+        EXPECT_EQ(expectedValues.front(), value);
+        ASSERT_FALSE(expectedValues.empty());
+        expectedValues.erase(expectedValues.begin());
+    }
+    ASSERT_TRUE(expectedValues.empty());
+}