diff --git a/baseline.xml b/baseline.xml
index 18881f70..84a23784 100644
--- a/baseline.xml
+++ b/baseline.xml
@@ -22,9 +22,9 @@
       <code><![CDATA[$rawData]]></code>
     </MixedArgument>
     <MixedAssignment>
-      <code><![CDATA[$data[$propertyMetadata->fieldName()]]]></code>
-      <code><![CDATA[$data[$propertyMetadata->fieldName()]]]></code>
-      <code><![CDATA[$data[$propertyMetadata->fieldName()]]]></code>
+      <code><![CDATA[$data[$propertyMetadata->fieldName]]]></code>
+      <code><![CDATA[$data[$propertyMetadata->fieldName]]]></code>
+      <code><![CDATA[$data[$propertyMetadata->fieldName]]]></code>
       <code><![CDATA[$rawData]]></code>
       <code><![CDATA[$rawData]]></code>
     </MixedAssignment>
diff --git a/src/Cryptography/SensitiveDataPayloadCryptographer.php b/src/Cryptography/SensitiveDataPayloadCryptographer.php
index ac48995f..b71b5c3c 100644
--- a/src/Cryptography/SensitiveDataPayloadCryptographer.php
+++ b/src/Cryptography/SensitiveDataPayloadCryptographer.php
@@ -36,7 +36,7 @@ public function __construct(
      */
     public function encrypt(ClassMetadata $metadata, array $data): array
     {
-        foreach ($metadata->properties() as $propertyMetadata) {
+        foreach ($metadata->properties as $propertyMetadata) {
             if (!$propertyMetadata->isSensitiveData()) {
                 continue;
             }
@@ -52,18 +52,18 @@ public function encrypt(ClassMetadata $metadata, array $data): array
 
             $targetFieldName = $this->useEncryptedFieldName
                 ? $propertyMetadata->encryptedFieldName()
-                : $propertyMetadata->fieldName();
+                : $propertyMetadata->fieldName;
 
             $data[$targetFieldName] = $this->cipher->encrypt(
                 $cipherKey,
-                $data[$propertyMetadata->fieldName()],
+                $data[$propertyMetadata->fieldName],
             );
 
             if (!$this->useEncryptedFieldName) {
                 continue;
             }
 
-            unset($data[$propertyMetadata->fieldName()]);
+            unset($data[$propertyMetadata->fieldName]);
         }
 
         return $data;
@@ -76,7 +76,7 @@ public function encrypt(ClassMetadata $metadata, array $data): array
      */
     public function decrypt(ClassMetadata $metadata, array $data): array
     {
-        foreach ($metadata->properties() as $propertyMetadata) {
+        foreach ($metadata->properties as $propertyMetadata) {
             if (!$propertyMetadata->isSensitiveData()) {
                 continue;
             }
@@ -93,23 +93,23 @@ public function decrypt(ClassMetadata $metadata, array $data): array
                 $rawData = $data[$propertyMetadata->encryptedFieldName()];
                 unset($data[$propertyMetadata->encryptedFieldName()]);
             } elseif (!$this->useEncryptedFieldName || $this->fallbackToFieldName) {
-                $rawData = $data[$propertyMetadata->fieldName()];
+                $rawData = $data[$propertyMetadata->fieldName];
             } else {
                 continue;
             }
 
             if (!$cipherKey) {
-                $data[$propertyMetadata->fieldName()] = $this->fallback($propertyMetadata, $subjectId, $rawData);
+                $data[$propertyMetadata->fieldName] = $this->fallback($propertyMetadata, $subjectId, $rawData);
                 continue;
             }
 
             try {
-                $data[$propertyMetadata->fieldName()] = $this->cipher->decrypt(
+                $data[$propertyMetadata->fieldName] = $this->cipher->decrypt(
                     $cipherKey,
                     $rawData,
                 );
             } catch (DecryptionFailed) {
-                $data[$propertyMetadata->fieldName()] = $this->fallback($propertyMetadata, $subjectId, $rawData);
+                $data[$propertyMetadata->fieldName] = $this->fallback($propertyMetadata, $subjectId, $rawData);
             }
         }
 
@@ -123,7 +123,7 @@ private function subjectId(PropertyMetadata $propertyMetadata, ClassMetadata $me
             throw new NotSensitiveData($metadata->className(), $propertyMetadata->propertyName());
         }
 
-        $sensitiveDataSubjectIdName = $propertyMetadata->sensitiveDataSubjectIdName();
+        $sensitiveDataSubjectIdName = $propertyMetadata->sensitiveDataSubjectIdName;
 
         if (!$metadata->hasSubjectIdIdentifier($sensitiveDataSubjectIdName)) {
             throw new MissingSubjectId($metadata->className(), $propertyMetadata->propertyName());
@@ -153,7 +153,7 @@ private function fallback(PropertyMetadata $propertyMetadata, string $subjectId,
         $callback = $propertyMetadata->sensitiveDataFallbackCallable();
 
         if (!$callback) {
-            return $propertyMetadata->sensitiveDataFallback();
+            return $propertyMetadata->sensitiveDataFallback;
         }
 
         return $callback($subjectId, $rawData);
diff --git a/src/Metadata/AttributeMetadataFactory.php b/src/Metadata/AttributeMetadataFactory.php
index d6533f14..b4a2eb69 100644
--- a/src/Metadata/AttributeMetadataFactory.php
+++ b/src/Metadata/AttributeMetadataFactory.php
@@ -256,28 +256,28 @@ private function mergeMetadata(ClassMetadata $parent, ClassMetadata $child): Cla
     {
         $properties = [];
 
-        foreach ($parent->properties() as $property) {
-            $properties[$property->fieldName()] = $property;
+        foreach ($parent->properties as $property) {
+            $properties[$property->fieldName] = $property;
         }
 
-        foreach ($child->properties() as $property) {
-            if (array_key_exists($property->fieldName(), $properties)) {
+        foreach ($child->properties as $property) {
+            if (array_key_exists($property->fieldName, $properties)) {
                 throw DuplicatedFieldNameInMetadata::byInheritance(
-                    $property->fieldName(),
+                    $property->fieldName,
                     $parent->className(),
                     $child->className(),
                 );
             }
 
-            $properties[$property->fieldName()] = $property;
+            $properties[$property->fieldName] = $property;
         }
 
         $mergedClassMetadata = new ClassMetadata(
-            $parent->reflection(),
+            $parent->reflection,
             array_values($properties),
-            array_merge($parent->postHydrateCallbacks(), $child->postHydrateCallbacks()),
-            array_merge($parent->preExtractCallbacks(), $child->preExtractCallbacks()),
-            $child->lazy() ?? $parent->lazy(),
+            array_merge($parent->postHydrateCallbacks, $child->postHydrateCallbacks),
+            array_merge($parent->preExtractCallbacks, $child->preExtractCallbacks),
+            $child->lazy ?? $parent->lazy,
         );
 
         $this->validate($mergedClassMetadata);
@@ -314,12 +314,12 @@ private function validate(ClassMetadata $metadata): void
     {
         $subjectIds = [];
 
-        foreach ($metadata->properties() as $property) {
+        foreach ($metadata->properties as $property) {
             if ($property->isSensitiveData() && $property->isSubjectId()) {
                 throw new SubjectIdAndSensitiveDataConflict($metadata->className(), $property->propertyName());
             }
 
-            if ($property->isSensitiveData() && !$metadata->hasSubjectIdIdentifier($property->sensitiveDataSubjectIdName())) {
+            if ($property->isSensitiveData() && !$metadata->hasSubjectIdIdentifier($property->sensitiveDataSubjectIdName)) {
                 throw new MissingDataSubjectId($metadata->className());
             }
 
@@ -327,7 +327,7 @@ private function validate(ClassMetadata $metadata): void
                 continue;
             }
 
-            $subjectIdIdentifier = $property->subjectIdName();
+            $subjectIdIdentifier = $property->subjectIdName;
 
             if (array_key_exists($subjectIdIdentifier, $subjectIds)) {
                 throw new DuplicateSubjectIdIdentifier(
diff --git a/src/Metadata/ClassMetadata.php b/src/Metadata/ClassMetadata.php
index 405c8e90..e04d2a33 100644
--- a/src/Metadata/ClassMetadata.php
+++ b/src/Metadata/ClassMetadata.php
@@ -26,53 +26,24 @@ final class ClassMetadata
      * @param list<CallbackMetadata> $preExtractCallbacks
      */
     public function __construct(
-        private readonly ReflectionClass $reflection,
-        private readonly array $properties = [],
-        private readonly array $postHydrateCallbacks = [],
-        private readonly array $preExtractCallbacks = [],
-        private readonly bool|null $lazy = null,
+        public readonly ReflectionClass $reflection,
+        public readonly array $properties = [],
+        public readonly array $postHydrateCallbacks = [],
+        public readonly array $preExtractCallbacks = [],
+        public readonly bool|null $lazy = null,
     ) {
     }
 
-    /** @return ReflectionClass<T> */
-    public function reflection(): ReflectionClass
-    {
-        return $this->reflection;
-    }
-
     /** @return class-string<T> */
     public function className(): string
     {
         return $this->reflection->getName();
     }
 
-    /** @return list<PropertyMetadata> */
-    public function properties(): array
-    {
-        return $this->properties;
-    }
-
-    /** @return list<CallbackMetadata> */
-    public function postHydrateCallbacks(): array
-    {
-        return $this->postHydrateCallbacks;
-    }
-
-    /** @return list<CallbackMetadata> */
-    public function preExtractCallbacks(): array
-    {
-        return $this->preExtractCallbacks;
-    }
-
-    public function lazy(): bool|null
-    {
-        return $this->lazy;
-    }
-
     public function propertyForField(string $name): PropertyMetadata
     {
         foreach ($this->properties as $property) {
-            if ($property->fieldName() === $name) {
+            if ($property->fieldName === $name) {
                 return $property;
             }
         }
@@ -83,7 +54,7 @@ public function propertyForField(string $name): PropertyMetadata
     public function hasSubjectIdIdentifier(string $subjectIdIdentifier): bool
     {
         foreach ($this->properties as $property) {
-            if ($property->subjectIdName() === $subjectIdIdentifier) {
+            if ($property->subjectIdName === $subjectIdIdentifier) {
                 return true;
             }
         }
@@ -94,8 +65,8 @@ public function hasSubjectIdIdentifier(string $subjectIdIdentifier): bool
     public function getSubjectIdFieldName(string $subjectIdIdentifier): string
     {
         foreach ($this->properties as $property) {
-            if ($property->subjectIdName() === $subjectIdIdentifier) {
-                return $property->fieldName();
+            if ($property->subjectIdName === $subjectIdIdentifier) {
+                return $property->fieldName;
             }
         }
 
diff --git a/src/Metadata/PropertyMetadata.php b/src/Metadata/PropertyMetadata.php
index 5f4c0716..1b7e5ead 100644
--- a/src/Metadata/PropertyMetadata.php
+++ b/src/Metadata/PropertyMetadata.php
@@ -28,44 +28,29 @@ final class PropertyMetadata
 
     /** @param (callable(string, mixed):mixed)|null $sensitiveDataFallbackCallable */
     public function __construct(
-        private readonly ReflectionProperty $reflection,
-        private readonly string $fieldName,
-        private readonly Normalizer|null $normalizer = null,
-        private readonly string|null $subjectIdName = null,
-        private readonly string|null $sensitiveDataSubjectIdName = null,
-        private readonly mixed $sensitiveDataFallback = null,
-        private readonly mixed $sensitiveDataFallbackCallable = null,
+        public readonly ReflectionProperty $reflection,
+        public readonly string $fieldName,
+        public readonly Normalizer|null $normalizer = null,
+        public readonly string|null $subjectIdName = null,
+        public readonly string|null $sensitiveDataSubjectIdName = null,
+        public readonly mixed $sensitiveDataFallback = null,
+        public readonly mixed $sensitiveDataFallbackCallable = null,
     ) {
         if (str_starts_with($fieldName, self::ENCRYPTED_PREFIX)) {
             throw new InvalidArgumentException('fieldName must not start with !');
         }
     }
 
-    public function reflection(): ReflectionProperty
-    {
-        return $this->reflection;
-    }
-
     public function propertyName(): string
     {
         return $this->reflection->getName();
     }
 
-    public function fieldName(): string
-    {
-        return $this->fieldName;
-    }
-
     public function encryptedFieldName(): string
     {
         return self::ENCRYPTED_PREFIX . $this->fieldName;
     }
 
-    public function normalizer(): Normalizer|null
-    {
-        return $this->normalizer;
-    }
-
     public function setValue(object $object, mixed $value): void
     {
         $this->reflection->setValue($object, $value);
@@ -76,28 +61,18 @@ public function getValue(object $object): mixed
         return $this->reflection->getValue($object);
     }
 
-    /** @phpstan-assert-if-true !null $this->sensitiveDataSubjectIdName() */
+    /** @phpstan-assert-if-true !null $this->sensitiveDataSubjectIdName */
     public function isSensitiveData(): bool
     {
         return $this->sensitiveDataSubjectIdName !== null;
     }
 
-    /** @phpstan-assert-if-true !null $this->subjectIdName() */
+    /** @phpstan-assert-if-true !null $this->subjectIdName */
     public function isSubjectId(): bool
     {
         return $this->subjectIdName !== null;
     }
 
-    public function subjectIdName(): string|null
-    {
-        return $this->subjectIdName;
-    }
-
-    public function sensitiveDataFallback(): mixed
-    {
-        return $this->sensitiveDataFallback;
-    }
-
     /** @return (Closure(string, mixed):mixed)|null */
     public function sensitiveDataFallbackCallable(): Closure|null
     {
@@ -108,11 +83,6 @@ public function sensitiveDataFallbackCallable(): Closure|null
         return null;
     }
 
-    public function sensitiveDataSubjectIdName(): string|null
-    {
-        return $this->sensitiveDataSubjectIdName;
-    }
-
     /** @return serialized */
     public function __serialize(): array
     {
diff --git a/src/MetadataHydrator.php b/src/MetadataHydrator.php
index e1a37a7f..961741e4 100644
--- a/src/MetadataHydrator.php
+++ b/src/MetadataHydrator.php
@@ -74,7 +74,7 @@ public function hydrate(string $class, array $data): object
             return $this->doHydrate($metadata, $data);
         }
 
-        $lazy = $metadata->lazy() ?? $this->defaultLazy;
+        $lazy = $metadata->lazy ?? $this->defaultLazy;
 
         if (!$lazy) {
             return $this->doHydrate($metadata, $data);
@@ -105,9 +105,9 @@ private function doHydrate(ClassMetadata $metadata, array $data): object
 
         $constructorParameters = null;
 
-        foreach ($metadata->properties() as $propertyMetadata) {
-            if (!array_key_exists($propertyMetadata->fieldName(), $data)) {
-                if (!$propertyMetadata->reflection()->isPromoted()) {
+        foreach ($metadata->properties as $propertyMetadata) {
+            if (!array_key_exists($propertyMetadata->fieldName, $data)) {
+                if (!$propertyMetadata->reflection->isPromoted()) {
                     continue;
                 }
 
@@ -127,9 +127,9 @@ private function doHydrate(ClassMetadata $metadata, array $data): object
             }
 
             /** @psalm-suppress MixedAssignment */
-            $value = $data[$propertyMetadata->fieldName()];
+            $value = $data[$propertyMetadata->fieldName];
 
-            $normalizer = $propertyMetadata->normalizer();
+            $normalizer = $propertyMetadata->normalizer;
 
             if ($normalizer) {
                 if ($normalizer instanceof HydratorAwareNormalizer) {
@@ -160,7 +160,7 @@ private function doHydrate(ClassMetadata $metadata, array $data): object
             }
         }
 
-        foreach ($metadata->postHydrateCallbacks() as $callback) {
+        foreach ($metadata->postHydrateCallbacks as $callback) {
             $callback->invoke($object);
         }
 
@@ -184,17 +184,17 @@ public function extract(object $object): array
         try {
             $metadata = $this->metadataFactory->metadata($object::class);
 
-            foreach ($metadata->preExtractCallbacks() as $callback) {
+            foreach ($metadata->preExtractCallbacks as $callback) {
                 $callback->invoke($object);
             }
 
             $data = [];
 
-            foreach ($metadata->properties() as $propertyMetadata) {
+            foreach ($metadata->properties as $propertyMetadata) {
                 /** @psalm-suppress MixedAssignment */
                 $value = $propertyMetadata->getValue($object);
 
-                $normalizer = $propertyMetadata->normalizer();
+                $normalizer = $propertyMetadata->normalizer;
 
                 if ($normalizer) {
                     if ($normalizer instanceof HydratorAwareNormalizer) {
@@ -221,7 +221,7 @@ public function extract(object $object): array
                 }
 
                 /** @psalm-suppress MixedAssignment */
-                $data[$propertyMetadata->fieldName()] = $value;
+                $data[$propertyMetadata->fieldName] = $value;
             }
 
             if ($this->eventDispatcher) {
@@ -237,7 +237,7 @@ public function extract(object $object): array
     /** @return array<string, ReflectionParameter> */
     private function promotedConstructorParametersWithDefaultValue(ClassMetadata $metadata): array
     {
-        $constructor = $metadata->reflection()->getConstructor();
+        $constructor = $metadata->reflection->getConstructor();
 
         if (!$constructor) {
             return [];
diff --git a/tests/Unit/Metadata/AttributeMetadataFactoryTest.php b/tests/Unit/Metadata/AttributeMetadataFactoryTest.php
index c4c3ccdf..bb133bbb 100644
--- a/tests/Unit/Metadata/AttributeMetadataFactoryTest.php
+++ b/tests/Unit/Metadata/AttributeMetadataFactoryTest.php
@@ -47,9 +47,9 @@ public function testEmptyObject(): void
         $metadataFactory = new AttributeMetadataFactory();
         $metadata = $metadataFactory->metadata($object::class);
 
-        self::assertCount(0, $metadata->properties());
-        self::assertCount(0, $metadata->preExtractCallbacks());
-        self::assertCount(0, $metadata->postHydrateCallbacks());
+        self::assertCount(0, $metadata->properties);
+        self::assertCount(0, $metadata->preExtractCallbacks);
+        self::assertCount(0, $metadata->postHydrateCallbacks);
     }
 
     public function testSameMetadata(): void
@@ -84,15 +84,15 @@ public function testWithProperties(): void
         $metadataFactory = new AttributeMetadataFactory();
         $metadata = $metadataFactory->metadata($object::class);
 
-        $properties = $metadata->properties();
+        $properties = $metadata->properties;
 
         self::assertCount(1, $properties);
 
         $propertyMetadata = $metadata->propertyForField('name');
 
         self::assertSame('name', $propertyMetadata->propertyName());
-        self::assertSame('name', $propertyMetadata->fieldName());
-        self::assertNull($propertyMetadata->normalizer());
+        self::assertSame('name', $propertyMetadata->fieldName);
+        self::assertNull($propertyMetadata->normalizer);
     }
 
     public function testUnknownClass(): void
@@ -112,7 +112,7 @@ public function testSkipStaticProperties(): void
         $metadataFactory = new AttributeMetadataFactory();
         $metadata = $metadataFactory->metadata($object::class);
 
-        $properties = $metadata->properties();
+        $properties = $metadata->properties;
 
         self::assertCount(0, $properties);
     }
@@ -129,15 +129,15 @@ public function __construct(
         $metadataFactory = new AttributeMetadataFactory();
         $metadata = $metadataFactory->metadata($object::class);
 
-        $properties = $metadata->properties();
+        $properties = $metadata->properties;
 
         self::assertCount(1, $properties);
 
         $propertyMetadata = $metadata->propertyForField('name');
 
         self::assertSame('name', $propertyMetadata->propertyName());
-        self::assertSame('name', $propertyMetadata->fieldName());
-        self::assertNull($propertyMetadata->normalizer());
+        self::assertSame('name', $propertyMetadata->fieldName);
+        self::assertNull($propertyMetadata->normalizer);
     }
 
     public function testNormalizedName(): void
@@ -153,15 +153,15 @@ public function __construct(
         $metadataFactory = new AttributeMetadataFactory();
         $metadata = $metadataFactory->metadata($object::class);
 
-        $properties = $metadata->properties();
+        $properties = $metadata->properties;
 
         self::assertCount(1, $properties);
 
         $propertyMetadata = $metadata->propertyForField('username');
 
         self::assertSame('name', $propertyMetadata->propertyName());
-        self::assertSame('username', $propertyMetadata->fieldName());
-        self::assertNull($propertyMetadata->normalizer());
+        self::assertSame('username', $propertyMetadata->fieldName);
+        self::assertNull($propertyMetadata->normalizer);
     }
 
     public function testDefineNormalizer(): void
@@ -177,15 +177,15 @@ public function __construct(
         $metadataFactory = new AttributeMetadataFactory();
         $metadata = $metadataFactory->metadata($object::class);
 
-        $properties = $metadata->properties();
+        $properties = $metadata->properties;
 
         self::assertCount(1, $properties);
 
         $propertyMetadata = $metadata->propertyForField('email');
 
         self::assertSame('email', $propertyMetadata->propertyName());
-        self::assertSame('email', $propertyMetadata->fieldName());
-        self::assertInstanceOf(EmailNormalizer::class, $propertyMetadata->normalizer());
+        self::assertSame('email', $propertyMetadata->fieldName);
+        self::assertInstanceOf(EmailNormalizer::class, $propertyMetadata->normalizer);
     }
 
     public function testTypeAwareNormalizer(): void
@@ -201,16 +201,16 @@ public function __construct(
         $metadataFactory = new AttributeMetadataFactory();
         $metadata = $metadataFactory->metadata($object::class);
 
-        $properties = $metadata->properties();
+        $properties = $metadata->properties;
 
         self::assertCount(1, $properties);
 
         $propertyMetadata = $metadata->propertyForField('status');
 
         self::assertSame('status', $propertyMetadata->propertyName());
-        self::assertSame('status', $propertyMetadata->fieldName());
+        self::assertSame('status', $propertyMetadata->fieldName);
 
-        $normalizer = $propertyMetadata->normalizer();
+        $normalizer = $propertyMetadata->normalizer;
 
         self::assertInstanceOf(EnumNormalizer::class, $normalizer);
         self::assertSame(Status::class, $normalizer->getEnum());
@@ -228,13 +228,13 @@ public function __construct(
         $metadataFactory = new AttributeMetadataFactory();
         $metadata = $metadataFactory->metadata($object::class);
 
-        $properties = $metadata->properties();
+        $properties = $metadata->properties;
 
         self::assertCount(1, $properties);
 
         $propertyMetadata = $metadata->propertyForField('profileId');
 
-        self::assertEquals(new IdNormalizer(ProfileId::class), $propertyMetadata->normalizer());
+        self::assertEquals(new IdNormalizer(ProfileId::class), $propertyMetadata->normalizer);
     }
 
     public function testInferNormalizerWithGeneric(): void
@@ -242,10 +242,10 @@ public function testInferNormalizerWithGeneric(): void
         $metadataFactory = new AttributeMetadataFactory();
         $metadata = $metadataFactory->metadata(ProfileCreatedWithGeneric::class);
 
-        self::assertCount(2, $metadata->properties());
+        self::assertCount(2, $metadata->properties);
 
         $propertyMetadata = $metadata->propertyForField('email');
-        self::assertEquals(new ObjectNormalizer(Wrapper::class), $propertyMetadata->normalizer());
+        self::assertEquals(new ObjectNormalizer(Wrapper::class), $propertyMetadata->normalizer);
     }
 
     public function testInferNormalizerWithTemplate(): void
@@ -253,16 +253,16 @@ public function testInferNormalizerWithTemplate(): void
         $metadataFactory = new AttributeMetadataFactory();
         $metadata = $metadataFactory->metadata(Wrapper::class);
 
-        self::assertCount(3, $metadata->properties());
+        self::assertCount(3, $metadata->properties);
 
         $propertyMetadata = $metadata->propertyForField('value');
-        self::assertNull($propertyMetadata->normalizer());
+        self::assertNull($propertyMetadata->normalizer);
 
         $propertyMetadata = $metadata->propertyForField('object');
-        self::assertEquals(new ObjectNormalizer(Wrapper::class), $propertyMetadata->normalizer());
+        self::assertEquals(new ObjectNormalizer(Wrapper::class), $propertyMetadata->normalizer);
 
         $propertyMetadata = $metadata->propertyForField('scalar');
-        self::assertEquals(new ObjectNormalizer(Wrapper::class), $propertyMetadata->normalizer());
+        self::assertEquals(new ObjectNormalizer(Wrapper::class), $propertyMetadata->normalizer);
     }
 
     public function testExtends(): void
@@ -270,19 +270,19 @@ public function testExtends(): void
         $metadataFactory = new AttributeMetadataFactory();
         $metadata = $metadataFactory->metadata(ParentDto::class);
 
-        self::assertCount(2, $metadata->properties());
+        self::assertCount(2, $metadata->properties);
 
         $emailPropertyMetadata = $metadata->propertyForField('profileId');
 
         self::assertSame('profileId', $emailPropertyMetadata->propertyName());
-        self::assertSame('profileId', $emailPropertyMetadata->fieldName());
-        self::assertInstanceOf(IdNormalizer::class, $emailPropertyMetadata->normalizer());
+        self::assertSame('profileId', $emailPropertyMetadata->fieldName);
+        self::assertInstanceOf(IdNormalizer::class, $emailPropertyMetadata->normalizer);
 
         $emailPropertyMetadata = $metadata->propertyForField('email');
 
         self::assertSame('email', $emailPropertyMetadata->propertyName());
-        self::assertSame('email', $emailPropertyMetadata->fieldName());
-        self::assertInstanceOf(EmailNormalizer::class, $emailPropertyMetadata->normalizer());
+        self::assertSame('email', $emailPropertyMetadata->fieldName);
+        self::assertInstanceOf(EmailNormalizer::class, $emailPropertyMetadata->normalizer);
     }
 
     public function testExtendsDuplicatedFieldName(): void
@@ -298,7 +298,7 @@ public function testBug70(): void
         $metadataFactory = new AttributeMetadataFactory();
         $metadata = $metadataFactory->metadata(DistributionCreated::class);
 
-        self::assertCount(1, $metadata->properties());
+        self::assertCount(1, $metadata->properties);
 
         $property = $metadata->propertyForField('recordedDate');
 
@@ -318,19 +318,19 @@ public function testExtendsWithIgnore(): void
         $metadataFactory = new AttributeMetadataFactory();
         $metadata = $metadataFactory->metadata(IgnoreParentDto::class);
 
-        self::assertCount(2, $metadata->properties());
+        self::assertCount(2, $metadata->properties);
 
         $emailPropertyMetadata = $metadata->propertyForField('profileId');
 
         self::assertSame('profileId', $emailPropertyMetadata->propertyName());
-        self::assertSame('profileId', $emailPropertyMetadata->fieldName());
-        self::assertInstanceOf(IdNormalizer::class, $emailPropertyMetadata->normalizer());
+        self::assertSame('profileId', $emailPropertyMetadata->fieldName);
+        self::assertInstanceOf(IdNormalizer::class, $emailPropertyMetadata->normalizer);
 
         $emailPropertyMetadata = $metadata->propertyForField('email');
 
         self::assertSame('email', $emailPropertyMetadata->propertyName());
-        self::assertSame('email', $emailPropertyMetadata->fieldName());
-        self::assertInstanceOf(EmailNormalizer::class, $emailPropertyMetadata->normalizer());
+        self::assertSame('email', $emailPropertyMetadata->fieldName);
+        self::assertInstanceOf(EmailNormalizer::class, $emailPropertyMetadata->normalizer);
     }
 
     public function testIgnore(): void
@@ -338,13 +338,13 @@ public function testIgnore(): void
         $metadataFactory = new AttributeMetadataFactory();
         $metadata = $metadataFactory->metadata(IgnoreDto::class);
 
-        self::assertCount(1, $metadata->properties());
+        self::assertCount(1, $metadata->properties);
 
         $emailPropertyMetadata = $metadata->propertyForField('profileId');
 
         self::assertSame('profileId', $emailPropertyMetadata->propertyName());
-        self::assertSame('profileId', $emailPropertyMetadata->fieldName());
-        self::assertInstanceOf(IdNormalizer::class, $emailPropertyMetadata->normalizer());
+        self::assertSame('profileId', $emailPropertyMetadata->fieldName);
+        self::assertInstanceOf(IdNormalizer::class, $emailPropertyMetadata->normalizer);
     }
 
     public function testIgnoreNotFoundProperty(): void
@@ -374,18 +374,18 @@ public function __construct(
         $metadataFactory = new AttributeMetadataFactory();
         $metadata = $metadataFactory->metadata($event::class);
 
-        self::assertCount(2, $metadata->properties());
+        self::assertCount(2, $metadata->properties);
 
         self::assertSame(false, $metadata->propertyForField('_id')->isSensitiveData());
         self::assertSame(true, $metadata->propertyForField('_id')->isSubjectId());
-        self::assertSame('default', $metadata->propertyForField('_id')->subjectIdName());
-        self::assertSame(null, $metadata->propertyForField('_id')->sensitiveDataFallback());
-        self::assertSame(null, $metadata->propertyForField('_id')->sensitiveDataSubjectIdName());
+        self::assertSame('default', $metadata->propertyForField('_id')->subjectIdName);
+        self::assertSame(null, $metadata->propertyForField('_id')->sensitiveDataFallback);
+        self::assertSame(null, $metadata->propertyForField('_id')->sensitiveDataSubjectIdName);
 
         self::assertSame(true, $metadata->propertyForField('_name')->isSensitiveData());
         self::assertSame(false, $metadata->propertyForField('_name')->isSubjectId());
-        self::assertSame('fallback', $metadata->propertyForField('_name')->sensitiveDataFallback());
-        self::assertSame('default', $metadata->propertyForField('_name')->sensitiveDataSubjectIdName());
+        self::assertSame('fallback', $metadata->propertyForField('_name')->sensitiveDataFallback);
+        self::assertSame('default', $metadata->propertyForField('_name')->sensitiveDataSubjectIdName);
     }
 
     public function testMissingDataSubjectId(): void
@@ -454,29 +454,29 @@ public function __construct(
         $metadataFactory = new AttributeMetadataFactory();
         $metadata = $metadataFactory->metadata($event::class);
 
-        self::assertCount(4, $metadata->properties());
+        self::assertCount(4, $metadata->properties);
 
         $fooIdProperty = $metadata->propertyForField('_fooId');
         self::assertFalse($fooIdProperty->isSensitiveData());
-        self::assertSame(null, $fooIdProperty->sensitiveDataFallback());
+        self::assertSame(null, $fooIdProperty->sensitiveDataFallback);
         self::assertTrue($fooIdProperty->isSubjectId());
-        self::assertSame('foo', $fooIdProperty->subjectIdName());
+        self::assertSame('foo', $fooIdProperty->subjectIdName);
 
         $fooNameProperty = $metadata->propertyForField('_fooName');
         self::assertSame(true, $fooNameProperty->isSensitiveData());
-        self::assertSame('fallback', $fooNameProperty->sensitiveDataFallback());
-        self::assertSame('foo', $fooNameProperty->sensitiveDataSubjectIdName());
+        self::assertSame('fallback', $fooNameProperty->sensitiveDataFallback);
+        self::assertSame('foo', $fooNameProperty->sensitiveDataSubjectIdName);
 
         $barIdProperty = $metadata->propertyForField('_barId');
         self::assertFalse($barIdProperty->isSensitiveData());
-        self::assertSame(null, $barIdProperty->sensitiveDataFallback());
+        self::assertSame(null, $barIdProperty->sensitiveDataFallback);
         self::assertTrue($barIdProperty->isSubjectId());
-        self::assertSame('bar', $barIdProperty->subjectIdName());
+        self::assertSame('bar', $barIdProperty->subjectIdName);
 
         $barNameProperty = $metadata->propertyForField('_barName');
         self::assertSame(true, $barNameProperty->isSensitiveData());
-        self::assertSame('fallback', $barNameProperty->sensitiveDataFallback());
-        self::assertSame('bar', $barNameProperty->sensitiveDataSubjectIdName());
+        self::assertSame('fallback', $barNameProperty->sensitiveDataFallback);
+        self::assertSame('bar', $barNameProperty->sensitiveDataSubjectIdName);
     }
 
     public function testDuplicateSubjectIdIdentifiers(): void
@@ -511,23 +511,23 @@ public function testExtendsWithSensitiveData(): void
         $metadataFactory = new AttributeMetadataFactory();
         $metadata = $metadataFactory->metadata(ParentWithSensitiveDataDto::class);
 
-        self::assertCount(2, $metadata->properties());
+        self::assertCount(2, $metadata->properties);
 
         $idPropertyMetadata = $metadata->propertyForField('profileId');
 
         self::assertSame('profileId', $idPropertyMetadata->propertyName());
-        self::assertSame('profileId', $idPropertyMetadata->fieldName());
+        self::assertSame('profileId', $idPropertyMetadata->fieldName);
         self::assertTrue($idPropertyMetadata->isSubjectId());
         self::assertFalse($idPropertyMetadata->isSensitiveData());
-        self::assertInstanceOf(IdNormalizer::class, $idPropertyMetadata->normalizer());
+        self::assertInstanceOf(IdNormalizer::class, $idPropertyMetadata->normalizer);
 
         $emailPropertyMetadata = $metadata->propertyForField('email');
 
         self::assertSame('email', $emailPropertyMetadata->propertyName());
-        self::assertSame('email', $emailPropertyMetadata->fieldName());
+        self::assertSame('email', $emailPropertyMetadata->fieldName);
         self::assertFalse($emailPropertyMetadata->isSubjectId());
         self::assertTrue($emailPropertyMetadata->isSensitiveData());
-        self::assertInstanceOf(EmailNormalizer::class, $emailPropertyMetadata->normalizer());
+        self::assertInstanceOf(EmailNormalizer::class, $emailPropertyMetadata->normalizer);
     }
 
     public function testExtendsWithSensitiveDataWithName(): void
@@ -535,25 +535,25 @@ public function testExtendsWithSensitiveDataWithName(): void
         $metadataFactory = new AttributeMetadataFactory();
         $metadata = $metadataFactory->metadata(ParentWithSensitiveDataWithIdentifierDto::class);
 
-        self::assertCount(2, $metadata->properties());
+        self::assertCount(2, $metadata->properties);
 
         $idPropertyMetadata = $metadata->propertyForField('profileId');
 
         self::assertSame('profileId', $idPropertyMetadata->propertyName());
-        self::assertSame('profileId', $idPropertyMetadata->fieldName());
+        self::assertSame('profileId', $idPropertyMetadata->fieldName);
         self::assertTrue($idPropertyMetadata->isSubjectId());
         self::assertFalse($idPropertyMetadata->isSensitiveData());
-        self::assertInstanceOf(IdNormalizer::class, $idPropertyMetadata->normalizer());
+        self::assertInstanceOf(IdNormalizer::class, $idPropertyMetadata->normalizer);
 
         $emailPropertyMetadata = $metadata->propertyForField('email');
 
         self::assertSame('email', $emailPropertyMetadata->propertyName());
-        self::assertSame('email', $emailPropertyMetadata->fieldName());
+        self::assertSame('email', $emailPropertyMetadata->fieldName);
         self::assertFalse($emailPropertyMetadata->isSubjectId());
         self::assertTrue($emailPropertyMetadata->isSensitiveData());
-        self::assertNull($emailPropertyMetadata->sensitiveDataFallback());
-        self::assertSame('profile', $emailPropertyMetadata->sensitiveDataSubjectIdName());
-        self::assertInstanceOf(EmailNormalizer::class, $emailPropertyMetadata->normalizer());
+        self::assertNull($emailPropertyMetadata->sensitiveDataFallback);
+        self::assertSame('profile', $emailPropertyMetadata->sensitiveDataSubjectIdName);
+        self::assertInstanceOf(EmailNormalizer::class, $emailPropertyMetadata->normalizer);
     }
 
     public function testHooks(): void
@@ -573,12 +573,12 @@ private function postHydrate(): void
         $metadataFactory = new AttributeMetadataFactory();
         $metadata = $metadataFactory->metadata($object::class);
 
-        $preExtract = $metadata->preExtractCallbacks();
+        $preExtract = $metadata->preExtractCallbacks;
 
         self::assertCount(1, $preExtract);
         self::assertSame('preExtract', $preExtract[0]->methodName());
 
-        $postHydrate = $metadata->postHydrateCallbacks();
+        $postHydrate = $metadata->postHydrateCallbacks;
 
         self::assertCount(1, $postHydrate);
         self::assertSame('postHydrate', $postHydrate[0]->methodName());
@@ -601,8 +601,8 @@ private static function postHydrate(): void
         $metadataFactory = new AttributeMetadataFactory();
         $metadata = $metadataFactory->metadata($object::class);
 
-        self::assertCount(0, $metadata->preExtractCallbacks());
-        self::assertCount(0, $metadata->postHydrateCallbacks());
+        self::assertCount(0, $metadata->preExtractCallbacks);
+        self::assertCount(0, $metadata->postHydrateCallbacks);
     }
 
     public function testNoLazy(): void
@@ -613,7 +613,7 @@ public function testNoLazy(): void
         $metadataFactory = new AttributeMetadataFactory();
         $metadata = $metadataFactory->metadata($object::class);
 
-        self::assertNull($metadata->lazy());
+        self::assertNull($metadata->lazy);
     }
 
     public function testLazy(): void
@@ -625,6 +625,6 @@ class {
         $metadataFactory = new AttributeMetadataFactory();
         $metadata = $metadataFactory->metadata($object::class);
 
-        self::assertTrue($metadata->lazy());
+        self::assertTrue($metadata->lazy);
     }
 }