diff --git a/phpstan-baseline.neon b/phpstan-baseline.neon
index c0d875ed..2da34651 100644
--- a/phpstan-baseline.neon
+++ b/phpstan-baseline.neon
@@ -265,6 +265,16 @@ parameters:
 			count: 1
 			path: test/Unit/Formatter/DefaultDurationFormatterTest.php
 
+		-
+			message: "#^Method Ergebnis\\\\PHPUnit\\\\SlowTestDetector\\\\Test\\\\Unit\\\\MaximumDurationTest\\:\\:testDefaultReturnsMaximumDuration\\(\\) has no return type specified\\.$#"
+			count: 1
+			path: test/Unit/MaximumDurationTest.php
+
+		-
+			message: "#^Method Ergebnis\\\\PHPUnit\\\\SlowTestDetector\\\\Test\\\\Unit\\\\MaximumDurationTest\\:\\:testFromDurationReturnsMaximumDuration\\(\\) has no return type specified\\.$#"
+			count: 1
+			path: test/Unit/MaximumDurationTest.php
+
 		-
 			message: "#^Method Ergebnis\\\\PHPUnit\\\\SlowTestDetector\\\\Test\\\\Unit\\\\PhaseIdentifierTest\\:\\:testFromStringRejectsInvalidValue\\(\\) has no return type specified\\.$#"
 			count: 1
@@ -310,6 +320,11 @@ parameters:
 			count: 1
 			path: test/Unit/TestDescriptionTest.php
 
+		-
+			message: "#^Method Ergebnis\\\\PHPUnit\\\\SlowTestDetector\\\\Test\\\\Unit\\\\TestDurationTest\\:\\:testFromDurationReturnsTestDuration\\(\\) has no return type specified\\.$#"
+			count: 1
+			path: test/Unit/TestDurationTest.php
+
 		-
 			message: "#^Method Ergebnis\\\\PHPUnit\\\\SlowTestDetector\\\\Test\\\\Unit\\\\TestIdentifierTest\\:\\:testFromStringRejectsInvalidValue\\(\\) has no return type specified\\.$#"
 			count: 1
diff --git a/src/Collector/DefaultCollector.php b/src/Collector/DefaultCollector.php
index 525dec77..77e8ceee 100644
--- a/src/Collector/DefaultCollector.php
+++ b/src/Collector/DefaultCollector.php
@@ -32,7 +32,7 @@ public function collectSlowTest(SlowTest $slowTest)
         if (\array_key_exists($key, $this->slowTests)) {
             $previousSlowTest = $this->slowTests[$key];
 
-            if (!$slowTest->duration()->isGreaterThan($previousSlowTest->duration())) {
+            if (!$slowTest->testDuration()->toDuration()->isGreaterThan($previousSlowTest->testDuration()->toDuration())) {
                 return;
             }
 
diff --git a/src/Extension.php b/src/Extension.php
index 35dcfbc8..047fd734 100644
--- a/src/Extension.php
+++ b/src/Extension.php
@@ -37,7 +37,7 @@ final class Extension implements Framework\TestListener
         private $suites = 0;
 
         /**
-         * @var Duration
+         * @var MaximumDuration
          */
         private $maximumDuration;
 
@@ -59,10 +59,10 @@ public function __construct(array $options = [])
                 $maximumCount = Count::fromInt((int) $options['maximum-count']);
             }
 
-            $maximumDuration = Duration::fromMilliseconds(500);
+            $maximumDuration = MaximumDuration::default();
 
             if (\array_key_exists('maximum-duration', $options)) {
-                $maximumDuration = Duration::fromMilliseconds((int) $options['maximum-duration']);
+                $maximumDuration = MaximumDuration::fromDuration(Duration::fromMilliseconds((int) $options['maximum-duration']));
             }
 
             $this->maximumDuration = $maximumDuration;
@@ -159,14 +159,14 @@ public function endTest(
             $seconds = (int) \floor($time);
             $nanoseconds = (int) (($time - $seconds) * 1000000000);
 
-            $duration = Duration::fromSecondsAndNanoseconds(
+            $testDuration = TestDuration::fromDuration(Duration::fromSecondsAndNanoseconds(
                 $seconds,
                 $nanoseconds
-            );
+            ));
 
             $maximumDuration = $this->resolveMaximumDuration($test);
 
-            if (!$duration->isGreaterThan($maximumDuration)) {
+            if (!$testDuration->toDuration()->isGreaterThan($maximumDuration->toDuration())) {
                 return;
             }
 
@@ -181,14 +181,14 @@ public function endTest(
                     \get_class($test),
                     $test->getName()
                 )),
-                $duration,
+                $testDuration,
                 $maximumDuration
             );
 
             $this->collector->collectSlowTest($slowTest);
         }
 
-        private function resolveMaximumDuration(Framework\Test $test): Duration
+        private function resolveMaximumDuration(Framework\Test $test): MaximumDuration
         {
             $annotations = [
                 'maximumDuration',
@@ -219,7 +219,7 @@ private function resolveMaximumDuration(Framework\Test $test): Duration
                     continue;
                 }
 
-                return Duration::fromMilliseconds((int) $maximumDuration);
+                return MaximumDuration::fromDuration(Duration::fromMilliseconds((int) $maximumDuration));
             }
 
             return $this->maximumDuration;
@@ -267,10 +267,10 @@ public function __construct(array $options = [])
                 $maximumCount = Count::fromInt((int) $options['maximum-count']);
             }
 
-            $maximumDuration = Duration::fromMilliseconds(500);
+            $maximumDuration = MaximumDuration::default();
 
             if (\array_key_exists('maximum-duration', $options)) {
-                $maximumDuration = Duration::fromMilliseconds((int) $options['maximum-duration']);
+                $maximumDuration = MaximumDuration::fromDuration(Duration::fromMilliseconds((int) $options['maximum-duration']));
             }
 
             $this->maximumDuration = $maximumDuration;
@@ -306,21 +306,21 @@ public function executeAfterTest(
             $seconds = (int) \floor($time);
             $nanoseconds = (int) (($time - $seconds) * 1000000000);
 
-            $duration = Duration::fromSecondsAndNanoseconds(
+            $testDuration = TestDuration::fromDuration(Duration::fromSecondsAndNanoseconds(
                 $seconds,
                 $nanoseconds
-            );
+            ));
 
             $maximumDuration = $this->resolveMaximumDuration($test);
 
-            if (!$duration->isGreaterThan($maximumDuration)) {
+            if (!$testDuration->toDuration()->isGreaterThan($maximumDuration->toDuration())) {
                 return;
             }
 
             $slowTest = SlowTest::create(
                 TestIdentifier::fromString($test),
                 TestDescription::fromString($test),
-                $duration,
+                $testDuration,
                 $maximumDuration
             );
 
@@ -354,7 +354,7 @@ public function executeAfterLastTest(): void
 TXT;
         }
 
-        private function resolveMaximumDuration(string $test): Duration
+        private function resolveMaximumDuration(string $test): MaximumDuration
         {
             list($testClassName, $testMethodName) = \explode(
                 '::',
@@ -390,7 +390,7 @@ private function resolveMaximumDuration(string $test): Duration
                     continue;
                 }
 
-                return Duration::fromMilliseconds((int) $maximumDuration);
+                return MaximumDuration::fromDuration(Duration::fromMilliseconds((int) $maximumDuration));
             }
 
             return $this->maximumDuration;
@@ -421,10 +421,10 @@ public function bootstrap(
                 $maximumCount = Count::fromInt((int) $parameters->get('maximum-count'));
             }
 
-            $maximumDuration = Duration::fromMilliseconds(500);
+            $maximumDuration = MaximumDuration::default();
 
             if ($parameters->has('maximum-duration')) {
-                $maximumDuration = Duration::fromMilliseconds((int) $parameters->get('maximum-duration'));
+                $maximumDuration = MaximumDuration::fromDuration(Duration::fromMilliseconds((int) $parameters->get('maximum-duration')));
             }
 
             $timeKeeper = new TimeKeeper();
diff --git a/src/MaximumDuration.php b/src/MaximumDuration.php
new file mode 100644
index 00000000..aae4334c
--- /dev/null
+++ b/src/MaximumDuration.php
@@ -0,0 +1,42 @@
+<?php
+
+declare(strict_types=1);
+
+/**
+ * Copyright (c) 2021-2025 Andreas Möller
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE.md file that was distributed with this source code.
+ *
+ * @see https://github.com/ergebnis/phpunit-slow-test-detector
+ */
+
+namespace Ergebnis\PHPUnit\SlowTestDetector;
+
+/**
+ * @internal
+ */
+final class MaximumDuration
+{
+    private $duration;
+
+    private function __construct(Duration $duration)
+    {
+        $this->duration = $duration;
+    }
+
+    public static function fromDuration(Duration $duration): self
+    {
+        return new self($duration);
+    }
+
+    public static function default(): self
+    {
+        return new self(Duration::fromMilliseconds(500));
+    }
+
+    public function toDuration(): Duration
+    {
+        return $this->duration;
+    }
+}
diff --git a/src/Reporter/DefaultReporter.php b/src/Reporter/DefaultReporter.php
index af670e8c..79027da6 100644
--- a/src/Reporter/DefaultReporter.php
+++ b/src/Reporter/DefaultReporter.php
@@ -15,8 +15,8 @@
 
 use Ergebnis\PHPUnit\SlowTestDetector\Comparator;
 use Ergebnis\PHPUnit\SlowTestDetector\Count;
-use Ergebnis\PHPUnit\SlowTestDetector\Duration;
 use Ergebnis\PHPUnit\SlowTestDetector\Formatter;
+use Ergebnis\PHPUnit\SlowTestDetector\MaximumDuration;
 use Ergebnis\PHPUnit\SlowTestDetector\SlowTest;
 
 /**
@@ -30,7 +30,7 @@ final class DefaultReporter implements Reporter
     private $durationFormatter;
 
     /**
-     * @var Duration
+     * @var MaximumDuration
      */
     private $maximumDuration;
 
@@ -46,7 +46,7 @@ final class DefaultReporter implements Reporter
 
     public function __construct(
         Formatter\DurationFormatter $durationFormatter,
-        Duration $maximumDuration,
+        MaximumDuration $maximumDuration,
         Count $maximumCount
     ) {
         $this->durationFormatter = $durationFormatter;
@@ -102,8 +102,8 @@ private function list(SlowTest ...$slowTests): string
 
         \usort($slowTests, static function (SlowTest $one, SlowTest $two) use ($durationComparator): int {
             return $durationComparator->compare(
-                $two->duration(),
-                $one->duration()
+                $two->testDuration()->toDuration(),
+                $one->testDuration()->toDuration()
             );
         });
 
@@ -113,13 +113,13 @@ private function list(SlowTest ...$slowTests): string
             $this->maximumCount->toInt()
         );
 
-        /** @var SlowTest $slowTestWithLongestDuration */
-        $slowTestWithLongestDuration = \reset($slowTestsToReport);
+        /** @var SlowTest $slowTestWithLongestTestDuration */
+        $slowTestWithLongestTestDuration = \reset($slowTestsToReport);
 
         $longestMaximumDuration = \array_reduce(
             $slowTestsToReport,
-            static function (Duration $maximumDuration, SlowTest $slowTest): Duration {
-                if ($maximumDuration->isLessThan($slowTest->maximumDuration())) {
+            static function (MaximumDuration $maximumDuration, SlowTest $slowTest): MaximumDuration {
+                if ($maximumDuration->toDuration()->isLessThan($slowTest->maximumDuration()->toDuration())) {
                     return $slowTest->maximumDuration();
                 }
 
@@ -131,8 +131,8 @@ static function (Duration $maximumDuration, SlowTest $slowTest): Duration {
         $durationFormatter = $this->durationFormatter;
 
         $numberWidth = \strlen((string) \count($slowTestsToReport));
-        $durationWidth = \strlen($durationFormatter->format($slowTestWithLongestDuration->duration()));
-        $maximumDurationWidth = \strlen($durationFormatter->format($longestMaximumDuration));
+        $durationWidth = \strlen($durationFormatter->format($slowTestWithLongestTestDuration->testDuration()->toDuration()));
+        $maximumDurationWidth = \strlen($durationFormatter->format($longestMaximumDuration->toDuration()));
 
         $items = \array_map(static function (int $number, SlowTest $slowTest) use ($numberWidth, $durationFormatter, $durationWidth, $maximumDurationWidth): string {
             $formattedNumber = \str_pad(
@@ -143,7 +143,7 @@ static function (Duration $maximumDuration, SlowTest $slowTest): Duration {
             );
 
             $formattedDuration = \str_pad(
-                $durationFormatter->format($slowTest->duration()),
+                $durationFormatter->format($slowTest->testDuration()->toDuration()),
                 $durationWidth,
                 ' ',
                 \STR_PAD_LEFT
@@ -152,7 +152,7 @@ static function (Duration $maximumDuration, SlowTest $slowTest): Duration {
             $formattedMaximumDuration = \sprintf(
                 '(%s)',
                 \str_pad(
-                    $durationFormatter->format($slowTest->maximumDuration()),
+                    $durationFormatter->format($slowTest->maximumDuration()->toDuration()),
                     $maximumDurationWidth,
                     ' ',
                     \STR_PAD_LEFT
diff --git a/src/SlowTest.php b/src/SlowTest.php
index 9c630d40..07c2f071 100644
--- a/src/SlowTest.php
+++ b/src/SlowTest.php
@@ -29,37 +29,37 @@ final class SlowTest
     private $testDescription;
 
     /**
-     * @var Duration
+     * @var TestDuration
      */
-    private $duration;
+    private $testDuration;
 
     /**
-     * @var Duration
+     * @var MaximumDuration
      */
     private $maximumDuration;
 
     private function __construct(
         TestIdentifier $testIdentifier,
         TestDescription $testDescription,
-        Duration $duration,
-        Duration $maximumDuration
+        TestDuration $testDuration,
+        MaximumDuration $maximumDuration
     ) {
         $this->testIdentifier = $testIdentifier;
         $this->testDescription = $testDescription;
-        $this->duration = $duration;
+        $this->testDuration = $testDuration;
         $this->maximumDuration = $maximumDuration;
     }
 
     public static function create(
         TestIdentifier $testIdentifier,
         TestDescription $testDescription,
-        Duration $duration,
-        Duration $maximumDuration
+        TestDuration $testDuration,
+        MaximumDuration $maximumDuration
     ): self {
         return new self(
             $testIdentifier,
             $testDescription,
-            $duration,
+            $testDuration,
             $maximumDuration
         );
     }
@@ -74,12 +74,12 @@ public function testDescription(): TestDescription
         return $this->testDescription;
     }
 
-    public function duration(): Duration
+    public function testDuration(): TestDuration
     {
-        return $this->duration;
+        return $this->testDuration;
     }
 
-    public function maximumDuration(): Duration
+    public function maximumDuration(): MaximumDuration
     {
         return $this->maximumDuration;
     }
diff --git a/src/Subscriber/Test/FinishedSubscriber.php b/src/Subscriber/Test/FinishedSubscriber.php
index a46bf609..4a334932 100644
--- a/src/Subscriber/Test/FinishedSubscriber.php
+++ b/src/Subscriber/Test/FinishedSubscriber.php
@@ -16,9 +16,11 @@
 use Ergebnis\PHPUnit\SlowTestDetector\Attribute;
 use Ergebnis\PHPUnit\SlowTestDetector\Collector;
 use Ergebnis\PHPUnit\SlowTestDetector\Duration;
+use Ergebnis\PHPUnit\SlowTestDetector\MaximumDuration;
 use Ergebnis\PHPUnit\SlowTestDetector\PhaseIdentifier;
 use Ergebnis\PHPUnit\SlowTestDetector\SlowTest;
 use Ergebnis\PHPUnit\SlowTestDetector\TestDescription;
+use Ergebnis\PHPUnit\SlowTestDetector\TestDuration;
 use Ergebnis\PHPUnit\SlowTestDetector\TestIdentifier;
 use Ergebnis\PHPUnit\SlowTestDetector\Time;
 use Ergebnis\PHPUnit\SlowTestDetector\TimeKeeper;
@@ -33,7 +35,7 @@
 final class FinishedSubscriber implements Event\Test\FinishedSubscriber
 {
     /**
-     * @var Duration
+     * @var MaximumDuration
      */
     private $maximumDuration;
 
@@ -53,7 +55,7 @@ final class FinishedSubscriber implements Event\Test\FinishedSubscriber
     private $versionSeries;
 
     public function __construct(
-        Duration $maximumDuration,
+        MaximumDuration $maximumDuration,
         TimeKeeper $timeKeeper,
         Collector\Collector $collector,
         Version\Series $versionSeries
@@ -82,18 +84,18 @@ public function notify(Event\Test\Finished $event): void
             )
         );
 
-        $duration = $phase->duration();
+        $testDuration = TestDuration::fromDuration($phase->duration());
 
         $maximumDuration = $this->resolveMaximumDuration($event->test());
 
-        if (!$duration->isGreaterThan($maximumDuration)) {
+        if (!$testDuration->toDuration()->isGreaterThan($maximumDuration->toDuration())) {
             return;
         }
 
         $slowTest = SlowTest::create(
             TestIdentifier::fromString($event->test()->id()),
             self::descriptionFromTest($event->test()),
-            $duration,
+            $testDuration,
             $maximumDuration
         );
 
@@ -152,18 +154,18 @@ private static function descriptionFromTest(Event\Code\Test $test): TestDescript
         ));
     }
 
-    private function resolveMaximumDuration(Event\Code\Test $test): Duration
+    private function resolveMaximumDuration(Event\Code\Test $test): MaximumDuration
     {
         $maximumDurationFromAttribute = self::resolveMaximumDurationFromAttribute($test);
 
-        if ($maximumDurationFromAttribute instanceof Duration) {
+        if ($maximumDurationFromAttribute instanceof MaximumDuration) {
             return $maximumDurationFromAttribute;
         }
 
         if ($this->versionSeries->major()->isLessThan(Version\Major::fromInt(12))) {
             $maximumDurationFromAnnotation = self::resolveMaximumDurationFromAnnotation($test);
 
-            if ($maximumDurationFromAnnotation instanceof Duration) {
+            if ($maximumDurationFromAnnotation instanceof MaximumDuration) {
                 return $maximumDurationFromAnnotation;
             }
         }
@@ -171,7 +173,7 @@ private function resolveMaximumDuration(Event\Code\Test $test): Duration
         return $this->maximumDuration;
     }
 
-    private static function resolveMaximumDurationFromAttribute(Event\Code\Test $test): ?Duration
+    private static function resolveMaximumDurationFromAttribute(Event\Code\Test $test): ?MaximumDuration
     {
         /** @var Event\Code\TestMethod $test */
         $methodReflection = new \ReflectionMethod(
@@ -186,13 +188,13 @@ private static function resolveMaximumDurationFromAttribute(Event\Code\Test $tes
 
             $attribute = $attributeReflection->newInstance();
 
-            return Duration::fromMilliseconds($attribute->milliseconds());
+            return MaximumDuration::fromDuration(Duration::fromMilliseconds($attribute->milliseconds()));
         }
 
         return null;
     }
 
-    private static function resolveMaximumDurationFromAnnotation(Event\Code\Test $test): ?Duration
+    private static function resolveMaximumDurationFromAnnotation(Event\Code\Test $test): ?MaximumDuration
     {
         $annotations = [
             'maximumDuration',
@@ -222,7 +224,7 @@ private static function resolveMaximumDurationFromAnnotation(Event\Code\Test $te
                 continue;
             }
 
-            return Duration::fromMilliseconds((int) $maximumDuration);
+            return MaximumDuration::fromDuration(Duration::fromMilliseconds((int) $maximumDuration));
         }
 
         return null;
diff --git a/src/TestDuration.php b/src/TestDuration.php
new file mode 100644
index 00000000..e6629510
--- /dev/null
+++ b/src/TestDuration.php
@@ -0,0 +1,37 @@
+<?php
+
+declare(strict_types=1);
+
+/**
+ * Copyright (c) 2021-2025 Andreas Möller
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE.md file that was distributed with this source code.
+ *
+ * @see https://github.com/ergebnis/phpunit-slow-test-detector
+ */
+
+namespace Ergebnis\PHPUnit\SlowTestDetector;
+
+/**
+ * @internal
+ */
+final class TestDuration
+{
+    private $duration;
+
+    private function __construct(Duration $duration)
+    {
+        $this->duration = $duration;
+    }
+
+    public static function fromDuration(Duration $duration): self
+    {
+        return new self($duration);
+    }
+
+    public function toDuration(): Duration
+    {
+        return $this->duration;
+    }
+}
diff --git a/test/Unit/Collector/DefaultCollectorTest.php b/test/Unit/Collector/DefaultCollectorTest.php
index 5e291fa1..eaa496a4 100644
--- a/test/Unit/Collector/DefaultCollectorTest.php
+++ b/test/Unit/Collector/DefaultCollectorTest.php
@@ -15,9 +15,11 @@
 
 use Ergebnis\PHPUnit\SlowTestDetector\Collector;
 use Ergebnis\PHPUnit\SlowTestDetector\Duration;
+use Ergebnis\PHPUnit\SlowTestDetector\MaximumDuration;
 use Ergebnis\PHPUnit\SlowTestDetector\SlowTest;
 use Ergebnis\PHPUnit\SlowTestDetector\Test;
 use Ergebnis\PHPUnit\SlowTestDetector\TestDescription;
+use Ergebnis\PHPUnit\SlowTestDetector\TestDuration;
 use Ergebnis\PHPUnit\SlowTestDetector\TestIdentifier;
 use PHPUnit\Framework;
 
@@ -25,8 +27,10 @@
  * @covers \Ergebnis\PHPUnit\SlowTestDetector\Collector\DefaultCollector
  *
  * @uses \Ergebnis\PHPUnit\SlowTestDetector\Duration
+ * @uses \Ergebnis\PHPUnit\SlowTestDetector\MaximumDuration
  * @uses \Ergebnis\PHPUnit\SlowTestDetector\SlowTest
  * @uses \Ergebnis\PHPUnit\SlowTestDetector\TestDescription
+ * @uses \Ergebnis\PHPUnit\SlowTestDetector\TestDuration
  * @uses \Ergebnis\PHPUnit\SlowTestDetector\TestIdentifier
  */
 final class DefaultCollectorTest extends Framework\TestCase
@@ -40,15 +44,15 @@ public function testCollectSlowTestCollectsSlowTests()
         $one = SlowTest::create(
             TestIdentifier::fromString($faker->word()),
             TestDescription::fromString($faker->word()),
-            Duration::fromMilliseconds($faker->numberBetween(0)),
-            Duration::fromMilliseconds($faker->numberBetween(0))
+            TestDuration::fromDuration(Duration::fromMilliseconds($faker->numberBetween(0))),
+            MaximumDuration::fromDuration(Duration::fromMilliseconds($faker->numberBetween(0)))
         );
 
         $two = SlowTest::create(
             TestIdentifier::fromString($faker->word()),
             TestDescription::fromString($faker->word()),
-            Duration::fromMilliseconds($faker->numberBetween(0)),
-            Duration::fromMilliseconds($faker->numberBetween(0))
+            TestDuration::fromDuration(Duration::fromMilliseconds($faker->numberBetween(0))),
+            MaximumDuration::fromDuration(Duration::fromMilliseconds($faker->numberBetween(0)))
         );
 
         $collector = new Collector\DefaultCollector();
@@ -71,17 +75,17 @@ public function testCollectSlowTestCollectsSlowerTestWithSameTestIdentifier()
         $one = SlowTest::create(
             TestIdentifier::fromString($faker->word()),
             TestDescription::fromString($faker->word()),
-            Duration::fromMilliseconds($faker->numberBetween(0)),
-            Duration::fromMilliseconds($faker->numberBetween(0, 999999999 - 1))
+            TestDuration::fromDuration(Duration::fromMilliseconds($faker->numberBetween(0))),
+            MaximumDuration::fromDuration(Duration::fromMilliseconds($faker->numberBetween(0, 999999999 - 1)))
         );
 
         $two = SlowTest::create(
             $one->testIdentifier(),
             TestDescription::fromString($faker->word()),
-            Duration::fromSecondsAndNanoseconds(
-                $one->duration()->seconds(),
-                $one->duration()->nanoseconds() + 1
-            ),
+            TestDuration::fromDuration(Duration::fromSecondsAndNanoseconds(
+                $one->testDuration()->toDuration()->seconds(),
+                $one->testDuration()->toDuration()->nanoseconds() + 1
+            )),
             $one->maximumDuration()
         );
 
@@ -104,17 +108,17 @@ public function testCollectSlowTestDoesNotCollectFasterTestWithSameTestIdentifie
         $one = SlowTest::create(
             TestIdentifier::fromString($faker->word()),
             TestDescription::fromString($faker->word()),
-            Duration::fromMilliseconds($faker->numberBetween(0)),
-            Duration::fromMilliseconds($faker->numberBetween(1, 999999999))
+            TestDuration::fromDuration(Duration::fromMilliseconds($faker->numberBetween(0))),
+            MaximumDuration::fromDuration(Duration::fromMilliseconds($faker->numberBetween(1, 999999999)))
         );
 
         $two = SlowTest::create(
             $one->testIdentifier(),
             TestDescription::fromString($faker->word()),
-            Duration::fromSecondsAndNanoseconds(
-                $one->duration()->seconds(),
-                $one->duration()->nanoseconds() - 1
-            ),
+            TestDuration::fromDuration(Duration::fromSecondsAndNanoseconds(
+                $one->testDuration()->toDuration()->seconds(),
+                $one->testDuration()->toDuration()->nanoseconds() - 1
+            )),
             $one->maximumDuration()
         );
 
diff --git a/test/Unit/MaximumDurationTest.php b/test/Unit/MaximumDurationTest.php
new file mode 100644
index 00000000..3bd7f51e
--- /dev/null
+++ b/test/Unit/MaximumDurationTest.php
@@ -0,0 +1,49 @@
+<?php
+
+declare(strict_types=1);
+
+/**
+ * Copyright (c) 2021-2025 Andreas Möller
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE.md file that was distributed with this source code.
+ *
+ * @see https://github.com/ergebnis/phpunit-slow-test-detector
+ */
+
+namespace Ergebnis\PHPUnit\SlowTestDetector\Test\Unit;
+
+use Ergebnis\PHPUnit\SlowTestDetector\Duration;
+use Ergebnis\PHPUnit\SlowTestDetector\MaximumDuration;
+use Ergebnis\PHPUnit\SlowTestDetector\Test;
+use PHPUnit\Framework;
+
+/**
+ * @covers \Ergebnis\PHPUnit\SlowTestDetector\MaximumDuration
+ *
+ * @uses \Ergebnis\PHPUnit\SlowTestDetector\Duration
+ */
+final class MaximumDurationTest extends Framework\TestCase
+{
+    use Test\Util\Helper;
+
+    public function testFromDurationReturnsMaximumDuration()
+    {
+        $faker = self::faker();
+
+        $duration = Duration::fromMilliseconds($faker->numberBetween(0));
+
+        $maximumDuration = MaximumDuration::fromDuration($duration);
+
+        self::assertSame($duration, $maximumDuration->toDuration());
+    }
+
+    public function testDefaultReturnsMaximumDuration()
+    {
+        $maximumDuration = MaximumDuration::default();
+
+        $expected = Duration::fromMilliseconds(500);
+
+        self::assertEquals($expected, $maximumDuration->toDuration());
+    }
+}
diff --git a/test/Unit/Reporter/DefaultReporterTest.php b/test/Unit/Reporter/DefaultReporterTest.php
index c1a14d0b..eca1d4cf 100644
--- a/test/Unit/Reporter/DefaultReporterTest.php
+++ b/test/Unit/Reporter/DefaultReporterTest.php
@@ -16,10 +16,12 @@
 use Ergebnis\PHPUnit\SlowTestDetector\Count;
 use Ergebnis\PHPUnit\SlowTestDetector\Duration;
 use Ergebnis\PHPUnit\SlowTestDetector\Formatter;
+use Ergebnis\PHPUnit\SlowTestDetector\MaximumDuration;
 use Ergebnis\PHPUnit\SlowTestDetector\Reporter;
 use Ergebnis\PHPUnit\SlowTestDetector\SlowTest;
 use Ergebnis\PHPUnit\SlowTestDetector\Test;
 use Ergebnis\PHPUnit\SlowTestDetector\TestDescription;
+use Ergebnis\PHPUnit\SlowTestDetector\TestDuration;
 use Ergebnis\PHPUnit\SlowTestDetector\TestIdentifier;
 use PHPUnit\Framework;
 
@@ -30,8 +32,10 @@
  * @uses \Ergebnis\PHPUnit\SlowTestDetector\Count
  * @uses \Ergebnis\PHPUnit\SlowTestDetector\Duration
  * @uses \Ergebnis\PHPUnit\SlowTestDetector\Formatter\DefaultDurationFormatter
+ * @uses \Ergebnis\PHPUnit\SlowTestDetector\MaximumDuration
  * @uses \Ergebnis\PHPUnit\SlowTestDetector\SlowTest
  * @uses \Ergebnis\PHPUnit\SlowTestDetector\TestDescription
+ * @uses \Ergebnis\PHPUnit\SlowTestDetector\TestDuration
  * @uses \Ergebnis\PHPUnit\SlowTestDetector\TestIdentifier
  */
 final class DefaultReporterTest extends Framework\TestCase
@@ -44,7 +48,7 @@ public function testReportReturnsEmptyStringWhenThereAreNoSlowTests()
 
         $reporter = new Reporter\DefaultReporter(
             new Formatter\DefaultDurationFormatter(),
-            Duration::fromMilliseconds($faker->numberBetween(0)),
+            MaximumDuration::fromDuration(Duration::fromMilliseconds($faker->numberBetween(0))),
             Count::fromInt($faker->numberBetween(1))
         );
 
@@ -60,7 +64,7 @@ public function testReportReturnsEmptyStringWhenThereAreNoSlowTests()
      */
     public function testReportReturnsReportWhenThereAreFewerSlowTestsThanMaximumCount(
         string $expectedReport,
-        Duration $maximumDuration,
+        MaximumDuration $maximumDuration,
         Count $maximumCount,
         array $slowTests
     ) {
@@ -76,7 +80,7 @@ public function testReportReturnsReportWhenThereAreFewerSlowTestsThanMaximumCoun
     }
 
     /**
-     * @return \Generator<string, array{0: string, 1: Duration, 2: Count, 3: list<SlowTest>}>
+     * @return \Generator<string, array{0: string, 1: MaximumDuration, 2: Count, 3: list<SlowTest>}>
      */
     public static function provideExpectedReportMaximumDurationMaximumCountAndSlowTests(): iterable
     {
@@ -88,14 +92,14 @@ public static function provideExpectedReportMaximumDurationMaximumCountAndSlowTe
 1. 0.300 (0.100) FooTest::test
 TXT
                 ,
-                Duration::fromMilliseconds(500),
+                MaximumDuration::fromDuration(Duration::fromMilliseconds(500)),
                 Count::fromInt(1),
                 [
                     SlowTest::create(
                         TestIdentifier::fromString('FooTest::test'),
                         TestDescription::fromString('FooTest::test'),
-                        Duration::fromMilliseconds(300),
-                        Duration::fromMilliseconds(100)
+                        TestDuration::fromDuration(Duration::fromMilliseconds(300)),
+                        MaximumDuration::fromDuration(Duration::fromMilliseconds(100))
                     ),
                 ],
             ],
@@ -107,20 +111,20 @@ public static function provideExpectedReportMaximumDurationMaximumCountAndSlowTe
 2. 0.275 (0.100) BarTest::test
 TXT
                 ,
-                Duration::fromMilliseconds(500),
+                MaximumDuration::fromDuration(Duration::fromMilliseconds(500)),
                 Count::fromInt(2),
                 [
                     SlowTest::create(
                         TestIdentifier::fromString('FooTest::test'),
                         TestDescription::fromString('FooTest::test'),
-                        Duration::fromMilliseconds(300),
-                        Duration::fromMilliseconds(100)
+                        TestDuration::fromDuration(Duration::fromMilliseconds(300)),
+                        MaximumDuration::fromDuration(Duration::fromMilliseconds(100))
                     ),
                     SlowTest::create(
                         TestIdentifier::fromString('BarTest::test'),
                         TestDescription::fromString('BarTest::test'),
-                        Duration::fromMilliseconds(275),
-                        Duration::fromMilliseconds(100)
+                        TestDuration::fromDuration(Duration::fromMilliseconds(275)),
+                        MaximumDuration::fromDuration(Duration::fromMilliseconds(100))
                     ),
                 ],
             ],
@@ -133,26 +137,26 @@ public static function provideExpectedReportMaximumDurationMaximumCountAndSlowTe
 3. 0.250 (0.100) BazTest::test
 TXT
                 ,
-                Duration::fromMilliseconds(500),
+                MaximumDuration::fromDuration(Duration::fromMilliseconds(500)),
                 Count::fromInt(3),
                 [
                     SlowTest::create(
                         TestIdentifier::fromString('FooTest::test'),
                         TestDescription::fromString('FooTest::test'),
-                        Duration::fromMilliseconds(300),
-                        Duration::fromMilliseconds(100)
+                        TestDuration::fromDuration(Duration::fromMilliseconds(300)),
+                        MaximumDuration::fromDuration(Duration::fromMilliseconds(100))
                     ),
                     SlowTest::create(
                         TestIdentifier::fromString('BarTest::test'),
                         TestDescription::fromString('BarTest::test'),
-                        Duration::fromMilliseconds(275),
-                        Duration::fromMilliseconds(100)
+                        TestDuration::fromDuration(Duration::fromMilliseconds(275)),
+                        MaximumDuration::fromDuration(Duration::fromMilliseconds(100))
                     ),
                     SlowTest::create(
                         TestIdentifier::fromString('BazTest::test'),
                         TestDescription::fromString('BazTest::test'),
-                        Duration::fromMilliseconds(250),
-                        Duration::fromMilliseconds(100)
+                        TestDuration::fromDuration(Duration::fromMilliseconds(250)),
+                        MaximumDuration::fromDuration(Duration::fromMilliseconds(100))
                     ),
                 ],
             ],
@@ -165,26 +169,26 @@ public static function provideExpectedReportMaximumDurationMaximumCountAndSlowTe
 3. 0.250 (0.100) BazTest::test
 TXT
                 ,
-                Duration::fromMilliseconds(500),
+                MaximumDuration::fromDuration(Duration::fromMilliseconds(500)),
                 Count::fromInt(3),
                 [
                     SlowTest::create(
                         TestIdentifier::fromString('BazTest::test'),
                         TestDescription::fromString('BazTest::test'),
-                        Duration::fromMilliseconds(250),
-                        Duration::fromMilliseconds(100)
+                        TestDuration::fromDuration(Duration::fromMilliseconds(250)),
+                        MaximumDuration::fromDuration(Duration::fromMilliseconds(100))
                     ),
                     SlowTest::create(
                         TestIdentifier::fromString('BarTest::test'),
                         TestDescription::fromString('BarTest::test'),
-                        Duration::fromMilliseconds(275),
-                        Duration::fromMilliseconds(100)
+                        TestDuration::fromDuration(Duration::fromMilliseconds(275)),
+                        MaximumDuration::fromDuration(Duration::fromMilliseconds(100))
                     ),
                     SlowTest::create(
                         TestIdentifier::fromString('FooTest::test'),
                         TestDescription::fromString('FooTest::test'),
-                        Duration::fromMilliseconds(300),
-                        Duration::fromMilliseconds(100)
+                        TestDuration::fromDuration(Duration::fromMilliseconds(300)),
+                        MaximumDuration::fromDuration(Duration::fromMilliseconds(100))
                     ),
                 ],
             ],
@@ -204,68 +208,68 @@ public static function provideExpectedReportMaximumDurationMaximumCountAndSlowTe
 10.     0.110 (    0.100) FredTest::test
 TXT
                 ,
-                Duration::fromMilliseconds(500),
+                MaximumDuration::fromDuration(Duration::fromMilliseconds(500)),
                 Count::fromInt(10),
                 [
                     SlowTest::create(
                         TestIdentifier::fromString('FooTest::test'),
                         TestDescription::fromString('FooTest::test'),
-                        Duration::fromMilliseconds(1250000),
-                        Duration::fromMilliseconds(1000000)
+                        TestDuration::fromDuration(Duration::fromMilliseconds(1250000)),
+                        MaximumDuration::fromDuration(Duration::fromMilliseconds(1000000))
                     ),
                     SlowTest::create(
                         TestIdentifier::fromString('BarTest::test'),
                         TestDescription::fromString('BarTest::test'),
-                        Duration::fromMilliseconds(575000),
-                        Duration::fromMilliseconds(500000)
+                        TestDuration::fromDuration(Duration::fromMilliseconds(575000)),
+                        MaximumDuration::fromDuration(Duration::fromMilliseconds(500000))
                     ),
                     SlowTest::create(
                         TestIdentifier::fromString('BazTest::test'),
                         TestDescription::fromString('BazTest::test'),
-                        Duration::fromMilliseconds(250),
-                        Duration::fromMilliseconds(100)
+                        TestDuration::fromDuration(Duration::fromMilliseconds(250)),
+                        MaximumDuration::fromDuration(Duration::fromMilliseconds(100))
                     ),
                     SlowTest::create(
                         TestIdentifier::fromString('QuxTest::test'),
                         TestDescription::fromString('QuxTest::test'),
-                        Duration::fromMilliseconds(200),
-                        Duration::fromMilliseconds(100)
+                        TestDuration::fromDuration(Duration::fromMilliseconds(200)),
+                        MaximumDuration::fromDuration(Duration::fromMilliseconds(100))
                     ),
                     SlowTest::create(
                         TestIdentifier::fromString('QuuxTest::test'),
                         TestDescription::fromString('QuuxTest::test'),
-                        Duration::fromMilliseconds(160),
-                        Duration::fromMilliseconds(100)
+                        TestDuration::fromDuration(Duration::fromMilliseconds(160)),
+                        MaximumDuration::fromDuration(Duration::fromMilliseconds(100))
                     ),
                     SlowTest::create(
                         TestIdentifier::fromString('CorgeTest::test'),
                         TestDescription::fromString('CorgeTest::test'),
-                        Duration::fromMilliseconds(150),
-                        Duration::fromMilliseconds(100)
+                        TestDuration::fromDuration(Duration::fromMilliseconds(150)),
+                        MaximumDuration::fromDuration(Duration::fromMilliseconds(100))
                     ),
                     SlowTest::create(
                         TestIdentifier::fromString('GraultTest::test'),
                         TestDescription::fromString('GraultTest::test'),
-                        Duration::fromMilliseconds(140),
-                        Duration::fromMilliseconds(100)
+                        TestDuration::fromDuration(Duration::fromMilliseconds(140)),
+                        MaximumDuration::fromDuration(Duration::fromMilliseconds(100))
                     ),
                     SlowTest::create(
                         TestIdentifier::fromString('GarplyTest::test'),
                         TestDescription::fromString('GarplyTest::test'),
-                        Duration::fromMilliseconds(130),
-                        Duration::fromMilliseconds(100)
+                        TestDuration::fromDuration(Duration::fromMilliseconds(130)),
+                        MaximumDuration::fromDuration(Duration::fromMilliseconds(100))
                     ),
                     SlowTest::create(
                         TestIdentifier::fromString('WaldoTest::test'),
                         TestDescription::fromString('WaldoTest::test'),
-                        Duration::fromMilliseconds(120),
-                        Duration::fromMilliseconds(100)
+                        TestDuration::fromDuration(Duration::fromMilliseconds(120)),
+                        MaximumDuration::fromDuration(Duration::fromMilliseconds(100))
                     ),
                     SlowTest::create(
                         TestIdentifier::fromString('FredTest::test'),
                         TestDescription::fromString('FredTest::test'),
-                        Duration::fromMilliseconds(110),
-                        Duration::fromMilliseconds(100)
+                        TestDuration::fromDuration(Duration::fromMilliseconds(110)),
+                        MaximumDuration::fromDuration(Duration::fromMilliseconds(100))
                     ),
                 ],
             ],
@@ -278,20 +282,20 @@ public static function provideExpectedReportMaximumDurationMaximumCountAndSlowTe
 There is 1 additional slow test that is not listed here.
 TXT
                 ,
-                Duration::fromMilliseconds(500),
+                MaximumDuration::fromDuration(Duration::fromMilliseconds(500)),
                 Count::fromInt(1),
                 [
                     SlowTest::create(
                         TestIdentifier::fromString('FooTest::test'),
                         TestDescription::fromString('FooTest::test'),
-                        Duration::fromMilliseconds(300),
-                        Duration::fromMilliseconds(100)
+                        TestDuration::fromDuration(Duration::fromMilliseconds(300)),
+                        MaximumDuration::fromDuration(Duration::fromMilliseconds(100))
                     ),
                     SlowTest::create(
                         TestIdentifier::fromString('BarTest::test'),
                         TestDescription::fromString('BarTest::test'),
-                        Duration::fromMilliseconds(275),
-                        Duration::fromMilliseconds(100)
+                        TestDuration::fromDuration(Duration::fromMilliseconds(275)),
+                        MaximumDuration::fromDuration(Duration::fromMilliseconds(100))
                     ),
                 ],
             ],
@@ -304,26 +308,26 @@ public static function provideExpectedReportMaximumDurationMaximumCountAndSlowTe
 There are 2 additional slow tests that are not listed here.
 TXT
                 ,
-                Duration::fromMilliseconds(500),
+                MaximumDuration::fromDuration(Duration::fromMilliseconds(500)),
                 Count::fromInt(1),
                 [
                     SlowTest::create(
                         TestIdentifier::fromString('FooTest::test'),
                         TestDescription::fromString('FooTest::test'),
-                        Duration::fromMilliseconds(300),
-                        Duration::fromMilliseconds(100)
+                        TestDuration::fromDuration(Duration::fromMilliseconds(300)),
+                        MaximumDuration::fromDuration(Duration::fromMilliseconds(100))
                     ),
                     SlowTest::create(
                         TestIdentifier::fromString('BarTest::test'),
                         TestDescription::fromString('BarTest::test'),
-                        Duration::fromMilliseconds(275),
-                        Duration::fromMilliseconds(100)
+                        TestDuration::fromDuration(Duration::fromMilliseconds(275)),
+                        MaximumDuration::fromDuration(Duration::fromMilliseconds(100))
                     ),
                     SlowTest::create(
                         TestIdentifier::fromString('BazTest::test'),
                         TestDescription::fromString('BazTest::test'),
-                        Duration::fromMilliseconds(250),
-                        Duration::fromMilliseconds(100)
+                        TestDuration::fromDuration(Duration::fromMilliseconds(250)),
+                        MaximumDuration::fromDuration(Duration::fromMilliseconds(100))
                     ),
                 ],
             ],
diff --git a/test/Unit/SlowTestTest.php b/test/Unit/SlowTestTest.php
index 50bc33be..6ebaf562 100644
--- a/test/Unit/SlowTestTest.php
+++ b/test/Unit/SlowTestTest.php
@@ -14,9 +14,11 @@
 namespace Ergebnis\PHPUnit\SlowTestDetector\Test\Unit;
 
 use Ergebnis\PHPUnit\SlowTestDetector\Duration;
+use Ergebnis\PHPUnit\SlowTestDetector\MaximumDuration;
 use Ergebnis\PHPUnit\SlowTestDetector\SlowTest;
 use Ergebnis\PHPUnit\SlowTestDetector\Test;
 use Ergebnis\PHPUnit\SlowTestDetector\TestDescription;
+use Ergebnis\PHPUnit\SlowTestDetector\TestDuration;
 use Ergebnis\PHPUnit\SlowTestDetector\TestIdentifier;
 use PHPUnit\Framework;
 
@@ -24,7 +26,9 @@
  * @covers \Ergebnis\PHPUnit\SlowTestDetector\SlowTest
  *
  * @uses \Ergebnis\PHPUnit\SlowTestDetector\Duration
+ * @uses \Ergebnis\PHPUnit\SlowTestDetector\MaximumDuration
  * @uses \Ergebnis\PHPUnit\SlowTestDetector\TestDescription
+ * @uses \Ergebnis\PHPUnit\SlowTestDetector\TestDuration
  * @uses \Ergebnis\PHPUnit\SlowTestDetector\TestIdentifier
  */
 final class SlowTestTest extends Framework\TestCase
@@ -37,19 +41,19 @@ public function testCreateReturnsSlowTest()
 
         $testIdentifier = TestIdentifier::fromString($faker->word());
         $testDescription = TestDescription::fromString($faker->word());
-        $duration = Duration::fromMilliseconds($faker->numberBetween(0));
-        $maximumDuration = Duration::fromMilliseconds($faker->numberBetween(0));
+        $testDuration = TestDuration::fromDuration(Duration::fromMilliseconds($faker->numberBetween(0)));
+        $maximumDuration = MaximumDuration::fromDuration(Duration::fromMilliseconds($faker->numberBetween(0)));
 
         $slowTest = SlowTest::create(
             $testIdentifier,
             $testDescription,
-            $duration,
+            $testDuration,
             $maximumDuration
         );
 
         self::assertSame($testIdentifier, $slowTest->testIdentifier());
         self::assertSame($testDescription, $slowTest->testDescription());
-        self::assertSame($duration, $slowTest->duration());
+        self::assertSame($testDuration, $slowTest->testDuration());
         self::assertSame($maximumDuration, $slowTest->maximumDuration());
     }
 }
diff --git a/test/Unit/TestDurationTest.php b/test/Unit/TestDurationTest.php
new file mode 100644
index 00000000..a6053ddb
--- /dev/null
+++ b/test/Unit/TestDurationTest.php
@@ -0,0 +1,40 @@
+<?php
+
+declare(strict_types=1);
+
+/**
+ * Copyright (c) 2021-2025 Andreas Möller
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE.md file that was distributed with this source code.
+ *
+ * @see https://github.com/ergebnis/phpunit-slow-test-detector
+ */
+
+namespace Ergebnis\PHPUnit\SlowTestDetector\Test\Unit;
+
+use Ergebnis\PHPUnit\SlowTestDetector\Duration;
+use Ergebnis\PHPUnit\SlowTestDetector\Test;
+use Ergebnis\PHPUnit\SlowTestDetector\TestDuration;
+use PHPUnit\Framework;
+
+/**
+ * @covers \Ergebnis\PHPUnit\SlowTestDetector\TestDuration
+ *
+ * @uses \Ergebnis\PHPUnit\SlowTestDetector\Duration
+ */
+final class TestDurationTest extends Framework\TestCase
+{
+    use Test\Util\Helper;
+
+    public function testFromDurationReturnsTestDuration()
+    {
+        $faker = self::faker();
+
+        $duration = Duration::fromMilliseconds($faker->numberBetween(0));
+
+        $testDuration = TestDuration::fromDuration($duration);
+
+        self::assertSame($duration, $testDuration->toDuration());
+    }
+}