diff --git a/src/Middleware/TransformMiddleware.php b/src/Middleware/TransformMiddleware.php
index 9c42041..d9464c2 100644
--- a/src/Middleware/TransformMiddleware.php
+++ b/src/Middleware/TransformMiddleware.php
@@ -8,7 +8,6 @@
 use Patchlevel\Hydrator\DenormalizationFailure;
 use Patchlevel\Hydrator\Metadata\ClassMetadata;
 use Patchlevel\Hydrator\NormalizationFailure;
-use Patchlevel\Hydrator\Normalizer\ContextAwareNormalizer;
 use Patchlevel\Hydrator\TypeMismatch;
 use ReflectionParameter;
 use Throwable;
@@ -62,13 +61,8 @@ public function hydrate(ClassMetadata $metadata, array $data, array $context, St
 
             if ($propertyMetadata->normalizer) {
                 try {
-                    if ($propertyMetadata->normalizer instanceof ContextAwareNormalizer) {
-                        /** @psalm-suppress MixedAssignment */
-                        $value = $propertyMetadata->normalizer->denormalize($data[$propertyMetadata->fieldName], $context);
-                    } else {
-                        /** @psalm-suppress MixedAssignment */
-                        $value = $propertyMetadata->normalizer->denormalize($data[$propertyMetadata->fieldName]);
-                    }
+                    /** @psalm-suppress MixedAssignment */
+                    $value = $propertyMetadata->normalizer->denormalize($data[$propertyMetadata->fieldName], $context);
                 } catch (Throwable $e) {
                     throw new DenormalizationFailure(
                         $metadata->className,
@@ -119,18 +113,11 @@ public function extract(ClassMetadata $metadata, object $object, array $context,
             foreach ($metadata->properties as $propertyMetadata) {
                 if ($propertyMetadata->normalizer) {
                     try {
-                        if ($propertyMetadata->normalizer instanceof ContextAwareNormalizer) {
-                            /** @psalm-suppress MixedAssignment */
-                            $data[$propertyMetadata->fieldName] = $propertyMetadata->normalizer->normalize(
-                                $propertyMetadata->getValue($object),
-                                $context,
-                            );
-                        } else {
-                            /** @psalm-suppress MixedAssignment */
-                            $data[$propertyMetadata->fieldName] = $propertyMetadata->normalizer->normalize(
-                                $propertyMetadata->getValue($object),
-                            );
-                        }
+                        /** @psalm-suppress MixedAssignment */
+                        $data[$propertyMetadata->fieldName] = $propertyMetadata->normalizer->normalize(
+                            $propertyMetadata->getValue($object),
+                            $context,
+                        );
                     } catch (CircularReference $e) {
                         throw $e;
                     } catch (Throwable $e) {
diff --git a/src/Normalizer/ArrayNormalizer.php b/src/Normalizer/ArrayNormalizer.php
index c9c33be..69e55b4 100644
--- a/src/Normalizer/ArrayNormalizer.php
+++ b/src/Normalizer/ArrayNormalizer.php
@@ -20,8 +20,12 @@ public function __construct(
     ) {
     }
 
-    /** @return array<array-key, mixed>|null */
-    public function normalize(mixed $value): array|null
+    /**
+     * @param array<string, mixed> $context
+     *
+     * @return array<array-key, mixed>|null
+     */
+    public function normalize(mixed $value, array $context): array|null
     {
         if ($value === null) {
             return null;
@@ -32,14 +36,18 @@ public function normalize(mixed $value): array|null
         }
 
         foreach ($value as &$item) {
-            $item = $this->normalizer->normalize($item);
+            $item = $this->normalizer->normalize($item, $context);
         }
 
         return $value;
     }
 
-    /** @return array<array-key, mixed>|null */
-    public function denormalize(mixed $value): array|null
+    /**
+     * @param array<string, mixed> $context
+     *
+     * @return array<array-key, mixed>|null
+     */
+    public function denormalize(mixed $value, array $context): array|null
     {
         if ($value === null) {
             return null;
@@ -50,7 +58,7 @@ public function denormalize(mixed $value): array|null
         }
 
         foreach ($value as &$item) {
-            $item = $this->normalizer->denormalize($item);
+            $item = $this->normalizer->denormalize($item, $context);
         }
 
         return $value;
diff --git a/src/Normalizer/ArrayShapeNormalizer.php b/src/Normalizer/ArrayShapeNormalizer.php
index 64c10eb..b9abbeb 100644
--- a/src/Normalizer/ArrayShapeNormalizer.php
+++ b/src/Normalizer/ArrayShapeNormalizer.php
@@ -21,8 +21,12 @@ public function __construct(
     ) {
     }
 
-    /** @return array<array-key, mixed>|null */
-    public function normalize(mixed $value): array|null
+    /**
+     * @param array<string, mixed> $context
+     *
+     * @return array<array-key, mixed>|null
+     */
+    public function normalize(mixed $value, array $context): array|null
     {
         if ($value === null) {
             return null;
@@ -39,14 +43,18 @@ public function normalize(mixed $value): array|null
                 continue;
             }
 
-            $result[$field] = $normalizer->normalize($value[$field]);
+            $result[$field] = $normalizer->normalize($value[$field], $context);
         }
 
         return $result;
     }
 
-    /** @return array<array-key, mixed>|null */
-    public function denormalize(mixed $value): array|null
+    /**
+     * @param array<string, mixed> $context
+     *
+     * @return array<array-key, mixed>|null
+     */
+    public function denormalize(mixed $value, array $context): array|null
     {
         if ($value === null) {
             return null;
@@ -63,7 +71,7 @@ public function denormalize(mixed $value): array|null
                 continue;
             }
 
-            $result[$field] = $normalizer->denormalize($value[$field]);
+            $result[$field] = $normalizer->denormalize($value[$field], $context);
         }
 
         return $result;
diff --git a/src/Normalizer/ContextAwareNormalizer.php b/src/Normalizer/ContextAwareNormalizer.php
deleted file mode 100644
index 757eb05..0000000
--- a/src/Normalizer/ContextAwareNormalizer.php
+++ /dev/null
@@ -1,22 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Patchlevel\Hydrator\Normalizer;
-
-interface ContextAwareNormalizer extends Normalizer
-{
-    /**
-     * @param array<string, mixed> $context
-     *
-     * @throws InvalidArgument
-     */
-    public function normalize(mixed $value, array $context = []): mixed;
-
-    /**
-     * @param array<string, mixed> $context
-     *
-     * @throws InvalidArgument
-     */
-    public function denormalize(mixed $value, array $context = []): mixed;
-}
diff --git a/src/Normalizer/DateTimeImmutableNormalizer.php b/src/Normalizer/DateTimeImmutableNormalizer.php
index 64b65a4..41ce153 100644
--- a/src/Normalizer/DateTimeImmutableNormalizer.php
+++ b/src/Normalizer/DateTimeImmutableNormalizer.php
@@ -17,7 +17,8 @@ public function __construct(
     ) {
     }
 
-    public function normalize(mixed $value): string|null
+    /** @param array<string, mixed> $context */
+    public function normalize(mixed $value, array $context): string|null
     {
         if ($value === null) {
             return null;
@@ -30,7 +31,8 @@ public function normalize(mixed $value): string|null
         return $value->format($this->format);
     }
 
-    public function denormalize(mixed $value): DateTimeImmutable|null
+    /** @param array<string, mixed> $context */
+    public function denormalize(mixed $value, array $context): DateTimeImmutable|null
     {
         if ($value === null) {
             return null;
diff --git a/src/Normalizer/DateTimeNormalizer.php b/src/Normalizer/DateTimeNormalizer.php
index 0beb68b..d7a2f43 100644
--- a/src/Normalizer/DateTimeNormalizer.php
+++ b/src/Normalizer/DateTimeNormalizer.php
@@ -17,7 +17,8 @@ public function __construct(
     ) {
     }
 
-    public function normalize(mixed $value): string|null
+    /** @param array<string, mixed> $context */
+    public function normalize(mixed $value, array $context): string|null
     {
         if ($value === null) {
             return null;
@@ -30,7 +31,8 @@ public function normalize(mixed $value): string|null
         return $value->format($this->format);
     }
 
-    public function denormalize(mixed $value): DateTime|null
+    /** @param array<string, mixed> $context */
+    public function denormalize(mixed $value, array $context): DateTime|null
     {
         if ($value === null) {
             return null;
diff --git a/src/Normalizer/DateTimeZoneNormalizer.php b/src/Normalizer/DateTimeZoneNormalizer.php
index 97f2e35..8be21ab 100644
--- a/src/Normalizer/DateTimeZoneNormalizer.php
+++ b/src/Normalizer/DateTimeZoneNormalizer.php
@@ -12,7 +12,8 @@
 #[Attribute(Attribute::TARGET_PROPERTY)]
 final class DateTimeZoneNormalizer implements Normalizer
 {
-    public function normalize(mixed $value): string|null
+    /** @param array<string, mixed> $context */
+    public function normalize(mixed $value, array $context): string|null
     {
         if ($value === null) {
             return null;
@@ -25,7 +26,8 @@ public function normalize(mixed $value): string|null
         return $value->getName();
     }
 
-    public function denormalize(mixed $value): DateTimeZone|null
+    /** @param array<string, mixed> $context */
+    public function denormalize(mixed $value, array $context): DateTimeZone|null
     {
         if ($value === null) {
             return null;
diff --git a/src/Normalizer/EnumNormalizer.php b/src/Normalizer/EnumNormalizer.php
index aede8c2..cf806d4 100644
--- a/src/Normalizer/EnumNormalizer.php
+++ b/src/Normalizer/EnumNormalizer.php
@@ -23,7 +23,8 @@ public function __construct(
     ) {
     }
 
-    public function normalize(mixed $value): mixed
+    /** @param array<string, mixed> $context */
+    public function normalize(mixed $value, array $context): mixed
     {
         if ($value === null) {
             return null;
@@ -38,7 +39,8 @@ public function normalize(mixed $value): mixed
         return $value->value;
     }
 
-    public function denormalize(mixed $value): BackedEnum|null
+    /** @param array<string, mixed> $context */
+    public function denormalize(mixed $value, array $context): BackedEnum|null
     {
         if ($value === null) {
             return null;
diff --git a/src/Normalizer/Normalizer.php b/src/Normalizer/Normalizer.php
index a6fb1e0..6662e5c 100644
--- a/src/Normalizer/Normalizer.php
+++ b/src/Normalizer/Normalizer.php
@@ -6,9 +6,17 @@
 
 interface Normalizer
 {
-    /** @throws InvalidArgument */
-    public function normalize(mixed $value): mixed;
+    /**
+     * @param array<string, mixed> $context
+     *
+     * @throws InvalidArgument
+     */
+    public function normalize(mixed $value, array $context): mixed;
 
-    /** @throws InvalidArgument */
-    public function denormalize(mixed $value): mixed;
+    /**
+     * @param array<string, mixed> $context
+     *
+     * @throws InvalidArgument
+     */
+    public function denormalize(mixed $value, array $context): mixed;
 }
diff --git a/src/Normalizer/ObjectNormalizer.php b/src/Normalizer/ObjectNormalizer.php
index e5558c4..b7f0b87 100644
--- a/src/Normalizer/ObjectNormalizer.php
+++ b/src/Normalizer/ObjectNormalizer.php
@@ -15,7 +15,7 @@
 use function is_array;
 
 #[Attribute(Attribute::TARGET_PROPERTY | Attribute::TARGET_CLASS)]
-final class ObjectNormalizer implements ContextAwareNormalizer, TypeAwareNormalizer, HydratorAwareNormalizer
+final class ObjectNormalizer implements Normalizer, TypeAwareNormalizer, HydratorAwareNormalizer
 {
     private Hydrator|null $hydrator = null;
 
@@ -30,7 +30,7 @@ public function __construct(
      *
      * @return array<string, mixed>|null
      */
-    public function normalize(mixed $value, array $context = []): array|null
+    public function normalize(mixed $value, array $context): array|null
     {
         if (!$this->hydrator) {
             throw new MissingHydrator();
@@ -50,7 +50,7 @@ public function normalize(mixed $value, array $context = []): array|null
     }
 
     /** @param array<string, mixed> $context */
-    public function denormalize(mixed $value, array $context = []): object|null
+    public function denormalize(mixed $value, array $context): object|null
     {
         if (!$this->hydrator) {
             throw new MissingHydrator();
diff --git a/tests/Benchmark/Fixture/ProfileIdNormalizer.php b/tests/Benchmark/Fixture/ProfileIdNormalizer.php
index f867ebf..caef85a 100644
--- a/tests/Benchmark/Fixture/ProfileIdNormalizer.php
+++ b/tests/Benchmark/Fixture/ProfileIdNormalizer.php
@@ -13,7 +13,8 @@
 #[Attribute(Attribute::TARGET_PROPERTY)]
 final class ProfileIdNormalizer implements Normalizer
 {
-    public function normalize(mixed $value): string
+    /** @param array<string, mixed> $context */
+    public function normalize(mixed $value, array $context): string
     {
         if (!$value instanceof ProfileId) {
             throw new InvalidArgumentException();
@@ -22,7 +23,8 @@ public function normalize(mixed $value): string
         return $value->toString();
     }
 
-    public function denormalize(mixed $value): ProfileId|null
+    /** @param array<string, mixed> $context */
+    public function denormalize(mixed $value, array $context): ProfileId|null
     {
         if ($value === null) {
             return null;
diff --git a/tests/Unit/Fixture/EmailNormalizer.php b/tests/Unit/Fixture/EmailNormalizer.php
index 541eaf0..9936223 100644
--- a/tests/Unit/Fixture/EmailNormalizer.php
+++ b/tests/Unit/Fixture/EmailNormalizer.php
@@ -14,7 +14,8 @@
 #[Attribute(Attribute::TARGET_PROPERTY)]
 final class EmailNormalizer implements Normalizer
 {
-    public function normalize(mixed $value): string
+    /** @param array<string, mixed> $context */
+    public function normalize(mixed $value, array $context): string
     {
         if (!$value instanceof Email) {
             throw new InvalidArgumentException();
@@ -23,7 +24,8 @@ public function normalize(mixed $value): string
         return $value->toString();
     }
 
-    public function denormalize(mixed $value): Email|null
+    /** @param array<string, mixed> $context */
+    public function denormalize(mixed $value, array $context): Email|null
     {
         if ($value === null) {
             return null;
diff --git a/tests/Unit/Fixture/IdNormalizer.php b/tests/Unit/Fixture/IdNormalizer.php
index a01f136..eb4344d 100644
--- a/tests/Unit/Fixture/IdNormalizer.php
+++ b/tests/Unit/Fixture/IdNormalizer.php
@@ -24,7 +24,8 @@ public function __construct(
     ) {
     }
 
-    public function normalize(mixed $value): string|null
+    /** @param array<string, mixed> $context */
+    public function normalize(mixed $value, array $context): string|null
     {
         if ($value === null) {
             return null;
@@ -39,7 +40,8 @@ public function normalize(mixed $value): string|null
         return $value->toString();
     }
 
-    public function denormalize(mixed $value): Id|null
+    /** @param array<string, mixed> $context */
+    public function denormalize(mixed $value, array $context): Id|null
     {
         if ($value === null) {
             return null;
diff --git a/tests/Unit/Normalizer/ArrayNormalizerTest.php b/tests/Unit/Normalizer/ArrayNormalizerTest.php
index 702a8de..420bdea 100644
--- a/tests/Unit/Normalizer/ArrayNormalizerTest.php
+++ b/tests/Unit/Normalizer/ArrayNormalizerTest.php
@@ -20,7 +20,7 @@ public function testNormalizeWithNull(): void
         $innerNormalizer = $this->createMock(Normalizer::class);
 
         $normalizer = new ArrayNormalizer($innerNormalizer);
-        $this->assertEquals(null, $normalizer->normalize(null));
+        $this->assertEquals(null, $normalizer->normalize(null, []));
     }
 
     public function testDenormalizeWithNull(): void
@@ -28,7 +28,7 @@ public function testDenormalizeWithNull(): void
         $innerNormalizer = $this->createMock(Normalizer::class);
 
         $normalizer = new ArrayNormalizer($innerNormalizer);
-        $this->assertEquals(null, $normalizer->denormalize(null));
+        $this->assertEquals(null, $normalizer->denormalize(null, []));
     }
 
     public function testNormalizeWithInvalidArgument(): void
@@ -39,7 +39,7 @@ public function testNormalizeWithInvalidArgument(): void
         $innerNormalizer = $this->createMock(Normalizer::class);
 
         $normalizer = new ArrayNormalizer($innerNormalizer);
-        $normalizer->normalize('foo');
+        $normalizer->normalize('foo', []);
     }
 
     public function testDenormalizeWithInvalidArgument(): void
@@ -50,43 +50,47 @@ public function testDenormalizeWithInvalidArgument(): void
         $innerNormalizer = $this->createMock(Normalizer::class);
 
         $normalizer = new ArrayNormalizer($innerNormalizer);
-        $normalizer->denormalize('foo');
+        $normalizer->denormalize('foo', []);
     }
 
     public function testNormalizeWithValue(): void
     {
         $innerNormalizer = new class implements Normalizer {
-            public function normalize(mixed $value): string
+            /** @param array<string, mixed> $context */
+            public function normalize(mixed $value, array $context): string
             {
                 return (string)$value;
             }
 
-            public function denormalize(mixed $value): int
+            /** @param array<string, mixed> $context */
+            public function denormalize(mixed $value, array $context): int
             {
                 return (int)$value;
             }
         };
 
         $normalizer = new ArrayNormalizer($innerNormalizer);
-        $this->assertEquals(['1', '2'], $normalizer->normalize([1, 2]));
+        $this->assertEquals(['1', '2'], $normalizer->normalize([1, 2], []));
     }
 
     public function testDenormalizeWithValue(): void
     {
         $innerNormalizer = new class implements Normalizer {
-            public function normalize(mixed $value): string
+            /** @param array<string, mixed> $context */
+            public function normalize(mixed $value, array $context): string
             {
                 return (string)$value;
             }
 
-            public function denormalize(mixed $value): int
+            /** @param array<string, mixed> $context */
+            public function denormalize(mixed $value, array $context): int
             {
                 return (int)$value;
             }
         };
 
         $normalizer = new ArrayNormalizer($innerNormalizer);
-        $this->assertEquals([1, 2], $normalizer->denormalize(['1', '2']));
+        $this->assertEquals([1, 2], $normalizer->denormalize(['1', '2'], []));
     }
 
     public function testPassHydrator(): void
diff --git a/tests/Unit/Normalizer/ArrayShapeNormalizerTest.php b/tests/Unit/Normalizer/ArrayShapeNormalizerTest.php
index 35baed3..6e12cc5 100644
--- a/tests/Unit/Normalizer/ArrayShapeNormalizerTest.php
+++ b/tests/Unit/Normalizer/ArrayShapeNormalizerTest.php
@@ -20,7 +20,7 @@ public function testNormalizeWithNull(): void
         $innerNormalizer = $this->createMock(Normalizer::class);
 
         $normalizer = new ArrayShapeNormalizer(['foo' => $innerNormalizer]);
-        $this->assertEquals(null, $normalizer->normalize(null));
+        $this->assertEquals(null, $normalizer->normalize(null, []));
     }
 
     public function testDenormalizeWithNull(): void
@@ -28,7 +28,7 @@ public function testDenormalizeWithNull(): void
         $innerNormalizer = $this->createMock(Normalizer::class);
 
         $normalizer = new ArrayShapeNormalizer(['foo' => $innerNormalizer]);
-        $this->assertEquals(null, $normalizer->denormalize(null));
+        $this->assertEquals(null, $normalizer->denormalize(null, []));
     }
 
     public function testNormalizeWithInvalidArgument(): void
@@ -39,7 +39,7 @@ public function testNormalizeWithInvalidArgument(): void
         $innerNormalizer = $this->createMock(Normalizer::class);
 
         $normalizer = new ArrayShapeNormalizer(['foo' => $innerNormalizer]);
-        $normalizer->normalize('foo');
+        $normalizer->normalize('foo', []);
     }
 
     public function testDenormalizeWithInvalidArgument(): void
@@ -50,43 +50,47 @@ public function testDenormalizeWithInvalidArgument(): void
         $innerNormalizer = $this->createMock(Normalizer::class);
 
         $normalizer = new ArrayShapeNormalizer(['foo' => $innerNormalizer]);
-        $normalizer->denormalize('foo');
+        $normalizer->denormalize('foo', []);
     }
 
     public function testNormalizeWithValue(): void
     {
         $innerNormalizer = new class implements Normalizer {
-            public function normalize(mixed $value): string
+            /** @param array<string, mixed> $context */
+            public function normalize(mixed $value, array $context): string
             {
                 return (string)$value;
             }
 
-            public function denormalize(mixed $value): int
+            /** @param array<string, mixed> $context */
+            public function denormalize(mixed $value, array $context): int
             {
                 return (int)$value;
             }
         };
 
         $normalizer = new ArrayShapeNormalizer(['foo' => $innerNormalizer]);
-        $this->assertEquals(['foo' => '1'], $normalizer->normalize(['foo' => 1]));
+        $this->assertEquals(['foo' => '1'], $normalizer->normalize(['foo' => 1], []));
     }
 
     public function testDenormalizeWithValue(): void
     {
         $innerNormalizer = new class implements Normalizer {
-            public function normalize(mixed $value): string
+            /** @param array<string, mixed> $context */
+            public function normalize(mixed $value, array $context): string
             {
                 return (string)$value;
             }
 
-            public function denormalize(mixed $value): int
+            /** @param array<string, mixed> $context */
+            public function denormalize(mixed $value, array $context): int
             {
                 return (int)$value;
             }
         };
 
         $normalizer = new ArrayShapeNormalizer(['foo' => $innerNormalizer]);
-        $this->assertEquals(['foo' => 1], $normalizer->denormalize(['foo' => '1']));
+        $this->assertEquals(['foo' => 1], $normalizer->denormalize(['foo' => '1'], []));
     }
 
     public function testPassHydrator(): void
diff --git a/tests/Unit/Normalizer/DateTimeImmutableNormalizerTest.php b/tests/Unit/Normalizer/DateTimeImmutableNormalizerTest.php
index 28510f1..704e672 100644
--- a/tests/Unit/Normalizer/DateTimeImmutableNormalizerTest.php
+++ b/tests/Unit/Normalizer/DateTimeImmutableNormalizerTest.php
@@ -17,13 +17,13 @@ final class DateTimeImmutableNormalizerTest extends TestCase
     public function testNormalizeWithNull(): void
     {
         $normalizer = new DateTimeImmutableNormalizer();
-        $this->assertEquals(null, $normalizer->normalize(null));
+        $this->assertEquals(null, $normalizer->normalize(null, []));
     }
 
     public function testDenormalizeWithNull(): void
     {
         $normalizer = new DateTimeImmutableNormalizer();
-        $this->assertEquals(null, $normalizer->denormalize(null));
+        $this->assertEquals(null, $normalizer->denormalize(null, []));
     }
 
     public function testNormalizeWithInvalidArgument(): void
@@ -32,7 +32,7 @@ public function testNormalizeWithInvalidArgument(): void
         $this->expectExceptionCode(0);
 
         $normalizer = new DateTimeImmutableNormalizer();
-        $normalizer->normalize(123);
+        $normalizer->normalize(123, []);
     }
 
     public function testDenormalizeWithInvalidArgument(): void
@@ -41,30 +41,30 @@ public function testDenormalizeWithInvalidArgument(): void
         $this->expectExceptionCode(0);
 
         $normalizer = new DateTimeImmutableNormalizer();
-        $normalizer->denormalize(123);
+        $normalizer->denormalize(123, []);
     }
 
     public function testNormalizeWithValue(): void
     {
         $normalizer = new DateTimeImmutableNormalizer();
-        $this->assertEquals('2015-02-13T22:34:32+01:00', $normalizer->normalize(new DateTimeImmutable('2015-02-13 22:34:32+01:00')));
+        $this->assertEquals('2015-02-13T22:34:32+01:00', $normalizer->normalize(new DateTimeImmutable('2015-02-13 22:34:32+01:00'), []));
     }
 
     public function testNormalizeWithChangeFormat(): void
     {
         $normalizer = new DateTimeImmutableNormalizer(format: DateTime::RFC822);
-        $this->assertEquals('Fri, 13 Feb 15 22:34:32 +0100', $normalizer->normalize(new DateTimeImmutable('2015-02-13 22:34:32+01:00')));
+        $this->assertEquals('Fri, 13 Feb 15 22:34:32 +0100', $normalizer->normalize(new DateTimeImmutable('2015-02-13 22:34:32+01:00'), []));
     }
 
     public function testDenormalizeWithValue(): void
     {
         $normalizer = new DateTimeImmutableNormalizer();
-        $this->assertEquals(new DateTimeImmutable('2015-02-13 22:34:32+01:00'), $normalizer->denormalize('2015-02-13T22:34:32+01:00'));
+        $this->assertEquals(new DateTimeImmutable('2015-02-13 22:34:32+01:00'), $normalizer->denormalize('2015-02-13T22:34:32+01:00', []));
     }
 
     public function testDenormalizeWithChangeFormat(): void
     {
         $normalizer = new DateTimeImmutableNormalizer(format: DateTime::RFC822);
-        $this->assertEquals(new DateTimeImmutable('2015-02-13 22:34:32+01:00'), $normalizer->denormalize('Fri, 13 Feb 15 22:34:32 +0100'));
+        $this->assertEquals(new DateTimeImmutable('2015-02-13 22:34:32+01:00'), $normalizer->denormalize('Fri, 13 Feb 15 22:34:32 +0100', []));
     }
 }
diff --git a/tests/Unit/Normalizer/DateTimeNormalizerTest.php b/tests/Unit/Normalizer/DateTimeNormalizerTest.php
index 851382b..fd6e09e 100644
--- a/tests/Unit/Normalizer/DateTimeNormalizerTest.php
+++ b/tests/Unit/Normalizer/DateTimeNormalizerTest.php
@@ -16,13 +16,13 @@ final class DateTimeNormalizerTest extends TestCase
     public function testNormalizeWithNull(): void
     {
         $normalizer = new DateTimeNormalizer();
-        $this->assertEquals(null, $normalizer->normalize(null));
+        $this->assertEquals(null, $normalizer->normalize(null, []));
     }
 
     public function testDenormalizeWithNull(): void
     {
         $normalizer = new DateTimeNormalizer();
-        $this->assertEquals(null, $normalizer->denormalize(null));
+        $this->assertEquals(null, $normalizer->denormalize(null, []));
     }
 
     public function testNormalizeWithInvalidArgument(): void
@@ -31,7 +31,7 @@ public function testNormalizeWithInvalidArgument(): void
         $this->expectExceptionCode(0);
 
         $normalizer = new DateTimeNormalizer();
-        $normalizer->normalize(123);
+        $normalizer->normalize(123, []);
     }
 
     public function testDenormalizeWithInvalidArgument(): void
@@ -40,30 +40,30 @@ public function testDenormalizeWithInvalidArgument(): void
         $this->expectExceptionCode(0);
 
         $normalizer = new DateTimeNormalizer();
-        $normalizer->denormalize(123);
+        $normalizer->denormalize(123, []);
     }
 
     public function testNormalizeWithValue(): void
     {
         $normalizer = new DateTimeNormalizer();
-        $this->assertEquals('2015-02-13T22:34:32+01:00', $normalizer->normalize(new DateTime('2015-02-13 22:34:32+01:00')));
+        $this->assertEquals('2015-02-13T22:34:32+01:00', $normalizer->normalize(new DateTime('2015-02-13 22:34:32+01:00'), []));
     }
 
     public function testNormalizeWithChangeFormat(): void
     {
         $normalizer = new DateTimeNormalizer(format: DateTime::RFC822);
-        $this->assertEquals('Fri, 13 Feb 15 22:34:32 +0100', $normalizer->normalize(new DateTime('2015-02-13 22:34:32+01:00')));
+        $this->assertEquals('Fri, 13 Feb 15 22:34:32 +0100', $normalizer->normalize(new DateTime('2015-02-13 22:34:32+01:00'), []));
     }
 
     public function testDenormalizeWithValue(): void
     {
         $normalizer = new DateTimeNormalizer();
-        $this->assertEquals(new DateTime('2015-02-13 22:34:32+01:00'), $normalizer->denormalize('2015-02-13T22:34:32+01:00'));
+        $this->assertEquals(new DateTime('2015-02-13 22:34:32+01:00'), $normalizer->denormalize('2015-02-13T22:34:32+01:00', []));
     }
 
     public function testDenormalizeWithChangeFormat(): void
     {
         $normalizer = new DateTimeNormalizer(format: DateTime::RFC822);
-        $this->assertEquals(new DateTime('2015-02-13 22:34:32+01:00'), $normalizer->denormalize('Fri, 13 Feb 15 22:34:32 +0100'));
+        $this->assertEquals(new DateTime('2015-02-13 22:34:32+01:00'), $normalizer->denormalize('Fri, 13 Feb 15 22:34:32 +0100', []));
     }
 }
diff --git a/tests/Unit/Normalizer/DateTimeZoneNormalizerTest.php b/tests/Unit/Normalizer/DateTimeZoneNormalizerTest.php
index 2622863..68a88d5 100644
--- a/tests/Unit/Normalizer/DateTimeZoneNormalizerTest.php
+++ b/tests/Unit/Normalizer/DateTimeZoneNormalizerTest.php
@@ -16,13 +16,13 @@ final class DateTimeZoneNormalizerTest extends TestCase
     public function testNormalizeWithNull(): void
     {
         $normalizer = new DateTimeZoneNormalizer();
-        $this->assertEquals(null, $normalizer->normalize(null));
+        $this->assertEquals(null, $normalizer->normalize(null, []));
     }
 
     public function testDenormalizeWithNull(): void
     {
         $normalizer = new DateTimeZoneNormalizer();
-        $this->assertEquals(null, $normalizer->denormalize(null));
+        $this->assertEquals(null, $normalizer->denormalize(null, []));
     }
 
     public function testNormalizeWithInvalidArgument(): void
@@ -31,7 +31,7 @@ public function testNormalizeWithInvalidArgument(): void
         $this->expectExceptionCode(0);
 
         $normalizer = new DateTimeZoneNormalizer();
-        $normalizer->normalize(123);
+        $normalizer->normalize(123, []);
     }
 
     public function testDenormalizeWithInvalidArgument(): void
@@ -40,18 +40,18 @@ public function testDenormalizeWithInvalidArgument(): void
         $this->expectExceptionCode(0);
 
         $normalizer = new DateTimeZoneNormalizer();
-        $normalizer->denormalize(123);
+        $normalizer->denormalize(123, []);
     }
 
     public function testNormalizeWithValue(): void
     {
         $normalizer = new DateTimeZoneNormalizer();
-        $this->assertEquals('EDT', $normalizer->normalize(new DateTimeZone('EDT')));
+        $this->assertEquals('EDT', $normalizer->normalize(new DateTimeZone('EDT'), []));
     }
 
     public function testDenormalizeWithValue(): void
     {
         $normalizer = new DateTimeZoneNormalizer();
-        $this->assertEquals(new DateTimeZone('EDT'), $normalizer->denormalize('EDT'));
+        $this->assertEquals(new DateTimeZone('EDT'), $normalizer->denormalize('EDT', []));
     }
 }
diff --git a/tests/Unit/Normalizer/EnumNormalizerTest.php b/tests/Unit/Normalizer/EnumNormalizerTest.php
index 8f81b9a..e956b46 100644
--- a/tests/Unit/Normalizer/EnumNormalizerTest.php
+++ b/tests/Unit/Normalizer/EnumNormalizerTest.php
@@ -19,13 +19,13 @@ final class EnumNormalizerTest extends TestCase
     public function testNormalizeWithNull(): void
     {
         $normalizer = new EnumNormalizer(Status::class);
-        $this->assertEquals(null, $normalizer->normalize(null));
+        $this->assertEquals(null, $normalizer->normalize(null, []));
     }
 
     public function testDenormalizeWithNull(): void
     {
         $normalizer = new EnumNormalizer(Status::class);
-        $this->assertEquals(null, $normalizer->denormalize(null));
+        $this->assertEquals(null, $normalizer->denormalize(null, []));
     }
 
     public function testNormalizeWithInvalidArgument(): void
@@ -35,7 +35,7 @@ public function testNormalizeWithInvalidArgument(): void
         $this->expectExceptionMessage('type "Patchlevel\Hydrator\Tests\Unit\Fixture\Status|null" was expected but "string" was passed.');
 
         $normalizer = new EnumNormalizer(Status::class);
-        $normalizer->normalize('foo');
+        $normalizer->normalize('foo', []);
     }
 
     public function testDenormalizeWithInvalidArgument(): void
@@ -46,19 +46,19 @@ public function testDenormalizeWithInvalidArgument(): void
         $this->expectExceptionMessage('Patchlevel\Hydrator\Tests\Unit\Fixture\Status');
 
         $normalizer = new EnumNormalizer(Status::class);
-        $normalizer->denormalize('foo');
+        $normalizer->denormalize('foo', []);
     }
 
     public function testNormalizeWithValue(): void
     {
         $normalizer = new EnumNormalizer(Status::class);
-        $this->assertEquals('pending', $normalizer->normalize(Status::Pending));
+        $this->assertEquals('pending', $normalizer->normalize(Status::Pending, []));
     }
 
     public function testDenormalizeWithValue(): void
     {
         $normalizer = new EnumNormalizer(Status::class);
-        $this->assertEquals(Status::Pending, $normalizer->denormalize('pending'));
+        $this->assertEquals(Status::Pending, $normalizer->denormalize('pending', []));
     }
 
     public function testAutoDetect(): void
diff --git a/tests/Unit/Normalizer/ObjectNormalizerTest.php b/tests/Unit/Normalizer/ObjectNormalizerTest.php
index 3ff1327..b53f67e 100644
--- a/tests/Unit/Normalizer/ObjectNormalizerTest.php
+++ b/tests/Unit/Normalizer/ObjectNormalizerTest.php
@@ -28,7 +28,7 @@ public function testNormalizeMissingHydrator(): void
         $this->expectException(MissingHydrator::class);
 
         $normalizer = new ObjectNormalizer(ProfileCreated::class);
-        $this->assertEquals(null, $normalizer->normalize(null));
+        $this->assertEquals(null, $normalizer->normalize(null, []));
     }
 
     public function testDenormalizeMissingHydrator(): void
@@ -36,7 +36,7 @@ public function testDenormalizeMissingHydrator(): void
         $this->expectException(MissingHydrator::class);
 
         $normalizer = new ObjectNormalizer(ProfileCreated::class);
-        $this->assertEquals(null, $normalizer->denormalize(null));
+        $this->assertEquals(null, $normalizer->denormalize(null, []));
     }
 
     public function testNormalizeWithNull(): void
@@ -46,7 +46,7 @@ public function testNormalizeWithNull(): void
         $normalizer = new ObjectNormalizer(ProfileCreated::class);
         $normalizer->setHydrator($hydrator);
 
-        $this->assertEquals(null, $normalizer->normalize(null));
+        $this->assertEquals(null, $normalizer->normalize(null, []));
     }
 
     public function testDenormalizeWithNull(): void
@@ -56,7 +56,7 @@ public function testDenormalizeWithNull(): void
         $normalizer = new ObjectNormalizer(ProfileCreated::class);
         $normalizer->setHydrator($hydrator);
 
-        $this->assertEquals(null, $normalizer->denormalize(null));
+        $this->assertEquals(null, $normalizer->denormalize(null, []));
     }
 
     public function testNormalizeWithInvalidArgument(): void
@@ -69,7 +69,7 @@ public function testNormalizeWithInvalidArgument(): void
 
         $normalizer = new ObjectNormalizer(ProfileCreated::class);
         $normalizer->setHydrator($hydrator);
-        $normalizer->normalize('foo');
+        $normalizer->normalize('foo', []);
     }
 
     public function testDenormalizeWithInvalidArgument(): void
@@ -82,7 +82,7 @@ public function testDenormalizeWithInvalidArgument(): void
 
         $normalizer = new ObjectNormalizer(ProfileCreated::class);
         $normalizer->setHydrator($hydrator);
-        $normalizer->denormalize('foo');
+        $normalizer->denormalize('foo', []);
     }
 
     public function testNormalizeWithValue(): void
@@ -101,7 +101,7 @@ public function testNormalizeWithValue(): void
         $normalizer->setHydrator($hydrator);
 
         self::assertEquals(
-            $normalizer->normalize($event),
+            $normalizer->normalize($event, []),
             ['profileId' => '1', 'email' => 'info@patchlevel.de'],
         );
     }
@@ -126,7 +126,7 @@ public function testDenormalizeWithValue(): void
 
         $this->assertEquals(
             $expected,
-            $normalizer->denormalize(['profileId' => '1', 'email' => 'info@patchlevel.de']),
+            $normalizer->denormalize(['profileId' => '1', 'email' => 'info@patchlevel.de'], []),
         );
     }