diff --git a/composer.json b/composer.json
index c3a4c07..fc8ab83 100644
--- a/composer.json
+++ b/composer.json
@@ -34,7 +34,7 @@
         "php-standard-library/str": "^6.1",
         "php-standard-library/type": "^6.1",
         "php-standard-library/vec": "^6.1",
-        "veewee/reflecta": "~0.16",
+        "veewee/reflecta": "^1.0.0",
         "veewee/xml": "^4.10",
         "php-soap/engine": "^2.20",
         "php-soap/wsdl": "^1.19",
diff --git a/src/Encoder/AnyElementEncoder.php b/src/Encoder/AnyElementEncoder.php
index 0b01507..7801d55 100644
--- a/src/Encoder/AnyElementEncoder.php
+++ b/src/Encoder/AnyElementEncoder.php
@@ -19,11 +19,11 @@
 use function Psl\Type\vec;
 
 /**
- * @implements XmlEncoder<array|string|null, string>
+ * @implements XmlEncoder<array|string|null, array<array-key, string>|string|null, string, ElementList|string>
  *
  * @psalm-import-type LookupArray from DocumentToLookupArrayReader
  *
- * @template-implements Feature\ProvidesObjectDecoderLens<LookupArray, ElementList>
+ * @template-implements Feature\ProvidesObjectDecoderLens<LookupArray, LookupArray, ElementList, ElementList>
  */
 final class AnyElementEncoder implements Feature\ListAware, Feature\OptionalAware, Feature\ProvidesObjectDecoderLens, XmlEncoder
 {
@@ -32,7 +32,7 @@ final class AnyElementEncoder implements Feature\ListAware, Feature\OptionalAwar
      * It will contain all the XML tags available in the object that is surrounding the 'any' property.
      * Properties that are already known by the object, will be omitted.
      *
-     * @return Lens<LookupArray, ElementList>
+     * @return Lens<LookupArray, LookupArray, ElementList, ElementList>
      */
     public static function createObjectDecoderLens(Type $parentType, Property $currentProperty): Lens
     {
@@ -51,7 +51,7 @@ public static function createObjectDecoderLens(Type $parentType, Property $curre
          */
         $omit = static fn (array $data): array => diff_by_key($data, array_flip($omittedKeys));
 
-        /** @var Lens<LookupArray, ElementList> */
+        /** @var Lens<LookupArray, LookupArray, ElementList, ElementList> */
         return Lens::readonly(
             /**
              * @psalm-suppress MixedArgumentTypeCoercion - Psalm gets confused about the result of omit.
@@ -62,7 +62,7 @@ public static function createObjectDecoderLens(Type $parentType, Property $curre
     }
 
     /**
-     * @return Iso<array|string|null, string>
+     * @return Iso<array|string|null, array<array-key, string>|string|null, string, ElementList|string>
      */
     public function iso(Context $context): Iso
     {
diff --git a/src/Encoder/ElementEncoder.php b/src/Encoder/ElementEncoder.php
index 75e79f4..048f06d 100644
--- a/src/Encoder/ElementEncoder.php
+++ b/src/Encoder/ElementEncoder.php
@@ -10,12 +10,12 @@
 use VeeWee\Reflecta\Iso\Iso;
 
 /**
- * @implements XmlEncoder<mixed, string>
+ * @implements XmlEncoder<mixed, mixed, non-empty-string, Element|non-empty-string>
  */
 final class ElementEncoder implements Feature\ElementAware, XmlEncoder
 {
     /**
-     * @param XmlEncoder<mixed, string> $typeEncoder
+     * @param XmlEncoder<mixed, mixed, string, string> $typeEncoder
      */
     public function __construct(
         private readonly XmlEncoder $typeEncoder
@@ -23,7 +23,7 @@ public function __construct(
     }
 
     /**
-     * @return Iso<mixed, string>
+     * @return Iso<mixed, mixed, non-empty-string, Element|non-empty-string>
      */
     public function iso(Context $context): Iso
     {
diff --git a/src/Encoder/EncoderDetector.php b/src/Encoder/EncoderDetector.php
index 3fbc27a..c605408 100644
--- a/src/Encoder/EncoderDetector.php
+++ b/src/Encoder/EncoderDetector.php
@@ -4,6 +4,8 @@
 namespace Soap\Encoding\Encoder;
 
 use Soap\Encoding\Cache\ScopedCache;
+use Soap\Encoding\Xml\Node\Element;
+use Soap\Encoding\Xml\Node\ElementList;
 use Soap\Engine\Metadata\Model\XsdType;
 use stdClass;
 
@@ -18,7 +20,7 @@ public static function default(): self
     }
 
     /**
-     * @return ScopedCache<XsdType, XmlEncoder<mixed, string>>
+     * @return ScopedCache<XsdType, XmlEncoder<mixed, mixed, string|null, Element|ElementList|string|null>>
      *
      * @psalm-suppress LessSpecificReturnStatement, MoreSpecificReturnType, MixedReturnStatement
      */
@@ -30,9 +32,7 @@ private static function cache(): ScopedCache
     }
 
     /**
-     * @return XmlEncoder<mixed, string>
-     *
-     * @psalm-suppress InvalidArgument, InvalidReturnType, PossiblyInvalidArgument, InvalidReturnStatement - The simple type detector could return string|null, but should not be an issue here.
+     * @return XmlEncoder<mixed, mixed, string|null, Element|ElementList|string|null>
      */
     public function __invoke(Context $context): XmlEncoder
     {
@@ -44,9 +44,7 @@ public function __invoke(Context $context): XmlEncoder
     }
 
     /**
-     * @return XmlEncoder<mixed, string>
-     *
-     * @psalm-suppress PossiblyInvalidArgument - The simple type detector could return string|null, but should not be an issue here.
+     * @return XmlEncoder<mixed, mixed, string|null, Element|ElementList|string|null>
      */
     private function detect(Context $context): XmlEncoder
     {
@@ -62,8 +60,8 @@ private function detect(Context $context): XmlEncoder
     }
 
     /**
-     * @param XmlEncoder<mixed, string> $encoder
-     * @return XmlEncoder<mixed, string>
+     * @param XmlEncoder<mixed, mixed, string|null, Element|ElementList|string|null> $encoder
+     * @return XmlEncoder<mixed, mixed, string|null, Element|ElementList|string|null>
      */
     private function enhanceEncoder(Context $context, XmlEncoder $encoder): XmlEncoder
     {
@@ -86,7 +84,7 @@ private function enhanceEncoder(Context $context, XmlEncoder $encoder): XmlEncod
     }
 
     /**
-     * @return XmlEncoder<mixed, string>
+     * @return XmlEncoder<mixed, mixed, string, Element|ElementList|string>
      */
     private function detectComplexTypeEncoder(XsdType $type, Context $context): XmlEncoder
     {
diff --git a/src/Encoder/ErrorHandlingEncoder.php b/src/Encoder/ErrorHandlingEncoder.php
index 9aea9c9..4f3133f 100644
--- a/src/Encoder/ErrorHandlingEncoder.php
+++ b/src/Encoder/ErrorHandlingEncoder.php
@@ -8,16 +8,18 @@
 use VeeWee\Reflecta\Iso\Iso;
 
 /**
- * @template-covariant TData
- * @template-covariant TXml
+ * @template TDataIn
+ * @template TDataOut
+ * @template TXmlOut
+ * @template TXmlIn
  *
- * @implements XmlEncoder<TData, TXml>
- * @implements Feature\DecoratingEncoder<TData, TXml>
+ * @implements XmlEncoder<TDataIn, TDataOut, TXmlOut, TXmlIn>
+ * @implements Feature\DecoratingEncoder<TDataIn, TDataOut, TXmlOut, TXmlIn>
  */
 final class ErrorHandlingEncoder implements Feature\DecoratingEncoder, XmlEncoder
 {
     /**
-     * @param XmlEncoder<TData, TXml> $encoder
+     * @param XmlEncoder<TDataIn, TDataOut, TXmlOut, TXmlIn> $encoder
      */
     public function __construct(
         private readonly XmlEncoder $encoder
@@ -25,7 +27,7 @@ public function __construct(
     }
 
     /**
-     * @return XmlEncoder<TData, TXml>
+     * @return XmlEncoder<TDataIn, TDataOut, TXmlOut, TXmlIn>
      */
     public function decoratedEncoder(): XmlEncoder
     {
@@ -33,7 +35,7 @@ public function decoratedEncoder(): XmlEncoder
     }
 
     /**
-     * @return Iso<TData, TXml>
+     * @return Iso<TDataIn, TDataOut, TXmlOut, TXmlIn>
      */
     public function iso(Context $context): Iso
     {
@@ -41,8 +43,8 @@ public function iso(Context $context): Iso
 
         return new Iso(
             /**
-             * @psalm-param TData $value
-             * @psalm-return TXml
+             * @psalm-param TDataIn $value
+             * @psalm-return TXmlOut
              */
             static function (mixed $value) use ($innerIso, $context): mixed {
                 try {
@@ -52,8 +54,8 @@ static function (mixed $value) use ($innerIso, $context): mixed {
                 }
             },
             /**
-             * @psalm-param TXml $value
-             * @psalm-return TData
+             * @psalm-param TXmlIn $value
+             * @psalm-return TDataOut
              */
             static function (mixed $value) use ($innerIso, $context): mixed {
                 try {
diff --git a/src/Encoder/Feature/DecoratingEncoder.php b/src/Encoder/Feature/DecoratingEncoder.php
index 97ae597..39bdf35 100644
--- a/src/Encoder/Feature/DecoratingEncoder.php
+++ b/src/Encoder/Feature/DecoratingEncoder.php
@@ -5,13 +5,15 @@
 use Soap\Encoding\Encoder\XmlEncoder;
 
 /**
- * @template-covariant TData
- * @template-covariant TXml
+ * @template-covariant TDataIn
+ * @template-covariant TDataOut
+ * @template-covariant TXmlOut
+ * @template-covariant TXmlIn
  */
 interface DecoratingEncoder
 {
     /**
-     * @return XmlEncoder<TData, TXml>
+     * @return XmlEncoder<TDataIn, TDataOut, TXmlOut, TXmlIn>
      */
     public function decoratedEncoder(): XmlEncoder;
 }
diff --git a/src/Encoder/Feature/ProvidesObjectDecoderLens.php b/src/Encoder/Feature/ProvidesObjectDecoderLens.php
index 4e9e1af..bd6bb30 100644
--- a/src/Encoder/Feature/ProvidesObjectDecoderLens.php
+++ b/src/Encoder/Feature/ProvidesObjectDecoderLens.php
@@ -4,18 +4,20 @@
 
 use Soap\Engine\Metadata\Model\Property;
 use Soap\Engine\Metadata\Model\Type;
-use VeeWee\Reflecta\Lens\Lens;
+use VeeWee\Reflecta\Lens\LensInterface;
 
 /**
  * When an encoder implements this feature interface, it knows how to create a lens that will be applied on the parent data that is being decoded.
  *
- * @template-covariant S
+ * @template-covariant S of array<array-key, mixed>
+ * @template-covariant T of array<array-key, mixed>
  * @template-covariant A
+ * @template-covariant B
  */
 interface ProvidesObjectDecoderLens
 {
     /**
-     * @return Lens<S, A>
+     * @return LensInterface<S, T, A, B>
      */
-    public static function createObjectDecoderLens(Type $parentType, Property $currentProperty): Lens;
+    public static function createObjectDecoderLens(Type $parentType, Property $currentProperty): LensInterface;
 }
diff --git a/src/Encoder/Feature/ProvidesObjectEncoderLens.php b/src/Encoder/Feature/ProvidesObjectEncoderLens.php
index 82c7551..5459d02 100644
--- a/src/Encoder/Feature/ProvidesObjectEncoderLens.php
+++ b/src/Encoder/Feature/ProvidesObjectEncoderLens.php
@@ -4,18 +4,20 @@
 
 use Soap\Engine\Metadata\Model\Property;
 use Soap\Engine\Metadata\Model\Type;
-use VeeWee\Reflecta\Lens\Lens;
+use VeeWee\Reflecta\Lens\LensInterface;
 
 /**
  * When an encoder implements this feature interface, it knows how to create a lens that will be applied on the parent data that is being encoded.
  *
- * @template-covariant S
+ * @template-covariant S of object
+ * @template-covariant T of object
  * @template-covariant A
+ * @template-covariant B
  */
 interface ProvidesObjectEncoderLens
 {
     /**
-     * @return Lens<S, A>
+     * @return LensInterface<S, T, A, B>
      */
-    public static function createObjectEncoderLens(Type $parentType, Property $currentProperty): Lens;
+    public static function createObjectEncoderLens(Type $parentType, Property $currentProperty): LensInterface;
 }
diff --git a/src/Encoder/FixedIsoEncoder.php b/src/Encoder/FixedIsoEncoder.php
index f41dc04..923a342 100644
--- a/src/Encoder/FixedIsoEncoder.php
+++ b/src/Encoder/FixedIsoEncoder.php
@@ -2,27 +2,29 @@
 
 namespace Soap\Encoding\Encoder;
 
-use VeeWee\Reflecta\Iso\Iso;
+use VeeWee\Reflecta\Iso\IsoInterface;
 
 /**
  * @template S
+ * @template T
  * @template A
- * @implements XmlEncoder<S, A>
+ * @template B
+ * @implements XmlEncoder<S, T, A, B>
  */
 final readonly class FixedIsoEncoder implements XmlEncoder
 {
     /**
-     * @param Iso<S, A> $iso
+     * @param IsoInterface<S, T, A, B> $iso
      */
     public function __construct(
-        private Iso $iso,
+        private IsoInterface $iso,
     ) {
     }
 
     /**
-     * @return Iso<S, A>
+     * @return IsoInterface<S, T, A, B>
      */
-    public function iso(Context $context): Iso
+    public function iso(Context $context): IsoInterface
     {
         return $this->iso;
     }
diff --git a/src/Encoder/MatchingValueEncoder.php b/src/Encoder/MatchingValueEncoder.php
index ec98999..56becf2 100644
--- a/src/Encoder/MatchingValueEncoder.php
+++ b/src/Encoder/MatchingValueEncoder.php
@@ -11,18 +11,18 @@
  * This encoder can be used to select an encoder based on the value being encoded.
  * For decoding, it will always use the default encoder.
  *
- * @psalm-type MatchedEncoderInfo = Context | array{0: Context, 1 ?: XmlEncoder<mixed, string>|null}
+ * @psalm-type MatchedEncoderInfo = Context | array{0: Context, 1 ?: XmlEncoder<mixed, mixed, string, Element|string>|null}
  * @psalm-type MatchingEncoderDetector = \Closure(Context, mixed): MatchedEncoderInfo
  *
  * @psalm-suppress UnusedClass
  *
- * @implements XmlEncoder<mixed, string>
+ * @implements XmlEncoder<mixed, mixed, string, Element|string>
  */
 final readonly class MatchingValueEncoder implements XmlEncoder
 {
     /**
      * @param MatchingEncoderDetector $encoderDetector
-     * @param XmlEncoder<mixed, string> $defaultEncoder
+     * @param XmlEncoder<mixed, mixed, string, Element|string> $defaultEncoder
      */
     public function __construct(
         private Closure $encoderDetector,
@@ -32,7 +32,6 @@ public function __construct(
 
     public function iso(Context $context): Iso
     {
-        /** @var Iso<string, mixed> $defaultIso */
         $defaultIso = $this->defaultEncoder->iso($context);
 
         return new Iso(
diff --git a/src/Encoder/Method/RequestEncoder.php b/src/Encoder/Method/RequestEncoder.php
index d9c7636..969165c 100644
--- a/src/Encoder/Method/RequestEncoder.php
+++ b/src/Encoder/Method/RequestEncoder.php
@@ -19,12 +19,12 @@
 use function VeeWee\Reflecta\Lens\index;
 
 /**
- * @template-implements SoapMethodEncoder<list<mixed>, non-empty-string>
+ * @template-implements SoapMethodEncoder<list<mixed>, list<mixed>, non-empty-string, non-empty-string>
  */
 final class RequestEncoder implements SoapMethodEncoder
 {
     /**
-     * @return Iso<list<mixed>, non-empty-string>
+     * @return Iso<list<mixed>, list<mixed>, non-empty-string, non-empty-string>
      */
     public function iso(MethodContext $context): Iso
     {
@@ -35,7 +35,7 @@ public function iso(MethodContext $context): Iso
                 ->unwrapOr(BindingUse::LITERAL)
         );
 
-        /** @var Iso<list<mixed>, non-empty-string> */
+        /** @var Iso<list<mixed>, list<mixed>, non-empty-string, non-empty-string> */
         return new Iso(
             /**
              * @param list<mixed> $arguments
diff --git a/src/Encoder/Method/ResponseEncoder.php b/src/Encoder/Method/ResponseEncoder.php
index 3cc469e..451564d 100644
--- a/src/Encoder/Method/ResponseEncoder.php
+++ b/src/Encoder/Method/ResponseEncoder.php
@@ -17,12 +17,12 @@
 use function Psl\Vec\map;
 
 /**
- * @template-implements SoapMethodEncoder<mixed, string>
+ * @template-implements SoapMethodEncoder<list<mixed>, list<mixed>, string, string>
  */
 final class ResponseEncoder implements SoapMethodEncoder
 {
     /**
-     * @return Iso<mixed, string>
+     * @return Iso<list<mixed>, list<mixed>, string, string>
      */
     public function iso(MethodContext $context): Iso
     {
@@ -33,7 +33,7 @@ public function iso(MethodContext $context): Iso
                 ->unwrapOr(BindingUse::LITERAL)
         );
 
-        /** @var Iso<list<mixed>, string> */
+        /** @var Iso<list<mixed>, list<mixed>, string, string> */
         return new Iso(
             /**
              * @param list<mixed> $arguments
diff --git a/src/Encoder/Method/SoapMethodEncoder.php b/src/Encoder/Method/SoapMethodEncoder.php
index 52007b1..74e541c 100644
--- a/src/Encoder/Method/SoapMethodEncoder.php
+++ b/src/Encoder/Method/SoapMethodEncoder.php
@@ -2,16 +2,18 @@
 
 namespace Soap\Encoding\Encoder\Method;
 
-use VeeWee\Reflecta\Iso\Iso;
+use VeeWee\Reflecta\Iso\IsoInterface;
 
 /**
- * @template-covariant TData
- * @template-covariant TXml
+ * @template-covariant TDataIn
+ * @template-covariant TDataOut
+ * @template-covariant TXmlOut
+ * @template-covariant TXmlIn
  */
 interface SoapMethodEncoder
 {
     /**
-     * @return Iso<TData, TXml>
+     * @return IsoInterface<TDataIn, TDataOut, TXmlOut, TXmlIn>
      */
-    public function iso(MethodContext $context): Iso;
+    public function iso(MethodContext $context): IsoInterface;
 }
diff --git a/src/Encoder/ObjectAccess.php b/src/Encoder/ObjectAccess.php
index 576cf5d..64ebd84 100644
--- a/src/Encoder/ObjectAccess.php
+++ b/src/Encoder/ObjectAccess.php
@@ -7,11 +7,13 @@
 use Soap\Encoding\EncoderRegistry;
 use Soap\Encoding\Normalizer\PhpPropertyNameNormalizer;
 use Soap\Encoding\TypeInference\ComplexTypeBuilder;
+use Soap\Encoding\Xml\Node\Element;
+use Soap\Encoding\Xml\Node\ElementList;
 use Soap\Engine\Metadata\Model\Property;
 use Soap\Engine\Metadata\Model\Type;
 use Soap\Engine\Metadata\Model\TypeMeta;
-use VeeWee\Reflecta\Iso\Iso;
-use VeeWee\Reflecta\Lens\Lens;
+use VeeWee\Reflecta\Iso\IsoInterface;
+use VeeWee\Reflecta\Lens\LensInterface;
 use function Psl\Vec\sort_by;
 use function VeeWee\Reflecta\Lens\index;
 use function VeeWee\Reflecta\Lens\optional;
@@ -21,9 +23,9 @@ final class ObjectAccess
 {
     /**
      * @param array<string, Property> $properties
-     * @param array<string, Lens<object, mixed>> $encoderLenses
-     * @param array<string, Lens<array, mixed>> $decoderLenses
-     * @param array<string, Iso<mixed, string>> $isos
+     * @param array<string, LensInterface<object|null, object|null, mixed, mixed>> $encoderLenses
+     * @param array<string, LensInterface<array<array-key, mixed>|null, array<array-key, mixed>|null, mixed, mixed>> $decoderLenses
+     * @param array<string, IsoInterface<mixed, mixed, string|null, Element|ElementList|string|null>> $isos
      */
     public function __construct(
         public readonly array $properties,
@@ -104,7 +106,7 @@ private static function build(Context $context): self
     }
 
     /**
-     * @return Lens<object, mixed>
+     * @return LensInterface<object|null, object|null, mixed, mixed>
      */
     private static function createEncoderLensForType(
         bool $shouldLensBeOptional,
@@ -112,19 +114,18 @@ private static function createEncoderLensForType(
         XmlEncoder $encoder,
         Type $type,
         Property $property,
-    ): Lens {
+    ): LensInterface {
         $lens = match (true) {
             $encoder instanceof Feature\DecoratingEncoder => self::createEncoderLensForType($shouldLensBeOptional, $normalizedName, $encoder->decoratedEncoder(), $type, $property),
             $encoder instanceof Feature\ProvidesObjectEncoderLens => $encoder::createObjectEncoderLens($type, $property),
             default => property($normalizedName)
         };
 
-        /** @var Lens<object, mixed> */
         return $shouldLensBeOptional ? optional($lens) : $lens;
     }
 
     /**
-     * @return Lens<array, mixed>
+     * @return LensInterface<array<array-key, mixed>|null, array<array-key, mixed>|null, mixed, mixed>
      */
     private static function createDecoderLensForType(
         bool $shouldLensBeOptional,
@@ -132,14 +133,13 @@ private static function createDecoderLensForType(
         XmlEncoder $encoder,
         Type $type,
         Property $property,
-    ): Lens {
+    ): LensInterface {
         $lens = match(true) {
             $encoder instanceof Feature\DecoratingEncoder => self::createDecoderLensForType($shouldLensBeOptional, $name, $encoder->decoratedEncoder(), $type, $property),
             $encoder instanceof Feature\ProvidesObjectDecoderLens => $encoder::createObjectDecoderLens($type, $property),
             default => index($name),
         };
 
-        /** @var Lens<array, mixed> */
         return $shouldLensBeOptional ? optional($lens) : $lens;
     }
 
diff --git a/src/Encoder/ObjectEncoder.php b/src/Encoder/ObjectEncoder.php
index 81bc5df..619cf32 100644
--- a/src/Encoder/ObjectEncoder.php
+++ b/src/Encoder/ObjectEncoder.php
@@ -13,7 +13,7 @@
 use Soap\Encoding\Xml\Writer\XsiAttributeBuilder;
 use Soap\Engine\Metadata\Model\Property;
 use VeeWee\Reflecta\Iso\Iso;
-use VeeWee\Reflecta\Lens\Lens;
+use VeeWee\Reflecta\Lens\LensInterface;
 use function is_array;
 use function Psl\Dict\map_with_key;
 use function Psl\Fun\lazy;
@@ -25,7 +25,7 @@
 /**
  * @template TObj extends object
  *
- * @implements XmlEncoder<TObj|array, non-empty-string>
+ * @implements XmlEncoder<TObj|array, TObj, non-empty-string, Element|non-empty-string>
  */
 final class ObjectEncoder implements Feature\ElementAware, XmlEncoder
 {
@@ -38,7 +38,7 @@ public function __construct(
     }
 
     /**
-     * @return Iso<TObj|array, non-empty-string>
+     * @return Iso<TObj|array, TObj, non-empty-string, Element|non-empty-string>
      */
     public function iso(Context $context): Iso
     {
@@ -105,12 +105,12 @@ static function (string $normalizePropertyName, Property $property) use ($object
                             return match(true) {
                                 $isAttribute => $value !== null ? (new AttributeBuilder(
                                     $type,
-                                    $iso->to($value)
+                                    (string) $iso->to($value)
                                 ))(...) : $defaultAction,
                                 $property->getName() === '_' => $value !== null
-                                    ? buildValue($iso->to($value))
+                                    ? buildValue((string) $iso->to($value))
                                     : (new NilAttributeBuilder())(...),
-                                default => raw($iso->to($value))
+                                default => raw((string) $iso->to($value))
                             };
                         }
                     )
@@ -125,7 +125,7 @@ static function (string $normalizePropertyName, Property $property) use ($object
     private function from(Context $context, ObjectAccess $objectAccess, Element $data): object
     {
         $nodes = (new DocumentToLookupArrayReader())($data);
-        /** @var Iso<TObj, array<string, mixed>> $objectData */
+        /** @var Iso<TObj, TObj, array<string, mixed>, array<string, mixed>> $objectData */
         $objectData = object_data($this->className);
 
         return $objectData->from(
@@ -153,7 +153,7 @@ static function (string $normalizePropertyName, Property $property) use ($object
         );
     }
 
-    private static function runLens(Lens $lens, mixed $data, mixed $default = null): mixed
+    private static function runLens(LensInterface $lens, mixed $data, mixed $default = null): mixed
     {
         try {
             /** @var mixed */
diff --git a/src/Encoder/OptionalElementEncoder.php b/src/Encoder/OptionalElementEncoder.php
index 3f08d82..78078f8 100644
--- a/src/Encoder/OptionalElementEncoder.php
+++ b/src/Encoder/OptionalElementEncoder.php
@@ -8,18 +8,19 @@
 use Soap\Encoding\Xml\Writer\NilAttributeBuilder;
 use Soap\Encoding\Xml\Writer\XsdTypeXmlElementWriter;
 use VeeWee\Reflecta\Iso\Iso;
+use VeeWee\Reflecta\Iso\IsoInterface;
 use VeeWee\Xml\Xmlns\Xmlns;
 use function count;
 use function is_string;
 
 /**
  * @template T of mixed
- * @implements XmlEncoder<T, string>
+ * @implements XmlEncoder<T, T, string, ElementList|Element|string>
  */
 final class OptionalElementEncoder implements Feature\ElementAware, Feature\OptionalAware, XmlEncoder
 {
     /**
-     * @param XmlEncoder<T, string> $elementEncoder
+     * @param XmlEncoder<T, T, string|null, ElementList|Element|string|null> $elementEncoder
      */
     public function __construct(
         private readonly XmlEncoder $elementEncoder
@@ -27,12 +28,13 @@ public function __construct(
     }
 
     /**
-     * @return Iso<T, string>
+     * @return IsoInterface<T, T, string, ElementList|Element|string>
      */
-    public function iso(Context $context): Iso
+    public function iso(Context $context): IsoInterface
     {
         $type = $context->type;
         $meta = $type->getMeta();
+        /** @var IsoInterface<T, T, string, ElementList|Element|string> $elementIso */
         $elementIso = $this->elementEncoder->iso($context);
         $isList = $meta->isList()->unwrapOr(false);
 
@@ -72,7 +74,7 @@ static function (ElementList|Element|string $xml) use ($elementIso, $isList) : m
                     return null;
                 }
 
-                /** @var Iso<T|null, ElementList|Element|non-empty-string> $elementIso */
+                /** @var Iso<T|null, T|null, ElementList|Element|non-empty-string, ElementList|Element|non-empty-string> $elementIso */
                 return $elementIso->from($xml);
             }
         );
diff --git a/src/Encoder/RepeatingElementEncoder.php b/src/Encoder/RepeatingElementEncoder.php
index 34648a3..f20ec56 100644
--- a/src/Encoder/RepeatingElementEncoder.php
+++ b/src/Encoder/RepeatingElementEncoder.php
@@ -12,12 +12,12 @@
 
 /**
  * @template T
- * @implements XmlEncoder<iterable<array-key, T>|null, string>
+ * @implements XmlEncoder<iterable<array-key, T>|null, iterable<array-key, T>, string, Element|ElementList|string>
  */
 final class RepeatingElementEncoder implements Feature\ElementAware, Feature\ListAware, XmlEncoder
 {
     /**
-     * @param XmlEncoder<T, string> $typeEncoder
+     * @param XmlEncoder<T, T, string|null, Element|ElementList|string|null> $typeEncoder
      */
     public function __construct(
         private readonly XmlEncoder $typeEncoder
@@ -25,7 +25,7 @@ public function __construct(
     }
 
     /**
-     * @return Iso<iterable<array-key, T>|null, string>
+     * @return Iso<iterable<array-key, T>|null, iterable<array-key, T>, string, Element|ElementList|string>
      */
     public function iso(Context $context): Iso
     {
@@ -47,8 +47,12 @@ static function (iterable|null $raw) use ($innerIso): string {
                         $raw ?? [],
                         /**
                          * @param T $item
+                         *
+                         * The inner XML output slot is `string|null` because it mirrors the shared aggregate
+                         * encoder type, but element encoders always produce a string in the to() direction;
+                         * the cast only collapses type-level nullability inherited from the aggregate.
                          */
-                        static fn (mixed $item): string => $innerIso->to($item)
+                        static fn (mixed $item): string => (string) $innerIso->to($item)
                     ),
                     ''
                 );
@@ -64,7 +68,7 @@ static function (Element|ElementList|string $xml) use ($innerIso): iterable {
                     default => ElementList::fromString('<list>'.$xml.'</list>')->elements()
                 };
 
-                /** @var Iso<T|null, Element|non-empty-string> $innerIso */
+                /** @var Iso<T|null, T|null, Element|non-empty-string, Element|non-empty-string> $innerIso */
                 return map(
                     $elements,
                     static fn (Element $element): mixed => $innerIso->from($element)
diff --git a/src/Encoder/SimpleType/AttributeValueEncoder.php b/src/Encoder/SimpleType/AttributeValueEncoder.php
index fd70687..3e62506 100644
--- a/src/Encoder/SimpleType/AttributeValueEncoder.php
+++ b/src/Encoder/SimpleType/AttributeValueEncoder.php
@@ -7,15 +7,16 @@
 use Soap\Encoding\Encoder\XmlEncoder;
 use Soap\Encoding\Exception\RestrictionException;
 use VeeWee\Reflecta\Iso\Iso;
+use VeeWee\Reflecta\Iso\IsoInterface;
 use function Psl\Type\scalar;
 
 /**
- * @implements XmlEncoder<mixed, string|null>
+ * @implements XmlEncoder<mixed, mixed, string|null, string|null>
  */
 final class AttributeValueEncoder implements XmlEncoder
 {
     /**
-     * @param XmlEncoder<mixed, string> $typeEncoder
+     * @param XmlEncoder<mixed, mixed, string, string> $typeEncoder
      */
     public function __construct(
         private readonly XmlEncoder $typeEncoder
@@ -23,7 +24,7 @@ public function __construct(
     }
 
     /**
-     * @return Iso<mixed, string|null>
+     * @return Iso<mixed, mixed, string|null, string|null>
      */
     public function iso(Context $context): Iso
     {
@@ -36,9 +37,9 @@ public function iso(Context $context): Iso
     }
 
     /**
-     * @param Iso<mixed, string> $typeIso
+     * @param IsoInterface<mixed, mixed, string, string> $typeIso
      */
-    private function to(Context $context, Iso $typeIso, mixed $value): ?string
+    private function to(Context $context, IsoInterface $typeIso, mixed $value): ?string
     {
         $meta = $context->type->getMeta();
         $fixed = $meta->fixed()
@@ -56,9 +57,9 @@ private function to(Context $context, Iso $typeIso, mixed $value): ?string
     }
 
     /**
-     * @param Iso<mixed, string> $typeIso
+     * @param IsoInterface<mixed, mixed, string, string> $typeIso
      */
-    private function from(Context $context, Iso $typeIso, ?string $value): mixed
+    private function from(Context $context, IsoInterface $typeIso, ?string $value): mixed
     {
         if ($value !== null) {
             return $typeIso->from($value);
diff --git a/src/Encoder/SimpleType/BackedEnumTypeEncoder.php b/src/Encoder/SimpleType/BackedEnumTypeEncoder.php
index c50fe41..3fcfaea 100644
--- a/src/Encoder/SimpleType/BackedEnumTypeEncoder.php
+++ b/src/Encoder/SimpleType/BackedEnumTypeEncoder.php
@@ -10,7 +10,7 @@
 use function Psl\Type\backed_enum;
 
 /**
- * @implements XmlEncoder<BackedEnum, string>
+ * @implements XmlEncoder<BackedEnum, BackedEnum, string, string>
  */
 final class BackedEnumTypeEncoder implements XmlEncoder
 {
@@ -23,7 +23,7 @@ public function __construct(
     }
 
     /**
-     * @return Iso<BackedEnum, string>
+     * @return Iso<BackedEnum, BackedEnum, string, string>
      */
     public function iso(Context $context): Iso
     {
diff --git a/src/Encoder/SimpleType/Base64BinaryTypeEncoder.php b/src/Encoder/SimpleType/Base64BinaryTypeEncoder.php
index 9ef336f..5ec788e 100644
--- a/src/Encoder/SimpleType/Base64BinaryTypeEncoder.php
+++ b/src/Encoder/SimpleType/Base64BinaryTypeEncoder.php
@@ -12,12 +12,12 @@
 use function Psl\Encoding\Base64\encode;
 
 /**
- * @implements XmlEncoder<string, string>
+ * @implements XmlEncoder<string, string, string, string>
  */
 final class Base64BinaryTypeEncoder implements XmlEncoder
 {
     /**
-     * @return Iso<string, string>
+     * @return Iso<string, string, string, string>
      */
     public function iso(Context $context): Iso
     {
diff --git a/src/Encoder/SimpleType/BoolTypeEncoder.php b/src/Encoder/SimpleType/BoolTypeEncoder.php
index 2fa2316..a7a1834 100644
--- a/src/Encoder/SimpleType/BoolTypeEncoder.php
+++ b/src/Encoder/SimpleType/BoolTypeEncoder.php
@@ -8,12 +8,12 @@
 use VeeWee\Reflecta\Iso\Iso;
 
 /**
- * @implements XmlEncoder<bool, string>
+ * @implements XmlEncoder<bool, bool, string, string>
  */
 final class BoolTypeEncoder implements XmlEncoder
 {
     /**
-     * @return Iso<bool, string>
+     * @return Iso<bool, bool, string, string>
      */
     public function iso(Context $context): Iso
     {
diff --git a/src/Encoder/SimpleType/CDataTypeEncoder.php b/src/Encoder/SimpleType/CDataTypeEncoder.php
index ddc7bc4..2cd5d90 100644
--- a/src/Encoder/SimpleType/CDataTypeEncoder.php
+++ b/src/Encoder/SimpleType/CDataTypeEncoder.php
@@ -14,12 +14,12 @@
  * When writing the data to the XML element, it will be wrapped in a CDATA section.
  *
  * @psalm-suppress UnusedClass
- * @implements XmlEncoder<string, string>
+ * @implements XmlEncoder<string, string, string, string>
  */
 final class CDataTypeEncoder implements Feature\CData, XmlEncoder
 {
     /**
-     * @return Iso<string, string>
+     * @return Iso<string, string, string, string>
      */
     public function iso(Context $context): Iso
     {
diff --git a/src/Encoder/SimpleType/DateTimeTypeEncoder.php b/src/Encoder/SimpleType/DateTimeTypeEncoder.php
index d351254..a7c6caf 100644
--- a/src/Encoder/SimpleType/DateTimeTypeEncoder.php
+++ b/src/Encoder/SimpleType/DateTimeTypeEncoder.php
@@ -10,7 +10,7 @@
 use VeeWee\Reflecta\Iso\Iso;
 
 /**
- * @implements XmlEncoder<DateTimeInterface, string>
+ * @implements XmlEncoder<DateTimeInterface, DateTimeImmutable, string, string>
  */
 final class DateTimeTypeEncoder implements XmlEncoder
 {
@@ -44,7 +44,7 @@ public static function timeZoned(): self
     }
 
     /**
-     * @return Iso<DateTimeInterface, string>
+     * @return Iso<DateTimeInterface, DateTimeImmutable, string, string>
      */
     public function iso(Context $context): Iso
     {
diff --git a/src/Encoder/SimpleType/DateTypeEncoder.php b/src/Encoder/SimpleType/DateTypeEncoder.php
index 345afea..0034f0f 100644
--- a/src/Encoder/SimpleType/DateTypeEncoder.php
+++ b/src/Encoder/SimpleType/DateTypeEncoder.php
@@ -10,7 +10,7 @@
 use VeeWee\Reflecta\Iso\Iso;
 
 /**
- * @implements XmlEncoder<DateTimeInterface, string>
+ * @implements XmlEncoder<DateTimeInterface, DateTimeImmutable, string, string>
  */
 final class DateTypeEncoder implements XmlEncoder
 {
@@ -44,13 +44,17 @@ public static function timeZoned(): self
     }
 
     /**
-     * @return Iso<DateTimeInterface, string>
+     * @return Iso<DateTimeInterface, DateTimeImmutable, string, string>
      */
     public function iso(Context $context): Iso
     {
         return (new Iso(
             fn (DateTimeInterface $value): string => $value->format($this->dateFormat),
-            static fn (string $value): DateTimeInterface => (new DateTimeImmutable($value))->setTime(0, 0),
+            static function (string $value): DateTimeImmutable {
+                /** @var DateTimeImmutable $result */
+                $result = (new DateTimeImmutable($value))->setTime(0, 0);
+                return $result;
+            },
         ));
     }
 }
diff --git a/src/Encoder/SimpleType/EncoderDetector.php b/src/Encoder/SimpleType/EncoderDetector.php
index f42799f..fdbe5d9 100644
--- a/src/Encoder/SimpleType/EncoderDetector.php
+++ b/src/Encoder/SimpleType/EncoderDetector.php
@@ -9,6 +9,8 @@
 use Soap\Encoding\Encoder\OptionalElementEncoder;
 use Soap\Encoding\Encoder\XmlEncoder;
 use Soap\Encoding\Encoder\XsiTypeEncoder;
+use Soap\Encoding\Xml\Node\Element;
+use Soap\Encoding\Xml\Node\ElementList;
 use Soap\Engine\Metadata\Model\XsdType;
 use function Psl\Iter\any;
 
@@ -23,7 +25,7 @@ public static function default(): self
     }
 
     /**
-     * @return XmlEncoder<mixed, string|null>
+     * @return XmlEncoder<mixed, mixed, string|null, ElementList|Element|string|null>
      */
     public function __invoke(Context $context): XmlEncoder
     {
@@ -34,8 +36,8 @@ public function __invoke(Context $context): XmlEncoder
     }
 
     /**
-     * @param XmlEncoder<mixed, string> $encoder
-     * @return XmlEncoder<mixed, string|null>
+     * @param XmlEncoder<mixed, mixed, string, string> $encoder
+     * @return XmlEncoder<mixed, mixed, string|null, ElementList|Element|string|null>
      */
     private function enhanceEncoder(Context $context, XmlEncoder $encoder): XmlEncoder
     {
@@ -68,7 +70,7 @@ private function enhanceEncoder(Context $context, XmlEncoder $encoder): XmlEncod
     }
 
     /**
-     * @return XmlEncoder<mixed, string>
+     * @return XmlEncoder<mixed, mixed, string, string>
      */
     private function detectSimpleTypeEncoder(Context $context): XmlEncoder
     {
diff --git a/src/Encoder/SimpleType/FloatTypeEncoder.php b/src/Encoder/SimpleType/FloatTypeEncoder.php
index d5c1d8a..63df17f 100644
--- a/src/Encoder/SimpleType/FloatTypeEncoder.php
+++ b/src/Encoder/SimpleType/FloatTypeEncoder.php
@@ -10,12 +10,12 @@
 use function Psl\Type\numeric_string;
 
 /**
- * @implements XmlEncoder<float, string>
+ * @implements XmlEncoder<float, float, numeric-string, string>
  */
 final class FloatTypeEncoder implements XmlEncoder
 {
     /**
-     * @return Iso<float, string>
+     * @return Iso<float, float, numeric-string, string>
      */
     public function iso(Context $context): Iso
     {
diff --git a/src/Encoder/SimpleType/HexBinaryTypeEncoder.php b/src/Encoder/SimpleType/HexBinaryTypeEncoder.php
index dd75565..90ef4be 100644
--- a/src/Encoder/SimpleType/HexBinaryTypeEncoder.php
+++ b/src/Encoder/SimpleType/HexBinaryTypeEncoder.php
@@ -11,12 +11,12 @@
 use function Psl\Encoding\Hex\encode;
 
 /**
- * @implements XmlEncoder<string, string>
+ * @implements XmlEncoder<string, string, string, string>
  */
 final class HexBinaryTypeEncoder implements XmlEncoder
 {
     /**
-     * @return Iso<string, string>
+     * @return Iso<string, string, string, string>
      */
     public function iso(Context $context): Iso
     {
diff --git a/src/Encoder/SimpleType/IntTypeEncoder.php b/src/Encoder/SimpleType/IntTypeEncoder.php
index 8ebafe5..87a6103 100644
--- a/src/Encoder/SimpleType/IntTypeEncoder.php
+++ b/src/Encoder/SimpleType/IntTypeEncoder.php
@@ -10,12 +10,12 @@
 use function Psl\Type\string;
 
 /**
- * @implements XmlEncoder<int, string>
+ * @implements XmlEncoder<int, int, string, string>
  */
 final class IntTypeEncoder implements XmlEncoder
 {
     /**
-     * @return Iso<int, string>
+     * @return Iso<int, int, string, string>
      */
     public function iso(Context $context): Iso
     {
diff --git a/src/Encoder/SimpleType/ScalarTypeEncoder.php b/src/Encoder/SimpleType/ScalarTypeEncoder.php
index fc6d4fd..0e5612d 100644
--- a/src/Encoder/SimpleType/ScalarTypeEncoder.php
+++ b/src/Encoder/SimpleType/ScalarTypeEncoder.php
@@ -14,7 +14,7 @@
 use function is_string;
 
 /**
- * @implements XmlEncoder<mixed, string>
+ * @implements XmlEncoder<mixed, scalar, string, string>
  */
 final class ScalarTypeEncoder implements XmlEncoder
 {
@@ -29,7 +29,7 @@ public static function default(): self
     /**
      * Will parse scalar values but accepts mixed to throw exceptions on invalid types.
      *
-     * @return Iso<mixed, string>
+     * @return Iso<mixed, scalar, string, string>
      */
     public function iso(Context $context): Iso
     {
diff --git a/src/Encoder/SimpleType/SimpleListEncoder.php b/src/Encoder/SimpleType/SimpleListEncoder.php
index 1769a51..c8cafc7 100644
--- a/src/Encoder/SimpleType/SimpleListEncoder.php
+++ b/src/Encoder/SimpleType/SimpleListEncoder.php
@@ -14,12 +14,12 @@
 use function Psl\Vec\map;
 
 /**
- * @implements XmlEncoder<array, string>
+ * @implements XmlEncoder<array|string, list<mixed>, string, string>
  */
 final class SimpleListEncoder implements Feature\ListAware, XmlEncoder
 {
     /**
-     * @param XmlEncoder<mixed, string> $typeEncoder
+     * @param XmlEncoder<mixed, mixed, string, string> $typeEncoder
      */
     public function __construct(
         private readonly XmlEncoder $typeEncoder
@@ -27,9 +27,7 @@ public function __construct(
     }
 
     /**
-     * @psalm-suppress ImplementedReturnTypeMismatch - ISO<S,A> does not ISO<S,T,A,B>
-     *
-     * @return Iso<string|array, string>
+     * @return Iso<array|string, list<mixed>, string, string>
      */
     public function iso(Context $context): Iso
     {
diff --git a/src/Encoder/SimpleType/StringTypeEncoder.php b/src/Encoder/SimpleType/StringTypeEncoder.php
index a34d75b..12e457c 100644
--- a/src/Encoder/SimpleType/StringTypeEncoder.php
+++ b/src/Encoder/SimpleType/StringTypeEncoder.php
@@ -9,12 +9,12 @@
 use VeeWee\Reflecta\Iso\Iso;
 
 /**
- * @implements XmlEncoder<string, string>
+ * @implements XmlEncoder<string, string, string, string>
  */
 final class StringTypeEncoder implements XmlEncoder
 {
     /**
-     * @return Iso<string, string>
+     * @return Iso<string, string, string, string>
      */
     public function iso(Context $context): Iso
     {
diff --git a/src/Encoder/SoapEnc/ApacheMapEncoder.php b/src/Encoder/SoapEnc/ApacheMapEncoder.php
index 1b9ad6a..e8a76bb 100644
--- a/src/Encoder/SoapEnc/ApacheMapEncoder.php
+++ b/src/Encoder/SoapEnc/ApacheMapEncoder.php
@@ -23,12 +23,12 @@
 use function VeeWee\Xml\Writer\Builder\value as buildValue;
 
 /**
- * @implements XmlEncoder<array<array-key, mixed>, non-empty-string>
+ * @implements XmlEncoder<array<array-key, mixed>, array<array-key, mixed>, non-empty-string, non-empty-string>
  */
 final class ApacheMapEncoder implements XmlEncoder
 {
     /**
-     * @return Iso<array<array-key, mixed>, non-empty-string>
+     * @return Iso<array<array-key, mixed>, array<array-key, mixed>, non-empty-string, non-empty-string>
      */
     public function iso(Context $context): Iso
     {
diff --git a/src/Encoder/SoapEnc/SoapArrayAccess.php b/src/Encoder/SoapEnc/SoapArrayAccess.php
index d4bd0a7..437dfc5 100644
--- a/src/Encoder/SoapEnc/SoapArrayAccess.php
+++ b/src/Encoder/SoapEnc/SoapArrayAccess.php
@@ -4,18 +4,19 @@
 
 use Soap\Encoding\Encoder\Context;
 use Soap\Encoding\Encoder\XmlEncoder;
+use Soap\Encoding\Xml\Node\Element;
+use Soap\Encoding\Xml\Node\ElementList;
 use Soap\Engine\Metadata\Model\TypeMeta;
 use Soap\Engine\Metadata\Model\XsdType;
 use Soap\WsdlReader\Model\Definitions\BindingUse;
 use Soap\WsdlReader\Parser\Xml\QnameParser;
 use Soap\Xml\Xmlns;
-use Stringable;
 use function Psl\Result\try_catch;
 
 final class SoapArrayAccess
 {
     /**
-     * @param XmlEncoder<mixed, Stringable|string> $itemEncoder
+     * @param XmlEncoder<mixed, mixed, string|null, Element|ElementList|string|null> $itemEncoder
      */
     public function __construct(
         public readonly string $xsiType,
diff --git a/src/Encoder/SoapEnc/SoapArrayEncoder.php b/src/Encoder/SoapEnc/SoapArrayEncoder.php
index c6c8414..6793ca4 100644
--- a/src/Encoder/SoapEnc/SoapArrayEncoder.php
+++ b/src/Encoder/SoapEnc/SoapArrayEncoder.php
@@ -22,12 +22,12 @@
 use function VeeWee\Xml\Writer\Builder\raw as buildRaw;
 
 /**
- * @implements XmlEncoder<list<mixed>, non-empty-string>
+ * @implements XmlEncoder<list<mixed>, list<mixed>, non-empty-string, non-empty-string>
  */
 final class SoapArrayEncoder implements ListAware, XmlEncoder
 {
     /**
-     * @return Iso<list<mixed>, non-empty-string>
+     * @return Iso<list<mixed>, list<mixed>, non-empty-string, non-empty-string>
      */
     public function iso(Context $context): Iso
     {
diff --git a/src/Encoder/SoapEnc/SoapObjectEncoder.php b/src/Encoder/SoapEnc/SoapObjectEncoder.php
index d433118..e0f31bb 100644
--- a/src/Encoder/SoapEnc/SoapObjectEncoder.php
+++ b/src/Encoder/SoapEnc/SoapObjectEncoder.php
@@ -21,12 +21,12 @@
 use function VeeWee\Xml\Writer\Builder\value as buildValue;
 
 /**
- * @implements XmlEncoder<object, non-empty-string>
+ * @implements XmlEncoder<object, object, non-empty-string, non-empty-string>
  */
 final class SoapObjectEncoder implements XmlEncoder
 {
     /**
-     * @return Iso<object, non-empty-string>
+     * @return Iso<object, object, non-empty-string, non-empty-string>
      */
     public function iso(Context $context): Iso
     {
diff --git a/src/Encoder/XmlEncoder.php b/src/Encoder/XmlEncoder.php
index 71e1508..9021e55 100644
--- a/src/Encoder/XmlEncoder.php
+++ b/src/Encoder/XmlEncoder.php
@@ -4,16 +4,18 @@
 
 namespace Soap\Encoding\Encoder;
 
-use VeeWee\Reflecta\Iso\Iso;
+use VeeWee\Reflecta\Iso\IsoInterface;
 
 /**
- * @template-covariant TData
- * @template-covariant TXml
+ * @template-covariant TDataIn
+ * @template-covariant TDataOut
+ * @template-covariant TXmlOut
+ * @template-covariant TXmlIn
  */
 interface XmlEncoder
 {
     /**
-     * @return Iso<TData, TXml>
+     * @return IsoInterface<TDataIn, TDataOut, TXmlOut, TXmlIn>
      */
-    public function iso(Context $context): Iso;
+    public function iso(Context $context): IsoInterface;
 }
diff --git a/src/Encoder/XsiTypeEncoder.php b/src/Encoder/XsiTypeEncoder.php
index e060ac5..1f92fb1 100644
--- a/src/Encoder/XsiTypeEncoder.php
+++ b/src/Encoder/XsiTypeEncoder.php
@@ -4,16 +4,18 @@
 
 use Soap\Encoding\TypeInference\XsiTypeDetector;
 use Soap\Encoding\Xml\Node\Element;
+use Soap\Encoding\Xml\Node\ElementList;
 use VeeWee\Reflecta\Iso\Iso;
+use VeeWee\Reflecta\Iso\IsoInterface;
 use function Psl\Type\non_empty_string;
 
 /**
- * @implements XmlEncoder<mixed, string>
+ * @implements XmlEncoder<mixed, mixed, string, Element|string>
  */
 final readonly class XsiTypeEncoder implements Feature\ElementAware, XmlEncoder
 {
     /**
-     * @param XmlEncoder<mixed, string> $encoder
+     * @param XmlEncoder<mixed, mixed, string|null, Element|ElementList|string|null> $encoder
      */
     public function __construct(
         private XmlEncoder $encoder
@@ -21,7 +23,7 @@ public function __construct(
     }
 
     /**
-     * @return Iso<mixed, string>
+     * @return Iso<mixed, mixed, string, Element|string>
      */
     public function iso(Context $context): Iso
     {
@@ -42,25 +44,29 @@ function (string|Element $value) use ($context, $innerIso) : mixed {
     }
 
     /**
-     * @param Iso<mixed, string> $innerIso
+     * @param IsoInterface<mixed, mixed, string|null, Element|ElementList|string|null> $innerIso
      */
-    private function to(Iso $innerIso, mixed $value): string
+    private function to(IsoInterface $innerIso, mixed $value): string
     {
         // There is no way to know what xsi:type to use when encoding any type.
         // The type defined in the wsdl will always be used to encode the value.
         // If you want more control over the encoded type, please control how to encode by using the MatchingValueEncoder.
-        return $innerIso->to($value);
+        //
+        // The inner XML output slot is `string|null` because it mirrors the shared aggregate encoder type,
+        // but element encoders always produce a (non-empty) string in the to() direction: the cast only collapses
+        // the type-level nullability that originates from attribute encoders elsewhere in the aggregate.
+        return (string) $innerIso->to($value);
     }
 
     /**
-     * @param Iso<mixed, string> $innerIso
+     * @param IsoInterface<mixed, mixed, string|null, Element|ElementList|string|null> $innerIso
      */
-    private function from(Context $context, Iso $innerIso, Element $value): mixed
+    private function from(Context $context, IsoInterface $innerIso, Element $value): mixed
     {
         $iso = match (true) {
             $this->encoder instanceof Feature\DisregardXsiInformation => $innerIso,
             default => XsiTypeDetector::detectEncoderFromXmlElement($context, $value->element())
-                ->map(static fn (XmlEncoder $encoder): Iso => $encoder->iso($context))
+                ->map(static fn (XmlEncoder $encoder): IsoInterface => $encoder->iso($context))
                 ->unwrapOr($innerIso),
         };
 
diff --git a/src/EncoderRegistry.php b/src/EncoderRegistry.php
index 520b0da..f90272a 100644
--- a/src/EncoderRegistry.php
+++ b/src/EncoderRegistry.php
@@ -13,19 +13,20 @@
 use Soap\Encoding\Encoder\SoapEnc;
 use Soap\Encoding\Encoder\XmlEncoder;
 use Soap\Encoding\Formatter\QNameFormatter;
+use Soap\Encoding\Xml\Node\Element;
+use Soap\Encoding\Xml\Node\ElementList;
 use Soap\Engine\Metadata\Model\XsdType;
 use Soap\WsdlReader\Metadata\Detector\ApacheMapDetector;
 use Soap\WsdlReader\Model\Definitions\EncodingStyle;
 use Soap\Xml\Xmlns;
 use stdClass;
-use Stringable;
 use function Psl\Dict\pull;
 
 final class EncoderRegistry
 {
     /**
-     * @param MutableMap<string, XmlEncoder<mixed, string>> $simpleTypeMap
-     * @param MutableMap<string, XmlEncoder<mixed, string>> $complextTypeMap
+     * @param MutableMap<string, XmlEncoder<mixed, mixed, string, string>> $simpleTypeMap
+     * @param MutableMap<string, XmlEncoder<mixed, mixed, string, Element|ElementList|string>> $complextTypeMap
      * @param int $decoderLibXmlOptions - bitmask of LIBXML_* constants https://www.php.net/manual/en/libxml.constants.php
      */
     private function __construct(
@@ -45,7 +46,7 @@ public static function default(): self
         $xsd1999 = Xmlns::xsd1999()->value();
 
         return new self(
-            /** @var MutableMap<XmlEncoder<mixed, string>> */
+            /** @var MutableMap<XmlEncoder<mixed, mixed, string, string>> */
             new MutableMap([
                 // Strings:
                 $qNameFormatter($xsd, 'string') => new SimpleType\StringTypeEncoder(),
@@ -139,7 +140,7 @@ public static function default(): self
                 $qNameFormatter($xsd1999, 'date') => SimpleType\DateTypeEncoder::default(),
                 $qNameFormatter($xsd1999, 'time') => new SimpleType\StringTypeEncoder(),
             ]),
-            /** @var MutableMap<XmlEncoder<mixed, string>> */
+            /** @var MutableMap<XmlEncoder<mixed, mixed, string, Element|ElementList|string>> */
             new MutableMap([
                 // SOAP 1.1 ENC
                 $qNameFormatter(EncodingStyle::SOAP_11->value, 'Array') => new SoapEnc\SoapArrayEncoder(),
@@ -227,7 +228,7 @@ public function addBackedEnumClassMapCollection(ClassMapCollection $classMapColl
     /**
      * @param non-empty-string $namespace
      * @param non-empty-string $name
-     * @param XmlEncoder<mixed, string> $encoder
+     * @param XmlEncoder<mixed, mixed, string, string> $encoder
      */
     public function addSimpleTypeConverter(string $namespace, string $name, XmlEncoder $encoder): self
     {
@@ -242,7 +243,7 @@ public function addSimpleTypeConverter(string $namespace, string $name, XmlEncod
     /**
      * @param non-empty-string $namespace
      * @param non-empty-string $name
-     * @param XmlEncoder<mixed, string> $encoder
+     * @param XmlEncoder<mixed, mixed, string, Element|ElementList|string> $encoder
      */
     public function addComplexTypeConverter(string $namespace, string $name, XmlEncoder $encoder): self
     {
@@ -255,7 +256,7 @@ public function addComplexTypeConverter(string $namespace, string $name, XmlEnco
     }
 
     /**
-     * @return XmlEncoder<mixed, string>
+     * @return XmlEncoder<mixed, mixed, string, string>
      */
     public function findSimpleEncoderByXsdType(XsdType $type): XmlEncoder
     {
@@ -266,7 +267,7 @@ public function findSimpleEncoderByXsdType(XsdType $type): XmlEncoder
     }
 
     /**
-     * @return XmlEncoder<mixed, string>
+     * @return XmlEncoder<mixed, mixed, string, string>
      */
     public function findSimpleEncoderByNamespaceName(string $namespace, string $name): XmlEncoder
     {
@@ -296,7 +297,7 @@ public function hasRegisteredSimpleTypeForNamespaceName(string $namespace, strin
     }
 
     /**
-     * @return XmlEncoder<mixed, string>
+     * @return XmlEncoder<mixed, mixed, string, Element|ElementList|string>
      */
     public function findComplexEncoderByXsdType(XsdType $type): XmlEncoder
     {
@@ -307,7 +308,7 @@ public function findComplexEncoderByXsdType(XsdType $type): XmlEncoder
     }
 
     /**
-     * @return XmlEncoder<mixed, string>
+     * @return XmlEncoder<mixed, mixed, string, Element|ElementList|string>
      */
     public function findComplexEncoderByNamespaceName(string $namespace, string $name): XmlEncoder
     {
@@ -337,7 +338,7 @@ public function hasRegisteredComplexTypeForNamespaceName(string $namespace, stri
     }
 
     /**
-     * @return XmlEncoder<mixed, string|Stringable>
+     * @return XmlEncoder<mixed, mixed, string|null, Element|ElementList|string|null>
      */
     public function detectEncoderForContext(Context $context): XmlEncoder
     {
diff --git a/src/Fault/Encoder/Soap11FaultEncoder.php b/src/Fault/Encoder/Soap11FaultEncoder.php
index 91cfce5..a857155 100644
--- a/src/Fault/Encoder/Soap11FaultEncoder.php
+++ b/src/Fault/Encoder/Soap11FaultEncoder.php
@@ -24,7 +24,7 @@
 final class Soap11FaultEncoder implements SoapFaultEncoder
 {
     /**
-     * @return Iso<Soap11Fault, non-empty-string>
+     * @return Iso<Soap11Fault, Soap11Fault, non-empty-string, non-empty-string>
      */
     public function iso(): Iso
     {
diff --git a/src/Fault/Encoder/Soap12FaultEncoder.php b/src/Fault/Encoder/Soap12FaultEncoder.php
index 5c6bbd3..36b02af 100644
--- a/src/Fault/Encoder/Soap12FaultEncoder.php
+++ b/src/Fault/Encoder/Soap12FaultEncoder.php
@@ -25,7 +25,7 @@ final class Soap12FaultEncoder implements SoapFaultEncoder
     private const ENV_NAMESPACE = 'http://www.w3.org/2003/05/soap-envelope';
 
     /**
-     * @return Iso<Soap12Fault, non-empty-string>
+     * @return Iso<Soap12Fault, Soap12Fault, non-empty-string, non-empty-string>
      */
     public function iso(): Iso
     {
diff --git a/src/Fault/Encoder/SoapFaultEncoder.php b/src/Fault/Encoder/SoapFaultEncoder.php
index b9aca33..e408144 100644
--- a/src/Fault/Encoder/SoapFaultEncoder.php
+++ b/src/Fault/Encoder/SoapFaultEncoder.php
@@ -12,7 +12,7 @@
 interface SoapFaultEncoder
 {
     /**
-     * @return Iso<TFault, non-empty-string>
+     * @return Iso<TFault, TFault, non-empty-string, non-empty-string>
      */
     public function iso(): Iso;
 }
diff --git a/src/Normalizer/PhpPropertyNameNormalizer.php b/src/Normalizer/PhpPropertyNameNormalizer.php
index 59ff625..341da3b 100644
--- a/src/Normalizer/PhpPropertyNameNormalizer.php
+++ b/src/Normalizer/PhpPropertyNameNormalizer.php
@@ -10,6 +10,7 @@
 use function count;
 use function preg_split;
 use function Psl\Type\non_empty_string;
+use function ucfirst;
 
 final class PhpPropertyNameNormalizer
 {
@@ -29,7 +30,7 @@ private static function camelCase(string $word, string $regexp):string
         }
 
         $keepUnchanged = array_shift($parts);
-        $parts = array_map(\ucfirst(...), $parts);
+        $parts = array_map(ucfirst(...), $parts);
         array_unshift($parts, $keepUnchanged);
 
         return non_empty_string()->assert(
diff --git a/src/TypeInference/XsiTypeDetector.php b/src/TypeInference/XsiTypeDetector.php
index 6c2b296..de16e14 100644
--- a/src/TypeInference/XsiTypeDetector.php
+++ b/src/TypeInference/XsiTypeDetector.php
@@ -9,6 +9,8 @@
 use Soap\Encoding\Encoder\Context;
 use Soap\Encoding\Encoder\FixedIsoEncoder;
 use Soap\Encoding\EncoderRegistry;
+use Soap\Encoding\Xml\Node\Element as XmlElement;
+use Soap\Encoding\Xml\Node\ElementList;
 use Soap\Engine\Metadata\Model\XsdType;
 use Soap\WsdlReader\Parser\Xml\QnameParser;
 use Soap\Xml\Xmlns as SoapXmlns;
@@ -24,7 +26,7 @@
 final class XsiTypeDetector
 {
     /**
-     * @return ScopedCache<EncoderRegistry, FixedIsoEncoder<mixed, string>>
+     * @return ScopedCache<EncoderRegistry, FixedIsoEncoder<mixed, mixed, string|null, XmlElement|ElementList|string|null>>
      *
      * @psalm-suppress LessSpecificReturnStatement, MoreSpecificReturnType, MixedReturnStatement
      */
@@ -89,7 +91,7 @@ public static function detectXsdTypeFromXmlElement(Context $context, Element $el
     }
 
     /**
-     * @return Option<FixedIsoEncoder<mixed, string>>
+     * @return Option<FixedIsoEncoder<mixed, mixed, string|null, XmlElement|ElementList|string|null>>
      */
     public static function detectEncoderFromXmlElement(Context $context, Element $element): Option
     {
diff --git a/src/Xml/Reader/ElementValueReader.php b/src/Xml/Reader/ElementValueReader.php
index 33afc7d..e5865c3 100644
--- a/src/Xml/Reader/ElementValueReader.php
+++ b/src/Xml/Reader/ElementValueReader.php
@@ -6,14 +6,14 @@
 use Dom\Element;
 use Soap\Encoding\Encoder\Context;
 use Soap\Encoding\Encoder\XmlEncoder;
-use VeeWee\Reflecta\Iso\Iso;
+use VeeWee\Reflecta\Iso\IsoInterface;
 use function Psl\Type\string;
 use function VeeWee\Xml\Dom\Locator\Node\value as readValue;
 
 final class ElementValueReader
 {
     /**
-     * @param XmlEncoder<mixed, string> $encoder
+     * @param XmlEncoder<mixed, mixed, string, string> $encoder
      * @psalm-return mixed
      */
     public function __invoke(
@@ -25,7 +25,7 @@ public function __invoke(
     }
 
     /**
-     * @param XmlEncoder<mixed, string> $encoder
+     * @param XmlEncoder<mixed, mixed, string, string> $encoder
      * @psalm-return mixed
      */
     public static function forEncoder(Context $context, XmlEncoder $encoder, Element $element): mixed
@@ -36,10 +36,10 @@ public static function forEncoder(Context $context, XmlEncoder $encoder, Element
     }
 
     /**
-     * @param Iso<mixed, string> $iso
+     * @param IsoInterface<mixed, mixed, string, string> $iso
      * @psalm-return mixed
      */
-    public static function forIso(Iso $iso, Element $element): mixed
+    public static function forIso(IsoInterface $iso, Element $element): mixed
     {
         return $iso->from(
             readValue($element, string())
diff --git a/src/Xml/Writer/ElementValueBuilder.php b/src/Xml/Writer/ElementValueBuilder.php
index 1e0ee15..bce72ff 100644
--- a/src/Xml/Writer/ElementValueBuilder.php
+++ b/src/Xml/Writer/ElementValueBuilder.php
@@ -8,7 +8,7 @@
 use Soap\Encoding\Encoder\Context;
 use Soap\Encoding\Encoder\Feature;
 use Soap\Encoding\Encoder\XmlEncoder;
-use VeeWee\Reflecta\Iso\Iso;
+use VeeWee\Reflecta\Iso\IsoInterface;
 use XMLWriter;
 use function VeeWee\Xml\Writer\Builder\cdata;
 use function VeeWee\Xml\Writer\Builder\children;
@@ -25,7 +25,7 @@ private function __construct(
     }
 
     /**
-     * @param XmlEncoder<mixed, string> $encoder
+     * @param XmlEncoder<mixed, mixed, string, mixed> $encoder
      * @psalm-param mixed $value
      */
     public static function fromEncoder(Context $context, XmlEncoder $encoder, mixed $value): self
@@ -37,11 +37,11 @@ public static function fromEncoder(Context $context, XmlEncoder $encoder, mixed
     }
 
     /**
-     * @param XmlEncoder<mixed, string> $encoder
-     * @param Iso<mixed, string> $iso
+     * @param XmlEncoder<mixed, mixed, mixed, mixed> $encoder
+     * @param IsoInterface<mixed, mixed, string, mixed> $iso
      * @psalm-param mixed $value
      */
-    public static function fromIso(Context $context, XmlEncoder $encoder, Iso $iso, mixed $value): self
+    public static function fromIso(Context $context, XmlEncoder $encoder, IsoInterface $iso, mixed $value): self
     {
         return new self([
             XsiAttributeBuilder::forEncodedValue($context, $encoder, $value),
@@ -58,7 +58,7 @@ public function __invoke(XMLWriter $writer): Generator
     }
 
     /**
-     * @param XmlEncoder<mixed, string> $encoder
+     * @param XmlEncoder<mixed, mixed, mixed, mixed> $encoder
      * @param Closure(): string $valueProvider
      *
      * @return Closure(XMLWriter): Generator<bool>