diff --git a/src/core/etl/src/Flow/ETL/PHP/Type/ArrayContentDetector.php b/src/core/etl/src/Flow/ETL/PHP/Type/ArrayContentDetector.php
new file mode 100644
index 000000000..b073edc91
--- /dev/null
+++ b/src/core/etl/src/Flow/ETL/PHP/Type/ArrayContentDetector.php
@@ -0,0 +1,70 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\ETL\PHP\Type;
+
+use Flow\ETL\Exception\InvalidArgumentException;
+use Flow\ETL\PHP\Type\Native\ArrayType;
+use Flow\ETL\PHP\Type\Native\NullType;
+use Flow\ETL\PHP\Type\Native\ScalarType;
+
+final class ArrayContentDetector
+{
+    public function __construct(private readonly Types $uniqueKeysType, private readonly Types $uniqueValuesType)
+    {
+    }
+
+    public function firstKeyType() : ?ScalarType
+    {
+        $type = $this->uniqueKeysType->first();
+
+        if (null !== $type && !$type instanceof ScalarType) {
+            throw InvalidArgumentException::because('First unique key type must be of ScalarType, given: ' . $type::class);
+        }
+
+        return $type;
+    }
+
+    public function firstValueType() : ?Type
+    {
+        return $this->uniqueValuesType->first();
+    }
+
+    public function isList() : bool
+    {
+        if (!$this->firstKeyType()?->isInteger()) {
+            return false;
+        }
+
+        return 1 === $this->uniqueValuesType->without(ArrayType::empty(), new NullType())->count();
+    }
+
+    public function isMap() : bool
+    {
+        if (1 === $this->uniqueValuesType->without(ArrayType::empty(), new NullType())->count()) {
+            if ($this->isList()) {
+                return false;
+            }
+
+            if (!$this->firstKeyType()?->isValidArrayKey()) {
+                return false;
+            }
+
+            return 1 === $this->uniqueKeysType->count();
+        }
+
+        return false;
+    }
+
+    public function isStructure() : bool
+    {
+        if ($this->isList() || $this->isMap()) {
+            return false;
+        }
+
+        return $this->firstKeyType()?->isString()
+            && 1 === $this->uniqueKeysType->count()
+            && 0 !== $this->uniqueValuesType->without(ArrayType::empty(), new NullType())->count();
+    }
+}
diff --git a/src/core/etl/src/Flow/ETL/PHP/Type/Logical/List/ListElement.php b/src/core/etl/src/Flow/ETL/PHP/Type/Logical/List/ListElement.php
index af5c62b32..8034bf3cb 100644
--- a/src/core/etl/src/Flow/ETL/PHP/Type/Logical/List/ListElement.php
+++ b/src/core/etl/src/Flow/ETL/PHP/Type/Logical/List/ListElement.php
@@ -24,6 +24,11 @@ public static function float() : self
         return new self(ScalarType::float());
     }
 
+    public static function fromType(Type $type) : self
+    {
+        return new self($type);
+    }
+
     public static function integer() : self
     {
         return new self(ScalarType::integer());
diff --git a/src/core/etl/src/Flow/ETL/PHP/Type/Logical/Map/MapKey.php b/src/core/etl/src/Flow/ETL/PHP/Type/Logical/Map/MapKey.php
index cffff19a1..6e51a0b98 100644
--- a/src/core/etl/src/Flow/ETL/PHP/Type/Logical/Map/MapKey.php
+++ b/src/core/etl/src/Flow/ETL/PHP/Type/Logical/Map/MapKey.php
@@ -10,6 +10,11 @@ private function __construct(private readonly ScalarType $value)
     {
     }
 
+    public static function fromType(ScalarType $type) : self
+    {
+        return new self($type);
+    }
+
     public static function integer() : self
     {
         return new self(ScalarType::integer());
diff --git a/src/core/etl/src/Flow/ETL/PHP/Type/Logical/Map/MapValue.php b/src/core/etl/src/Flow/ETL/PHP/Type/Logical/Map/MapValue.php
index a8dbd723f..1302750a0 100644
--- a/src/core/etl/src/Flow/ETL/PHP/Type/Logical/Map/MapValue.php
+++ b/src/core/etl/src/Flow/ETL/PHP/Type/Logical/Map/MapValue.php
@@ -24,6 +24,11 @@ public static function float() : self
         return new self(ScalarType::float());
     }
 
+    public static function fromType(Type $type) : self
+    {
+        return new self($type);
+    }
+
     public static function integer() : self
     {
         return new self(ScalarType::integer());
diff --git a/src/core/etl/src/Flow/ETL/PHP/Type/Native/ArrayType.php b/src/core/etl/src/Flow/ETL/PHP/Type/Native/ArrayType.php
new file mode 100644
index 000000000..d9b15c037
--- /dev/null
+++ b/src/core/etl/src/Flow/ETL/PHP/Type/Native/ArrayType.php
@@ -0,0 +1,37 @@
+<?php
+declare(strict_types=1);
+
+namespace Flow\ETL\PHP\Type\Native;
+
+use Flow\ETL\PHP\Type\Type;
+
+final class ArrayType implements NativeType
+{
+    public function __construct(private readonly bool $empty = false)
+    {
+    }
+
+    public static function empty() : self
+    {
+        return new self(true);
+    }
+
+    public function isEqual(Type $type) : bool
+    {
+        return $type instanceof self && $this->empty === $type->empty;
+    }
+
+    public function isValid(mixed $value) : bool
+    {
+        return \is_array($value);
+    }
+
+    public function toString() : string
+    {
+        if ($this->empty) {
+            return 'array<empty, empty>';
+        }
+
+        return 'array<mixed>';
+    }
+}
diff --git a/src/core/etl/src/Flow/ETL/PHP/Type/Native/CallableType.php b/src/core/etl/src/Flow/ETL/PHP/Type/Native/CallableType.php
new file mode 100644
index 000000000..09752dc81
--- /dev/null
+++ b/src/core/etl/src/Flow/ETL/PHP/Type/Native/CallableType.php
@@ -0,0 +1,24 @@
+<?php
+declare(strict_types=1);
+
+namespace Flow\ETL\PHP\Type\Native;
+
+use Flow\ETL\PHP\Type\Type;
+
+final class CallableType implements NativeType
+{
+    public function isEqual(Type $type) : bool
+    {
+        return $type instanceof self;
+    }
+
+    public function isValid(mixed $value) : bool
+    {
+        return \is_callable($value);
+    }
+
+    public function toString() : string
+    {
+        return 'callable';
+    }
+}
diff --git a/src/core/etl/src/Flow/ETL/PHP/Type/Native/NullType.php b/src/core/etl/src/Flow/ETL/PHP/Type/Native/NullType.php
new file mode 100644
index 000000000..7c2956913
--- /dev/null
+++ b/src/core/etl/src/Flow/ETL/PHP/Type/Native/NullType.php
@@ -0,0 +1,24 @@
+<?php
+declare(strict_types=1);
+
+namespace Flow\ETL\PHP\Type\Native;
+
+use Flow\ETL\PHP\Type\Type;
+
+final class NullType implements NativeType
+{
+    public function isEqual(Type $type) : bool
+    {
+        return $type instanceof self;
+    }
+
+    public function isValid(mixed $value) : bool
+    {
+        return null === $value;
+    }
+
+    public function toString() : string
+    {
+        return 'null';
+    }
+}
diff --git a/src/core/etl/src/Flow/ETL/PHP/Type/Native/ResourceType.php b/src/core/etl/src/Flow/ETL/PHP/Type/Native/ResourceType.php
new file mode 100644
index 000000000..cc6fab2ff
--- /dev/null
+++ b/src/core/etl/src/Flow/ETL/PHP/Type/Native/ResourceType.php
@@ -0,0 +1,24 @@
+<?php
+declare(strict_types=1);
+
+namespace Flow\ETL\PHP\Type\Native;
+
+use Flow\ETL\PHP\Type\Type;
+
+final class ResourceType implements NativeType
+{
+    public function isEqual(Type $type) : bool
+    {
+        return $type instanceof self;
+    }
+
+    public function isValid(mixed $value) : bool
+    {
+        return \is_resource($value);
+    }
+
+    public function toString() : string
+    {
+        return 'resource';
+    }
+}
diff --git a/src/core/etl/src/Flow/ETL/PHP/Type/Native/ScalarType.php b/src/core/etl/src/Flow/ETL/PHP/Type/Native/ScalarType.php
index 2956bfe31..dea774ff7 100644
--- a/src/core/etl/src/Flow/ETL/PHP/Type/Native/ScalarType.php
+++ b/src/core/etl/src/Flow/ETL/PHP/Type/Native/ScalarType.php
@@ -17,9 +17,11 @@ final class ScalarType implements NativeType
 
     public const STRING = 'string';
 
-    private function __construct(private readonly string $value, private readonly bool $optional)
+    private readonly string $value;
+
+    private function __construct(string $value, private readonly bool $optional)
     {
-        match (\strtolower($value)) {
+        $this->value = match (\strtolower($value)) {
             'integer' => self::INTEGER,
             'float', 'double' => self::FLOAT,
             'string' => self::STRING,
@@ -53,11 +55,31 @@ public static function string(bool $optional = false) : self
         return new self(self::STRING, $optional);
     }
 
+    public function isBoolean() : bool
+    {
+        return $this->value === self::BOOLEAN;
+    }
+
     public function isEqual(Type $type) : bool
     {
         return $type instanceof self && $type->value === $this->value;
     }
 
+    public function isFloat() : bool
+    {
+        return $this->value === self::FLOAT;
+    }
+
+    public function isInteger() : bool
+    {
+        return $this->value === self::INTEGER;
+    }
+
+    public function isString() : bool
+    {
+        return $this->value === self::STRING;
+    }
+
     public function isValid(mixed $value) : bool
     {
         if (null === $value && $this->optional) {
@@ -82,6 +104,11 @@ public function isValid(mixed $value) : bool
         return true;
     }
 
+    public function isValidArrayKey() : bool
+    {
+        return $this->isString() || $this->isInteger();
+    }
+
     public function optional() : bool
     {
         return $this->optional;
diff --git a/src/core/etl/src/Flow/ETL/PHP/Type/TypeFactory.php b/src/core/etl/src/Flow/ETL/PHP/Type/TypeFactory.php
new file mode 100644
index 000000000..73b51ad5b
--- /dev/null
+++ b/src/core/etl/src/Flow/ETL/PHP/Type/TypeFactory.php
@@ -0,0 +1,72 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\ETL\PHP\Type;
+
+use Flow\ETL\Exception\InvalidArgumentException;
+use Flow\ETL\PHP\Type\Logical\List\ListElement;
+use Flow\ETL\PHP\Type\Logical\ListType;
+use Flow\ETL\PHP\Type\Logical\Map\MapKey;
+use Flow\ETL\PHP\Type\Logical\Map\MapValue;
+use Flow\ETL\PHP\Type\Logical\MapType;
+use Flow\ETL\PHP\Type\Logical\Structure\StructureElement;
+use Flow\ETL\PHP\Type\Logical\StructureType;
+use Flow\ETL\PHP\Type\Native\ArrayType;
+use Flow\ETL\PHP\Type\Native\NullType;
+use Flow\ETL\PHP\Type\Native\ObjectType;
+use Flow\ETL\PHP\Type\Native\ScalarType;
+
+final class TypeFactory
+{
+    public function getType(mixed $value) : Type
+    {
+        if (null === $value) {
+            return new NullType();
+        }
+
+        if (\is_scalar($value)) {
+            return ScalarType::fromString(\gettype($value));
+        }
+
+        if (\is_object($value)) {
+            return ObjectType::of($value::class);
+        }
+
+        if (\is_array($value)) {
+            if ([] === $value) {
+                return ArrayType::empty();
+            }
+
+            $detector = new ArrayContentDetector(
+                new Types(...\array_map([$this, 'getType'], \array_keys($value))),
+                new Types(...\array_map([$this, 'getType'], \array_values($value)))
+            );
+
+            $firstKey = $detector->firstKeyType();
+            $firstValue = $detector->firstValueType();
+
+            if ($detector->isList() && $firstValue) {
+                return new ListType(ListElement::fromType($firstValue));
+            }
+
+            if ($detector->isMap() && $firstKey && $firstValue) {
+                return new MapType(MapKey::fromType($firstKey), MapValue::fromType($firstValue));
+            }
+
+            if ($detector->isStructure()) {
+                $elements = [];
+
+                foreach ($value as $key => $item) {
+                    $elements[] = new StructureElement($key, $this->getType($item));
+                }
+
+                return new StructureType(...$elements);
+            }
+
+            return new ArrayType([] === \array_filter($value, fn ($value) : bool => null !== $value));
+        }
+
+        throw InvalidArgumentException::because('Unsupported type given: ' . \gettype($value));
+    }
+}
diff --git a/src/core/etl/src/Flow/ETL/PHP/Type/Types.php b/src/core/etl/src/Flow/ETL/PHP/Type/Types.php
new file mode 100644
index 000000000..0e378cd3f
--- /dev/null
+++ b/src/core/etl/src/Flow/ETL/PHP/Type/Types.php
@@ -0,0 +1,46 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\ETL\PHP\Type;
+
+final class Types implements \Countable
+{
+    private readonly ?Type $first;
+
+    private readonly array $types;
+
+    public function __construct(Type ...$types)
+    {
+        $this->types = \array_map(
+            fn (string $type) : Type => \unserialize($type),
+            \array_unique(
+                \array_map(fn (Type $type) : string => \serialize($type), $types)
+            )
+        );
+        $this->first = $this->types[0] ?? null;
+    }
+
+    public function count() : int
+    {
+        return \count($this->types);
+    }
+
+    public function first() : ?Type
+    {
+        return $this->first;
+    }
+
+    public function without(Type ...$types) : self
+    {
+        return new self(...\array_filter($this->types, function (Type $type) use ($types) : bool {
+            foreach ($types as $withoutType) {
+                if ($type->isEqual($withoutType)) {
+                    return false;
+                }
+            }
+
+            return true;
+        }));
+    }
+}
diff --git a/src/core/etl/tests/Flow/ETL/Tests/Unit/PHP/Type/ArrayContentDetectorTest.php b/src/core/etl/tests/Flow/ETL/Tests/Unit/PHP/Type/ArrayContentDetectorTest.php
new file mode 100644
index 000000000..603a26416
--- /dev/null
+++ b/src/core/etl/tests/Flow/ETL/Tests/Unit/PHP/Type/ArrayContentDetectorTest.php
@@ -0,0 +1,285 @@
+<?php declare(strict_types=1);
+
+namespace Flow\ETL\Tests\Unit\PHP\Type;
+
+use Flow\ETL\PHP\Type\ArrayContentDetector;
+use Flow\ETL\PHP\Type\Logical\List\ListElement;
+use Flow\ETL\PHP\Type\Logical\ListType;
+use Flow\ETL\PHP\Type\Logical\Map\MapKey;
+use Flow\ETL\PHP\Type\Logical\Map\MapValue;
+use Flow\ETL\PHP\Type\Logical\MapType;
+use Flow\ETL\PHP\Type\Logical\Structure\StructureElement;
+use Flow\ETL\PHP\Type\Logical\StructureType;
+use Flow\ETL\PHP\Type\Native\ArrayType;
+use Flow\ETL\PHP\Type\Native\NullType;
+use Flow\ETL\PHP\Type\Native\ScalarType;
+use Flow\ETL\PHP\Type\Types;
+use PHPUnit\Framework\Attributes\DataProvider;
+use PHPUnit\Framework\TestCase;
+
+final class ArrayContentDetectorTest extends TestCase
+{
+    public static function provide_list_data() : \Generator
+    {
+        yield 'simple list' => [
+            [
+                ScalarType::integer(),
+            ],
+            [
+                ScalarType::string(),
+            ],
+            true,
+        ];
+
+        yield 'simple map' => [
+            [
+                ScalarType::string(),
+            ],
+            [
+                ScalarType::string(),
+            ],
+            false,
+        ];
+
+        yield 'simple structure' => [
+            [
+                ScalarType::string(),
+            ],
+            [
+                ScalarType::string(),
+                new MapType(MapKey::string(), MapValue::string()),
+                new ListType(ListElement::integer()),
+            ],
+            false,
+        ];
+
+        yield 'list of unique same structures' => [
+            [
+                ScalarType::integer(),
+            ],
+            [
+                new StructureType(
+                    new StructureElement('id', ScalarType::integer()),
+                    new StructureElement('name', ScalarType::string())
+                ),
+            ],
+            true,
+        ];
+
+        yield 'map with string key, of maps string with string' => [
+            [
+                ScalarType::string(),
+            ],
+            [
+                new MapType(
+                    MapKey::string(),
+                    MapValue::map(
+                        new MapType(MapKey::string(), MapValue::string()),
+                    )
+                ),
+            ],
+            false,
+        ];
+
+        yield 'array of nulls' => [
+            [
+                ScalarType::string(),
+            ],
+            [
+                new NullType(),
+                new NullType(),
+                new NullType(),
+            ],
+            false,
+        ];
+    }
+
+    public static function provide_map_data() : \Generator
+    {
+        yield 'simple list' => [
+            [
+                ScalarType::integer(),
+            ],
+            [
+                ScalarType::string(),
+            ],
+            false,
+        ];
+
+        yield 'simple map' => [
+            [
+                ScalarType::string(),
+            ],
+            [
+                ScalarType::string(),
+            ],
+            true,
+        ];
+
+        yield 'simple structure' => [
+            [
+                ScalarType::string(),
+            ],
+            [
+                ScalarType::string(),
+                new MapType(MapKey::string(), MapValue::string()),
+                new ListType(ListElement::integer()),
+            ],
+            false,
+        ];
+
+        yield 'list of unique same structures' => [
+            [
+                ScalarType::integer(),
+            ],
+            [
+                new StructureType(
+                    new StructureElement('id', ScalarType::integer()),
+                    new StructureElement('name', ScalarType::string())
+                ),
+            ],
+            false,
+        ];
+
+        yield 'map with string key, of maps string with string' => [
+            [
+                ScalarType::string(),
+            ],
+            [
+                new MapType(
+                    MapKey::string(),
+                    MapValue::map(
+                        new MapType(MapKey::string(), MapValue::string()),
+                    )
+                ),
+            ],
+            true,
+        ];
+
+        yield 'array of nulls' => [
+            [
+                ScalarType::string(),
+            ],
+            [
+                new NullType(),
+                new NullType(),
+                new NullType(),
+            ],
+            false,
+        ];
+    }
+
+    public static function provide_structure_data() : \Generator
+    {
+        yield 'simple list' => [
+            [
+                ScalarType::integer(),
+            ],
+            [
+                ScalarType::string(),
+            ],
+            false,
+        ];
+
+        yield 'simple map' => [
+            [
+                ScalarType::string(),
+            ],
+            [
+                ScalarType::string(),
+            ],
+            false,
+        ];
+
+        yield 'simple structure' => [
+            [
+                ScalarType::string(),
+            ],
+            [
+                ScalarType::string(),
+                new MapType(MapKey::string(), MapValue::string()),
+                new ListType(ListElement::integer()),
+            ],
+            true,
+        ];
+
+        yield 'list of unique same structures' => [
+            [
+                ScalarType::integer(),
+            ],
+            [
+                new StructureType(
+                    new StructureElement('id', ScalarType::integer()),
+                    new StructureElement('name', ScalarType::string())
+                ),
+            ],
+            false,
+        ];
+
+        yield 'map with string key, of maps string with string' => [
+            [
+                ScalarType::string(),
+            ],
+            [
+                new MapType(
+                    MapKey::string(),
+                    MapValue::map(
+                        new MapType(MapKey::string(), MapValue::string()),
+                    )
+                ),
+            ],
+            false,
+        ];
+
+        yield 'array of nulls' => [
+            [
+                ScalarType::string(),
+            ],
+            [
+                new NullType(),
+                new NullType(),
+                new NullType(),
+            ],
+            false,
+        ];
+
+        yield 'array of empty arrays' => [
+            [
+                ScalarType::string(),
+            ],
+            [
+                ArrayType::empty(),
+                ArrayType::empty(),
+                ArrayType::empty(),
+            ],
+            false,
+        ];
+    }
+
+    #[DataProvider('provide_list_data')]
+    public function test_list_data(array $keys, array $values, bool $expected) : void
+    {
+        $this->assertSame(
+            $expected,
+            (new ArrayContentDetector(new Types(...$keys), new Types(...$values)))->isList()
+        );
+    }
+
+    #[DataProvider('provide_map_data')]
+    public function test_map_data(array $keys, array $values, bool $expected) : void
+    {
+        $this->assertSame(
+            $expected,
+            (new ArrayContentDetector(new Types(...$keys), new Types(...$values)))->isMap()
+        );
+    }
+
+    #[DataProvider('provide_structure_data')]
+    public function test_structure_data(array $keys, array $values, bool $expected) : void
+    {
+        $this->assertSame(
+            $expected,
+            (new ArrayContentDetector(new Types(...$keys), new Types(...$values)))->isStructure()
+        );
+    }
+}
diff --git a/src/core/etl/tests/Flow/ETL/Tests/Unit/PHP/Type/Native/ArrayTypeTest.php b/src/core/etl/tests/Flow/ETL/Tests/Unit/PHP/Type/Native/ArrayTypeTest.php
new file mode 100644
index 000000000..14764d73c
--- /dev/null
+++ b/src/core/etl/tests/Flow/ETL/Tests/Unit/PHP/Type/Native/ArrayTypeTest.php
@@ -0,0 +1,69 @@
+<?php declare(strict_types=1);
+
+namespace Flow\ETL\Tests\Unit\PHP\Type\Native;
+
+use Flow\ETL\PHP\Type\Logical\Map\MapKey;
+use Flow\ETL\PHP\Type\Logical\Map\MapValue;
+use Flow\ETL\PHP\Type\Logical\MapType;
+use Flow\ETL\PHP\Type\Native\ArrayType;
+use Flow\ETL\PHP\Type\Native\ScalarType;
+use PHPUnit\Framework\TestCase;
+
+final class ArrayTypeTest extends TestCase
+{
+    public function test_equals() : void
+    {
+        $this->assertTrue(
+            (new ArrayType())->isEqual(new ArrayType)
+        );
+        $this->assertTrue(
+            ArrayType::empty()->isEqual(ArrayType::empty())
+        );
+        $this->assertFalse(
+            (new ArrayType())->isEqual(new MapType(MapKey::string(), MapValue::float()))
+        );
+        $this->assertFalse(
+            (new ArrayType())->isEqual(ScalarType::float())
+        );
+        $this->assertFalse(
+            ArrayType::empty()->isEqual(new ArrayType)
+        );
+    }
+
+    public function test_to_string() : void
+    {
+        $this->assertSame(
+            'array<mixed>',
+            (new ArrayType())->toString()
+        );
+        $this->assertSame(
+            'array<empty, empty>',
+            ArrayType::empty()->toString()
+        );
+    }
+
+    public function test_valid() : void
+    {
+        $this->assertTrue(
+            (new ArrayType())->isValid([])
+        );
+        $this->assertTrue(
+            (new ArrayType())->isValid(['one'])
+        );
+        $this->assertTrue(
+            (new ArrayType())->isValid([1])
+        );
+        $this->assertFalse(
+            (new ArrayType())->isValid(null)
+        );
+        $this->assertFalse(
+            (new ArrayType())->isValid('one')
+        );
+        $this->assertFalse(
+            (new ArrayType())->isValid(true)
+        );
+        $this->assertFalse(
+            (new ArrayType())->isValid(123)
+        );
+    }
+}
diff --git a/src/core/etl/tests/Flow/ETL/Tests/Unit/PHP/Type/Native/CallableTypeTest.php b/src/core/etl/tests/Flow/ETL/Tests/Unit/PHP/Type/Native/CallableTypeTest.php
new file mode 100644
index 000000000..cd9d3fe03
--- /dev/null
+++ b/src/core/etl/tests/Flow/ETL/Tests/Unit/PHP/Type/Native/CallableTypeTest.php
@@ -0,0 +1,50 @@
+<?php declare(strict_types=1);
+
+namespace Flow\ETL\Tests\Unit\PHP\Type\Native;
+
+use Flow\ETL\PHP\Type\Logical\Map\MapKey;
+use Flow\ETL\PHP\Type\Logical\Map\MapValue;
+use Flow\ETL\PHP\Type\Logical\MapType;
+use Flow\ETL\PHP\Type\Native\CallableType;
+use Flow\ETL\PHP\Type\Native\ScalarType;
+use PHPUnit\Framework\TestCase;
+
+final class CallableTypeTest extends TestCase
+{
+    public function test_equals() : void
+    {
+        $this->assertTrue(
+            (new CallableType)->isEqual(new CallableType)
+        );
+        $this->assertFalse(
+            (new CallableType)->isEqual(new MapType(MapKey::string(), MapValue::float()))
+        );
+        $this->assertFalse(
+            (new CallableType)->isEqual(ScalarType::float())
+        );
+    }
+
+    public function test_to_string() : void
+    {
+        $this->assertSame(
+            'callable',
+            (new CallableType)->toString()
+        );
+    }
+
+    public function test_valid() : void
+    {
+        $this->assertTrue(
+            (new CallableType)->isValid('printf')
+        );
+        $this->assertFalse(
+            (new CallableType)->isValid('one')
+        );
+        $this->assertFalse(
+            (new CallableType)->isValid([1, 2])
+        );
+        $this->assertFalse(
+            (new CallableType)->isValid(123)
+        );
+    }
+}
diff --git a/src/core/etl/tests/Flow/ETL/Tests/Unit/PHP/Type/Native/NullTypeTest.php b/src/core/etl/tests/Flow/ETL/Tests/Unit/PHP/Type/Native/NullTypeTest.php
new file mode 100644
index 000000000..5c62ec921
--- /dev/null
+++ b/src/core/etl/tests/Flow/ETL/Tests/Unit/PHP/Type/Native/NullTypeTest.php
@@ -0,0 +1,50 @@
+<?php declare(strict_types=1);
+
+namespace Flow\ETL\Tests\Unit\PHP\Type\Native;
+
+use Flow\ETL\PHP\Type\Logical\Map\MapKey;
+use Flow\ETL\PHP\Type\Logical\Map\MapValue;
+use Flow\ETL\PHP\Type\Logical\MapType;
+use Flow\ETL\PHP\Type\Native\NullType;
+use Flow\ETL\PHP\Type\Native\ScalarType;
+use PHPUnit\Framework\TestCase;
+
+final class NullTypeTest extends TestCase
+{
+    public function test_equals() : void
+    {
+        $this->assertTrue(
+            (new NullType)->isEqual(new NullType)
+        );
+        $this->assertFalse(
+            (new NullType)->isEqual(new MapType(MapKey::string(), MapValue::float()))
+        );
+        $this->assertFalse(
+            (new NullType)->isEqual(ScalarType::float())
+        );
+    }
+
+    public function test_to_string() : void
+    {
+        $this->assertSame(
+            'null',
+            (new NullType)->toString()
+        );
+    }
+
+    public function test_valid() : void
+    {
+        $this->assertTrue(
+            (new NullType)->isValid(null)
+        );
+        $this->assertFalse(
+            (new NullType)->isValid('one')
+        );
+        $this->assertFalse(
+            (new NullType)->isValid([1, 2])
+        );
+        $this->assertFalse(
+            (new NullType)->isValid(123)
+        );
+    }
+}
diff --git a/src/core/etl/tests/Flow/ETL/Tests/Unit/PHP/Type/Native/ResourceTypeTest.php b/src/core/etl/tests/Flow/ETL/Tests/Unit/PHP/Type/Native/ResourceTypeTest.php
new file mode 100644
index 000000000..f7f2e2d86
--- /dev/null
+++ b/src/core/etl/tests/Flow/ETL/Tests/Unit/PHP/Type/Native/ResourceTypeTest.php
@@ -0,0 +1,52 @@
+<?php declare(strict_types=1);
+
+namespace Flow\ETL\Tests\Unit\PHP\Type\Native;
+
+use Flow\ETL\PHP\Type\Logical\Map\MapKey;
+use Flow\ETL\PHP\Type\Logical\Map\MapValue;
+use Flow\ETL\PHP\Type\Logical\MapType;
+use Flow\ETL\PHP\Type\Native\ResourceType;
+use Flow\ETL\PHP\Type\Native\ScalarType;
+use PHPUnit\Framework\TestCase;
+
+final class ResourceTypeTest extends TestCase
+{
+    public function test_equals() : void
+    {
+        $this->assertTrue(
+            (new ResourceType)->isEqual(new ResourceType)
+        );
+        $this->assertFalse(
+            (new ResourceType)->isEqual(new MapType(MapKey::string(), MapValue::float()))
+        );
+        $this->assertFalse(
+            (new ResourceType)->isEqual(ScalarType::float())
+        );
+    }
+
+    public function test_to_string() : void
+    {
+        $this->assertSame(
+            'resource',
+            (new ResourceType)->toString()
+        );
+    }
+
+    public function test_valid() : void
+    {
+        $handle = \fopen('php://temp/max', 'r+b');
+        $this->assertTrue(
+            (new ResourceType)->isValid($handle)
+        );
+        \fclose($handle);
+        $this->assertFalse(
+            (new ResourceType)->isValid('one')
+        );
+        $this->assertFalse(
+            (new ResourceType)->isValid([1, 2])
+        );
+        $this->assertFalse(
+            (new ResourceType)->isValid(123)
+        );
+    }
+}
diff --git a/src/core/etl/tests/Flow/ETL/Tests/Unit/PHP/Type/TypeFactoryTest.php b/src/core/etl/tests/Flow/ETL/Tests/Unit/PHP/Type/TypeFactoryTest.php
new file mode 100644
index 000000000..98e381117
--- /dev/null
+++ b/src/core/etl/tests/Flow/ETL/Tests/Unit/PHP/Type/TypeFactoryTest.php
@@ -0,0 +1,307 @@
+<?php declare(strict_types=1);
+
+namespace Flow\ETL\Tests\Unit\PHP\Type;
+
+use Flow\ETL\PHP\Type\Logical\ListType;
+use Flow\ETL\PHP\Type\Logical\MapType;
+use Flow\ETL\PHP\Type\Logical\StructureType;
+use Flow\ETL\PHP\Type\Native\ArrayType;
+use Flow\ETL\PHP\Type\Native\NullType;
+use Flow\ETL\PHP\Type\Native\ObjectType;
+use Flow\ETL\PHP\Type\Native\ScalarType;
+use Flow\ETL\PHP\Type\TypeFactory;
+use PHPUnit\Framework\Attributes\DataProvider;
+use PHPUnit\Framework\TestCase;
+
+final class TypeFactoryTest extends TestCase
+{
+    public static function provide_data() : \Generator
+    {
+        yield 'null' => [
+            null,
+            NullType::class,
+            'null',
+        ];
+
+        yield 'simple list' => [
+            [
+                'one',
+                'two',
+                'three',
+            ],
+            ListType::class,
+            'list<string>',
+        ];
+
+        yield 'simple map' => [
+            [
+                'one' => 'one',
+                'two' => 'two',
+                'three' => 'three',
+            ],
+            MapType::class,
+            'map<string, string>',
+        ];
+
+        yield 'simple structure' => [
+            [
+                'one' => 'one',
+                'two' => 'two',
+                'three' => 'three',
+                'list' => [
+                    1, 2, 3,
+                ],
+                'map' => [
+                    'one' => 'one',
+                    'two' => 'two',
+                    'three' => 'three',
+                ],
+            ],
+            StructureType::class,
+            'structure{one: string, two: string, three: string, list: list<integer>, map: map<string, string>}',
+        ];
+
+        yield 'list of unique same structures' => [
+            [
+                [
+                    'id' => 1,
+                    'name' => 'Test 1',
+                ],
+                [
+                    'id' => 2,
+                    'name' => 'Test 2',
+                ],
+            ],
+            ListType::class,
+            'list<structure{id: integer, name: string}>',
+        ];
+
+        yield 'map with string key, of maps string with string' => [
+            [
+                'one' => [
+                    'map' => [
+                        'one' => 'one',
+                        'two' => 'two',
+                        'three' => 'three',
+                    ],
+                ],
+                'two' => [
+                    'map' => [
+                        'one' => 'one',
+                        'two' => 'two',
+                        'three' => 'three',
+                    ],
+                ],
+            ],
+            MapType::class,
+            'map<string, map<string, map<string, string>>>',
+        ];
+
+        yield 'empty array' => [
+            [],
+            ArrayType::class,
+            'array<empty, empty>',
+        ];
+
+        yield 'list with null' => [
+            [
+                1,
+                2,
+                3,
+                null,
+                5,
+            ],
+            ListType::class,
+            'list<integer>',
+        ];
+
+        yield 'one level list' => [
+            [
+                'one',
+                'two',
+                'three',
+                'map' => [
+                    'one' => 'one',
+                    'two' => 'two',
+                    'three' => 'three',
+                ],
+                'list' => [
+                    1, 2, 3,
+                ],
+            ],
+            ArrayType::class,
+            'array<mixed>',
+        ];
+
+        yield 'two level list' => [
+            [
+                'one',
+                'two',
+                'three',
+                'map' => [
+                    'one' => 'one',
+                    'two' => 'two',
+                    'three' => 'three',
+                    'list' => [
+                        1, 2, 3,
+                    ],
+                    'map' => [
+                        'one' => 'one',
+                        'two' => 'two',
+                        'three' => 'three',
+                    ],
+                ],
+                'list' => [
+                    1, 2, 3,
+                ],
+            ],
+            ArrayType::class,
+            'array<mixed>',
+        ];
+
+        yield 'complex structure' => [
+            [
+                [
+                    'id' => 1,
+                    'name' => 'Test 1',
+                    'active' => true,
+                ],
+                [
+                    'id' => 2,
+                    'name' => 'Test 2',
+                ],
+            ],
+            ArrayType::class,
+            'array<mixed>',
+        ];
+
+        yield 'list of lists' => [
+            [
+                [
+                    1, 2, 3,
+                ],
+                [
+                    4, 5, 6,
+                ],
+            ],
+            ListType::class,
+            'list<list<integer>>',
+        ];
+
+        yield 'list of lists with null' => [
+            [
+                [
+                    1, 2, 3,
+                ],
+                null,
+                [
+                    4, 5, 6,
+                ],
+            ],
+            ListType::class,
+            'list<list<integer>>',
+        ];
+
+        yield 'list of lists with empty' => [
+            [
+                [
+                    1, 2, 3,
+                ],
+                [
+                ],
+                [
+                    4, 5, 6,
+                ],
+            ],
+            ListType::class,
+            'list<list<integer>>',
+        ];
+
+        yield 'list of lists with array of nulls' => [
+            [
+                [
+                    1, 2, 3,
+                ],
+                [
+                    null,
+                ],
+                [
+                    4, 5, 6,
+                ],
+            ],
+            ListType::class,
+            'list<list<integer>>',
+        ];
+
+        yield 'map with null' => [
+            [
+                'one' => 'one',
+                'two' => null,
+                'three' => 'three',
+            ],
+            MapType::class,
+            'map<string, string>',
+        ];
+    }
+
+    public static function provide_object_data() : \Generator
+    {
+        yield 'stdclass' => [
+            new \stdClass(),
+        ];
+
+        yield 'datetime' => [
+            new \DateTime(),
+        ];
+
+        yield 'datetime immutable' => [
+            new \DateTimeImmutable(),
+        ];
+    }
+
+    public static function provide_scalar_data() : \Generator
+    {
+        yield 'bool' => [
+            true,
+            'boolean',
+        ];
+
+        yield 'string' => [
+            'test',
+            'string',
+        ];
+
+        yield 'float' => [
+            1.666,
+            'float',
+        ];
+
+        yield 'integer' => [
+            123456789,
+            'integer',
+        ];
+    }
+
+    #[DataProvider('provide_data')]
+    public function test_data($data, string $class, string $description) : void
+    {
+        $type = (new TypeFactory())->getType($data);
+
+        $this->assertInstanceOf($class, $type);
+        $this->assertSame($description, $type->toString());
+    }
+
+    #[DataProvider('provide_object_data')]
+    public function test_object_types(mixed $data) : void
+    {
+        $this->assertInstanceOf(ObjectType::class, (new TypeFactory())->getType($data));
+    }
+
+    #[DataProvider('provide_scalar_data')]
+    public function test_scalar_types(mixed $data, string $description) : void
+    {
+        $type = (new TypeFactory())->getType($data);
+        $this->assertInstanceOf(ScalarType::class, $type);
+        $this->assertSame($description, $type->toString());
+    }
+}