diff --git a/velox/exec/fuzzer/AggregationFuzzer.cpp b/velox/exec/fuzzer/AggregationFuzzer.cpp
index d778f39df475c..4033675d0c25b 100644
--- a/velox/exec/fuzzer/AggregationFuzzer.cpp
+++ b/velox/exec/fuzzer/AggregationFuzzer.cpp
@@ -60,7 +60,7 @@ class AggregationFuzzer : public AggregationFuzzerBase {
       const std::unordered_map<std::string, std::shared_ptr<InputGenerator>>&
           customInputGenerators,
       const std::unordered_map<std::string, DataSpec>& functionDataSpec,
-      VectorFuzzer::Options::TimestampPrecision timestampPrecision,
+      FuzzerTimestampPrecision timestampPrecision,
       const std::unordered_map<std::string, std::string>& queryConfigs,
       const std::unordered_map<std::string, std::string>& hiveConfigs,
       bool orderableGroupKeys,
@@ -214,7 +214,7 @@ void aggregateFuzzer(
     const std::unordered_map<std::string, std::shared_ptr<InputGenerator>>&
         customInputGenerators,
     const std::unordered_map<std::string, DataSpec>& functionDataSpec,
-    VectorFuzzer::Options::TimestampPrecision timestampPrecision,
+    FuzzerTimestampPrecision timestampPrecision,
     const std::unordered_map<std::string, std::string>& queryConfigs,
     const std::unordered_map<std::string, std::string>& hiveConfigs,
     bool orderableGroupKeys,
@@ -245,7 +245,7 @@ AggregationFuzzer::AggregationFuzzer(
     const std::unordered_map<std::string, std::shared_ptr<InputGenerator>>&
         customInputGenerators,
     const std::unordered_map<std::string, DataSpec>& functionDataSpec,
-    VectorFuzzer::Options::TimestampPrecision timestampPrecision,
+    FuzzerTimestampPrecision timestampPrecision,
     const std::unordered_map<std::string, std::string>& queryConfigs,
     const std::unordered_map<std::string, std::string>& hiveConfigs,
     bool orderableGroupKeys,
diff --git a/velox/exec/fuzzer/AggregationFuzzer.h b/velox/exec/fuzzer/AggregationFuzzer.h
index 9cb9a9171cf65..b7c9dbf1571d1 100644
--- a/velox/exec/fuzzer/AggregationFuzzer.h
+++ b/velox/exec/fuzzer/AggregationFuzzer.h
@@ -42,7 +42,7 @@ void aggregateFuzzer(
     const std::unordered_map<std::string, std::shared_ptr<InputGenerator>>&
         customInputGenerators,
     const std::unordered_map<std::string, DataSpec>& functionDataSpec,
-    VectorFuzzer::Options::TimestampPrecision timestampPrecision,
+    FuzzerTimestampPrecision timestampPrecision,
     const std::unordered_map<std::string, std::string>& queryConfigs,
     const std::unordered_map<std::string, std::string>& hiveConfigs,
     bool orderableGroupKeys,
diff --git a/velox/exec/fuzzer/AggregationFuzzerBase.h b/velox/exec/fuzzer/AggregationFuzzerBase.h
index a2237f8a9d74d..eae9e8f6e5d19 100644
--- a/velox/exec/fuzzer/AggregationFuzzerBase.h
+++ b/velox/exec/fuzzer/AggregationFuzzerBase.h
@@ -63,7 +63,7 @@ class AggregationFuzzerBase {
           customVerificationFunctions,
       const std::unordered_map<std::string, std::shared_ptr<InputGenerator>>&
           customInputGenerators,
-      VectorFuzzer::Options::TimestampPrecision timestampPrecision,
+      FuzzerTimestampPrecision timestampPrecision,
       const std::unordered_map<std::string, std::string>& queryConfigs,
       const std::unordered_map<std::string, std::string>& hiveConfigs,
       bool orderableGroupKeys,
@@ -151,7 +151,7 @@ class AggregationFuzzerBase {
   PlanWithSplits deserialize(const folly::dynamic& obj);
 
   static VectorFuzzer::Options getFuzzerOptions(
-      VectorFuzzer::Options::TimestampPrecision timestampPrecision) {
+      FuzzerTimestampPrecision timestampPrecision) {
     VectorFuzzer::Options opts;
     opts.vectorSize = FLAGS_batch_size;
     opts.stringVariableLength = true;
diff --git a/velox/exec/fuzzer/AggregationFuzzerOptions.h b/velox/exec/fuzzer/AggregationFuzzerOptions.h
index 71807617817f4..7f658e2a57d49 100644
--- a/velox/exec/fuzzer/AggregationFuzzerOptions.h
+++ b/velox/exec/fuzzer/AggregationFuzzerOptions.h
@@ -51,8 +51,8 @@ struct AggregationFuzzerOptions {
   std::unordered_set<std::string> orderDependentFunctions;
 
   /// Timestamp precision to use when generating inputs of type TIMESTAMP.
-  VectorFuzzer::Options::TimestampPrecision timestampPrecision{
-      VectorFuzzer::Options::TimestampPrecision::kMilliSeconds};
+  FuzzerTimestampPrecision timestampPrecision{
+      FuzzerTimestampPrecision::kMilliSeconds};
 
   /// A set of configuration properties to use when running query plans.
   /// Could be used to specify timezone or enable/disable settings that
diff --git a/velox/exec/fuzzer/JoinFuzzer.cpp b/velox/exec/fuzzer/JoinFuzzer.cpp
index 5218a9ff4db1e..11bf342c2c07b 100644
--- a/velox/exec/fuzzer/JoinFuzzer.cpp
+++ b/velox/exec/fuzzer/JoinFuzzer.cpp
@@ -112,8 +112,7 @@ class JoinFuzzer {
     opts.stringVariableLength = true;
     opts.stringLength = 100;
     opts.nullRatio = FLAGS_null_ratio;
-    opts.timestampPrecision =
-        VectorFuzzer::Options::TimestampPrecision::kMilliSeconds;
+    opts.timestampPrecision = FuzzerTimestampPrecision::kMilliSeconds;
     return opts;
   }
 
diff --git a/velox/exec/fuzzer/WindowFuzzer.cpp b/velox/exec/fuzzer/WindowFuzzer.cpp
index b4d8a578f3a8a..3516c1f631db0 100644
--- a/velox/exec/fuzzer/WindowFuzzer.cpp
+++ b/velox/exec/fuzzer/WindowFuzzer.cpp
@@ -758,7 +758,7 @@ void windowFuzzer(
         customInputGenerators,
     const std::unordered_set<std::string>& orderDependentFunctions,
     const std::unordered_map<std::string, DataSpec>& functionDataSpec,
-    VectorFuzzer::Options::TimestampPrecision timestampPrecision,
+    FuzzerTimestampPrecision timestampPrecision,
     const std::unordered_map<std::string, std::string>& queryConfigs,
     const std::unordered_map<std::string, std::string>& hiveConfigs,
     bool orderableGroupKeys,
diff --git a/velox/exec/fuzzer/WindowFuzzer.h b/velox/exec/fuzzer/WindowFuzzer.h
index 4e9b88057b354..609224c9e15aa 100644
--- a/velox/exec/fuzzer/WindowFuzzer.h
+++ b/velox/exec/fuzzer/WindowFuzzer.h
@@ -39,7 +39,7 @@ class WindowFuzzer : public AggregationFuzzerBase {
           customInputGenerators,
       const std::unordered_set<std::string>& orderDependentFunctions,
       const std::unordered_map<std::string, DataSpec>& functionDataSpec,
-      VectorFuzzer::Options::TimestampPrecision timestampPrecision,
+      FuzzerTimestampPrecision timestampPrecision,
       const std::unordered_map<std::string, std::string>& queryConfigs,
       const std::unordered_map<std::string, std::string>& hiveConfigs,
       bool orderableGroupKeys,
@@ -243,7 +243,7 @@ void windowFuzzer(
         customInputGenerators,
     const std::unordered_set<std::string>& orderDependentFunctions,
     const std::unordered_map<std::string, DataSpec>& functionDataSpec,
-    VectorFuzzer::Options::TimestampPrecision timestampPrecision,
+    FuzzerTimestampPrecision timestampPrecision,
     const std::unordered_map<std::string, std::string>& queryConfigs,
     const std::unordered_map<std::string, std::string>& hiveConfigs,
     bool orderableGroupKeys,
diff --git a/velox/exec/fuzzer/WriterFuzzer.cpp b/velox/exec/fuzzer/WriterFuzzer.cpp
index d3d60e49aaf21..1b7ca82875bed 100644
--- a/velox/exec/fuzzer/WriterFuzzer.cpp
+++ b/velox/exec/fuzzer/WriterFuzzer.cpp
@@ -87,8 +87,7 @@ class WriterFuzzer {
     opts.vectorSize = FLAGS_batch_size;
     opts.stringLength = 10;
     opts.nullRatio = FLAGS_null_ratio;
-    opts.timestampPrecision =
-        VectorFuzzer::Options::TimestampPrecision::kMilliSeconds;
+    opts.timestampPrecision = FuzzerTimestampPrecision::kMilliSeconds;
     return opts;
   }
 
diff --git a/velox/exec/tests/ExchangeFuzzer.cpp b/velox/exec/tests/ExchangeFuzzer.cpp
index acdcbbea390cb..017a8ea741cbf 100644
--- a/velox/exec/tests/ExchangeFuzzer.cpp
+++ b/velox/exec/tests/ExchangeFuzzer.cpp
@@ -365,7 +365,7 @@ class ExchangeFuzzer : public VectorTestBase {
       options_.maxConstantContainerSize = 2;
       options_.normalizeMapKeys = fuzzer_.coinToss(0.95);
       options_.timestampPrecision =
-          static_cast<VectorFuzzer::Options::TimestampPrecision>(randInt(0, 3));
+          static_cast<FuzzerTimestampPrecision>(randInt(0, 3));
       options_.allowLazyVector = false;
 
       fuzzer_.setOptions(options_);
diff --git a/velox/expression/fuzzer/FuzzerRunner.cpp b/velox/expression/fuzzer/FuzzerRunner.cpp
index 7c06a5ac6af6b..4544b44ef1430 100644
--- a/velox/expression/fuzzer/FuzzerRunner.cpp
+++ b/velox/expression/fuzzer/FuzzerRunner.cpp
@@ -170,8 +170,7 @@ VectorFuzzer::Options getVectorFuzzerOptions() {
   opts.stringVariableLength = true;
   opts.stringLength = 100;
   opts.nullRatio = FLAGS_null_ratio;
-  opts.timestampPrecision =
-      VectorFuzzer::Options::TimestampPrecision::kMilliSeconds;
+  opts.timestampPrecision = FuzzerTimestampPrecision::kMilliSeconds;
   return opts;
 }
 
diff --git a/velox/functions/lib/window/tests/WindowTestBase.cpp b/velox/functions/lib/window/tests/WindowTestBase.cpp
index 9e8c0d5466386..47576e8c800d7 100644
--- a/velox/functions/lib/window/tests/WindowTestBase.cpp
+++ b/velox/functions/lib/window/tests/WindowTestBase.cpp
@@ -123,8 +123,7 @@ VectorPtr WindowTestBase::makeRandomInputVector(
   VectorFuzzer::Options options;
   options.vectorSize = size;
   options.nullRatio = nullRatio;
-  options.timestampPrecision =
-      VectorFuzzer::Options::TimestampPrecision::kMicroSeconds;
+  options.timestampPrecision = FuzzerTimestampPrecision::kMicroSeconds;
   VectorFuzzer fuzzer(options, pool_.get(), 0);
   return fuzzer.fuzzFlat(type);
 }
diff --git a/velox/functions/prestosql/fuzzer/AggregationFuzzerTest.cpp b/velox/functions/prestosql/fuzzer/AggregationFuzzerTest.cpp
index 12650de90df46..d426d2a154f4e 100644
--- a/velox/functions/prestosql/fuzzer/AggregationFuzzerTest.cpp
+++ b/velox/functions/prestosql/fuzzer/AggregationFuzzerTest.cpp
@@ -194,7 +194,7 @@ int main(int argc, char** argv) {
   options.customInputGenerators =
       facebook::velox::exec::test::getCustomInputGenerators();
   options.timestampPrecision =
-      facebook::velox::VectorFuzzer::Options::TimestampPrecision::kMilliSeconds;
+      facebook::velox::FuzzerTimestampPrecision::kMilliSeconds;
   std::shared_ptr<facebook::velox::memory::MemoryPool> rootPool{
       facebook::velox::memory::memoryManager()->addRootPool()};
 
diff --git a/velox/functions/prestosql/fuzzer/WindowFuzzerTest.cpp b/velox/functions/prestosql/fuzzer/WindowFuzzerTest.cpp
index f7d863d7b8098..01557d635edc3 100644
--- a/velox/functions/prestosql/fuzzer/WindowFuzzerTest.cpp
+++ b/velox/functions/prestosql/fuzzer/WindowFuzzerTest.cpp
@@ -180,7 +180,7 @@ int main(int argc, char** argv) {
       facebook::velox::exec::test::getCustomInputGenerators();
   options.orderDependentFunctions = orderDependentFunctions;
   options.timestampPrecision =
-      facebook::velox::VectorFuzzer::Options::TimestampPrecision::kMilliSeconds;
+      facebook::velox::FuzzerTimestampPrecision::kMilliSeconds;
   std::shared_ptr<facebook::velox::memory::MemoryPool> rootPool{
       facebook::velox::memory::memoryManager()->addRootPool()};
   return Runner::run(
diff --git a/velox/row/benchmarks/DynamicRowVectorDeserializeBenchmark.cpp b/velox/row/benchmarks/DynamicRowVectorDeserializeBenchmark.cpp
index e32623244a7a5..dac9d0dcd24f6 100644
--- a/velox/row/benchmarks/DynamicRowVectorDeserializeBenchmark.cpp
+++ b/velox/row/benchmarks/DynamicRowVectorDeserializeBenchmark.cpp
@@ -80,8 +80,7 @@ class BenchmarkHelper {
     opts.stringVariableLength = true;
     opts.stringLength = 20;
     // Spark uses microseconds to store timestamp
-    opts.timestampPrecision =
-        VectorFuzzer::Options::TimestampPrecision::kMicroSeconds;
+    opts.timestampPrecision = FuzzerTimestampPrecision::kMicroSeconds;
 
     auto seed = folly::Random::rand32();
     VectorFuzzer fuzzer(opts, pool_.get(), seed);
diff --git a/velox/row/tests/CompactRowTest.cpp b/velox/row/tests/CompactRowTest.cpp
index 8bfa4fc3989d7..f04982a024ea3 100644
--- a/velox/row/tests/CompactRowTest.cpp
+++ b/velox/row/tests/CompactRowTest.cpp
@@ -554,8 +554,7 @@ TEST_F(CompactRowTest, fuzz) {
   opts.complexElementsMaxSize = 1'000;
 
   // Spark uses microseconds to store timestamp
-  opts.timestampPrecision =
-      VectorFuzzer::Options::TimestampPrecision::kMicroSeconds;
+  opts.timestampPrecision = FuzzerTimestampPrecision::kMicroSeconds;
 
   VectorFuzzer fuzzer(opts, pool_.get());
 
diff --git a/velox/row/tests/UnsafeRowFuzzTest.cpp b/velox/row/tests/UnsafeRowFuzzTest.cpp
index 9159bf73c5fd2..f60d6da6d81c7 100644
--- a/velox/row/tests/UnsafeRowFuzzTest.cpp
+++ b/velox/row/tests/UnsafeRowFuzzTest.cpp
@@ -59,8 +59,7 @@ class UnsafeRowFuzzTests : public ::testing::Test {
     opts.complexElementsMaxSize = 10'000;
 
     // Spark uses microseconds to store timestamp
-    opts.timestampPrecision =
-        VectorFuzzer::Options::TimestampPrecision::kMicroSeconds,
+    opts.timestampPrecision = FuzzerTimestampPrecision::kMicroSeconds,
     opts.containerLength = 10;
 
     VectorFuzzer fuzzer(opts, pool_.get());
diff --git a/velox/serializers/tests/CompactRowSerializerTest.cpp b/velox/serializers/tests/CompactRowSerializerTest.cpp
index 277957c323bda..b83670c27e7ac 100644
--- a/velox/serializers/tests/CompactRowSerializerTest.cpp
+++ b/velox/serializers/tests/CompactRowSerializerTest.cpp
@@ -170,8 +170,7 @@ TEST_P(CompactRowSerializerTest, fuzz) {
   opts.containerVariableLength = false;
 
   // Spark uses microseconds to store timestamp
-  opts.timestampPrecision =
-      VectorFuzzer::Options::TimestampPrecision::kMicroSeconds;
+  opts.timestampPrecision = FuzzerTimestampPrecision::kMicroSeconds;
   opts.containerLength = 10;
 
   const auto seed = folly::Random::rand32();
diff --git a/velox/serializers/tests/PrestoSerializerTest.cpp b/velox/serializers/tests/PrestoSerializerTest.cpp
index 898939f97a279..4e4b1162d31e9 100644
--- a/velox/serializers/tests/PrestoSerializerTest.cpp
+++ b/velox/serializers/tests/PrestoSerializerTest.cpp
@@ -502,7 +502,7 @@ class PrestoSerializerTest
     options.normalizeMapKeys = randInt(0, 20) < 16;
     if (isFirst) {
       options.timestampPrecision =
-          static_cast<VectorFuzzer::Options::TimestampPrecision>(randInt(0, 3));
+          static_cast<FuzzerTimestampPrecision>(randInt(0, 3));
     }
     options.allowLazyVector = false;
   }
@@ -1281,8 +1281,7 @@ TEST_P(PrestoSerializerTest, lazy) {
 
 TEST_P(PrestoSerializerTest, ioBufRoundTrip) {
   VectorFuzzer::Options opts;
-  opts.timestampPrecision =
-      VectorFuzzer::Options::TimestampPrecision::kMilliSeconds;
+  opts.timestampPrecision = FuzzerTimestampPrecision::kMilliSeconds;
   opts.nullRatio = 0.1;
   VectorFuzzer fuzzer(opts, pool_.get());
 
@@ -1300,13 +1299,11 @@ TEST_P(PrestoSerializerTest, ioBufRoundTrip) {
 
 TEST_P(PrestoSerializerTest, roundTrip) {
   VectorFuzzer::Options opts;
-  opts.timestampPrecision =
-      VectorFuzzer::Options::TimestampPrecision::kMilliSeconds;
+  opts.timestampPrecision = FuzzerTimestampPrecision::kMilliSeconds;
   opts.nullRatio = 0.1;
   VectorFuzzer fuzzer(opts, pool_.get());
   VectorFuzzer::Options nonNullOpts;
-  nonNullOpts.timestampPrecision =
-      VectorFuzzer::Options::TimestampPrecision::kMilliSeconds;
+  nonNullOpts.timestampPrecision = FuzzerTimestampPrecision::kMilliSeconds;
   nonNullOpts.nullRatio = 0;
   VectorFuzzer nonNullFuzzer(nonNullOpts, pool_.get());
 
@@ -1325,8 +1322,7 @@ TEST_P(PrestoSerializerTest, roundTrip) {
 
 TEST_P(PrestoSerializerTest, encodedRoundtrip) {
   VectorFuzzer::Options opts;
-  opts.timestampPrecision =
-      VectorFuzzer::Options::TimestampPrecision::kMilliSeconds;
+  opts.timestampPrecision = FuzzerTimestampPrecision::kMilliSeconds;
   opts.nullRatio = 0.1;
   opts.dictionaryHasNulls = false;
   VectorFuzzer fuzzer(opts, pool_.get());
@@ -1464,13 +1460,11 @@ TEST_P(PrestoSerializerTest, typeMismatch) {
 
 TEST_P(PrestoSerializerTest, lexer) {
   VectorFuzzer::Options opts;
-  opts.timestampPrecision =
-      VectorFuzzer::Options::TimestampPrecision::kMilliSeconds;
+  opts.timestampPrecision = FuzzerTimestampPrecision::kMilliSeconds;
   opts.nullRatio = 0.1;
   VectorFuzzer fuzzer(opts, pool_.get());
   VectorFuzzer::Options nonNullOpts;
-  nonNullOpts.timestampPrecision =
-      VectorFuzzer::Options::TimestampPrecision::kMilliSeconds;
+  nonNullOpts.timestampPrecision = FuzzerTimestampPrecision::kMilliSeconds;
   nonNullOpts.nullRatio = 0;
   VectorFuzzer nonNullFuzzer(nonNullOpts, pool_.get());
 
@@ -1594,8 +1588,7 @@ TEST_F(PrestoSerializerTest, deserializeSingleColumn) {
   opts.stringVariableLength = true;
   opts.stringLength = 20;
   opts.containerVariableLength = false;
-  opts.timestampPrecision =
-      VectorFuzzer::Options::TimestampPrecision::kMilliSeconds;
+  opts.timestampPrecision = FuzzerTimestampPrecision::kMilliSeconds;
   opts.containerLength = 10;
 
   auto seed = 0;
diff --git a/velox/serializers/tests/UnsafeRowSerializerTest.cpp b/velox/serializers/tests/UnsafeRowSerializerTest.cpp
index 050c104e33d29..7935b9146a663 100644
--- a/velox/serializers/tests/UnsafeRowSerializerTest.cpp
+++ b/velox/serializers/tests/UnsafeRowSerializerTest.cpp
@@ -350,8 +350,7 @@ TEST_P(UnsafeRowSerializerTest, types) {
   opts.containerVariableLength = false;
 
   // Spark uses microseconds to store timestamp
-  opts.timestampPrecision =
-      VectorFuzzer::Options::TimestampPrecision::kMicroSeconds;
+  opts.timestampPrecision = FuzzerTimestampPrecision::kMicroSeconds;
   opts.containerLength = 10;
 
   auto seed = folly::Random::rand32();
diff --git a/velox/vector/fuzzer/Utils.h b/velox/vector/fuzzer/Utils.h
index 5f51c3a52024f..0248b08f942fa 100644
--- a/velox/vector/fuzzer/Utils.h
+++ b/velox/vector/fuzzer/Utils.h
@@ -23,6 +23,13 @@ namespace facebook::velox {
 
 using FuzzerGenerator = std::mt19937;
 
+enum class FuzzerTimestampPrecision : int8_t {
+  kNanoSeconds = 0,
+  kMicroSeconds = 1,
+  kMilliSeconds = 2,
+  kSeconds = 3,
+};
+
 namespace generator_spec_utils {
 
 bool coinToss(FuzzerGenerator& rng, double threshold);
diff --git a/velox/vector/fuzzer/VectorFuzzer.cpp b/velox/vector/fuzzer/VectorFuzzer.cpp
index 56cd03a27c895..9797bc56632a7 100644
--- a/velox/vector/fuzzer/VectorFuzzer.cpp
+++ b/velox/vector/fuzzer/VectorFuzzer.cpp
@@ -149,18 +149,18 @@ Timestamp randTimestamp(FuzzerGenerator& rng, VectorFuzzer::Options opts) {
   constexpr int64_t millisInSecond = 1'000;
 
   switch (opts.timestampPrecision) {
-    case VectorFuzzer::Options::TimestampPrecision::kNanoSeconds:
+    case FuzzerTimestampPrecision::kNanoSeconds:
       return Timestamp(
           rand<int64_t>(rng, min, max), (rand<int64_t>(rng) % MAX_NANOS));
-    case VectorFuzzer::Options::TimestampPrecision::kMicroSeconds:
+    case FuzzerTimestampPrecision::kMicroSeconds:
       return Timestamp::fromMicros(
           rand<int64_t>(rng, min, max) * microInSecond +
           rand<int64_t>(rng, -microInSecond, microInSecond));
-    case VectorFuzzer::Options::TimestampPrecision::kMilliSeconds:
+    case FuzzerTimestampPrecision::kMilliSeconds:
       return Timestamp::fromMillis(
           rand<int64_t>(rng, min, max) * millisInSecond +
           rand<int64_t>(rng, -millisInSecond, millisInSecond));
-    case VectorFuzzer::Options::TimestampPrecision::kSeconds:
+    case FuzzerTimestampPrecision::kSeconds:
       return Timestamp(rand<int64_t>(rng, min, max), 0);
   }
   return {}; // no-op.
diff --git a/velox/vector/fuzzer/VectorFuzzer.h b/velox/vector/fuzzer/VectorFuzzer.h
index 6ebbf03dc0a65..8ab96c7cb4339 100644
--- a/velox/vector/fuzzer/VectorFuzzer.h
+++ b/velox/vector/fuzzer/VectorFuzzer.h
@@ -23,6 +23,7 @@
 #include "velox/vector/BaseVector.h"
 #include "velox/vector/ComplexVector.h"
 #include "velox/vector/fuzzer/GeneratorSpec.h"
+#include "velox/vector/fuzzer/Utils.h"
 
 namespace facebook::velox {
 
@@ -140,13 +141,8 @@ class VectorFuzzer {
 
     /// Control the precision of timestamps generated. By default generate using
     /// nanoseconds precision.
-    enum class TimestampPrecision : int8_t {
-      kNanoSeconds = 0,
-      kMicroSeconds = 1,
-      kMilliSeconds = 2,
-      kSeconds = 3,
-    };
-    TimestampPrecision timestampPrecision{TimestampPrecision::kNanoSeconds};
+    FuzzerTimestampPrecision timestampPrecision{
+        FuzzerTimestampPrecision::kNanoSeconds};
 
     /// If true, fuzz() will randomly generate lazy vectors and fuzzInputRow()
     /// will generate a raw vector with children that can randomly be lazy
diff --git a/velox/vector/fuzzer/tests/VectorFuzzerTest.cpp b/velox/vector/fuzzer/tests/VectorFuzzerTest.cpp
index 8cad48c4a74e6..dd33ea2d6a29e 100644
--- a/velox/vector/fuzzer/tests/VectorFuzzerTest.cpp
+++ b/velox/vector/fuzzer/tests/VectorFuzzerTest.cpp
@@ -581,7 +581,7 @@ TEST_F(VectorFuzzerTest, containerHasNulls) {
 }
 
 FlatVectorPtr<Timestamp> genTimestampVector(
-    VectorFuzzer::Options::TimestampPrecision precision,
+    FuzzerTimestampPrecision precision,
     size_t vectorSize,
     memory::MemoryPool* pool) {
   VectorFuzzer::Options opts;
@@ -598,7 +598,7 @@ TEST_F(VectorFuzzerTest, timestamp) {
 
   // Second granularity.
   auto secTsVector = genTimestampVector(
-      VectorFuzzer::Options::TimestampPrecision::kSeconds, vectorSize, pool());
+      FuzzerTimestampPrecision::kSeconds, vectorSize, pool());
 
   for (size_t i = 0; i < vectorSize; ++i) {
     auto ts = secTsVector->valueAt(i);
@@ -607,9 +607,7 @@ TEST_F(VectorFuzzerTest, timestamp) {
 
   // Millisecond granularity.
   auto milliTsVector = genTimestampVector(
-      VectorFuzzer::Options::TimestampPrecision::kMilliSeconds,
-      vectorSize,
-      pool());
+      FuzzerTimestampPrecision::kMilliSeconds, vectorSize, pool());
 
   for (size_t i = 0; i < vectorSize; ++i) {
     auto ts = milliTsVector->valueAt(i);
@@ -618,9 +616,7 @@ TEST_F(VectorFuzzerTest, timestamp) {
 
   // Microsecond granularity.
   auto microTsVector = genTimestampVector(
-      VectorFuzzer::Options::TimestampPrecision::kMicroSeconds,
-      vectorSize,
-      pool());
+      FuzzerTimestampPrecision::kMicroSeconds, vectorSize, pool());
 
   for (size_t i = 0; i < vectorSize; ++i) {
     auto ts = microTsVector->valueAt(i);
@@ -629,9 +625,7 @@ TEST_F(VectorFuzzerTest, timestamp) {
 
   // Nanosecond granularity.
   auto nanoTsVector = genTimestampVector(
-      VectorFuzzer::Options::TimestampPrecision::kNanoSeconds,
-      vectorSize,
-      pool());
+      FuzzerTimestampPrecision::kNanoSeconds, vectorSize, pool());
 
   // Check that at least one timestamp has nano > 0.
   bool nanosFound = false;