diff --git a/README.md b/README.md
index e5f86f5..3b4a4c4 100644
--- a/README.md
+++ b/README.md
@@ -183,8 +183,6 @@ $emailaddress
 	= Emailaddress::extractOrNull($input, 'not_existing_key', true) 
 	?? Emailaddress::from('default@domain.com'); 
 	// uses null coalescing operator to assign default value if key not present or null or invalid
-
-
 ```
 
 ## String-extractable types
@@ -692,6 +690,7 @@ All Enum-extractable types share following features:
 - `equalsValue(string $value): self` Returns `true` if parent contains the same value as `$value`.
 
 Enums can be created using standard extractors or using their constants:
+
 ```php
 CurrencyCode::from(
 	CurrencyCode::EUR
@@ -752,79 +751,105 @@ Represents Relation or Gate - AND / OR
 
 ## Primitive types and Arrays
 
-Types are able to get and extract primitives using `PrimitiveTypes` class. See examples below:
+Types are able to get and extract primitives using `IntType`, `IntArray`, `FloatType`, `FloatArray`, `StringType`, `StringArray`, `BoolType`, `BoolArray` and `Array` classes. See examples below:
 
 ```php
 <?php
 
 declare(strict_types = 1);
 
-use SmartEmailing\Types\PrimitiveTypes;
 use SmartEmailing\Types\Arrays;
+use SmartEmailing\Types\BoolArray;
+use SmartEmailing\Types\BoolType;
+use SmartEmailing\Types\FloatArray;
+use SmartEmailing\Types\FloatType;
+use SmartEmailing\Types\IntArray;
+use SmartEmailing\Types\IntType;
+use SmartEmailing\Types\StringArray;
+use SmartEmailing\Types\StringType;
+use SmartEmailing\Types\InvalidTypeException;
 
-PrimitiveTypes::getInt(666); // 666
-PrimitiveTypes::getInt('666'); // 666
-PrimitiveTypes::getInt(666.1); // throws InvalidTypeException
-PrimitiveTypes::getInt('abcd'); // throws InvalidTypeException
-PrimitiveTypes::getInt('abcd'); // throws InvalidTypeException
-PrimitiveTypes::getIntOrNull(null); // null
-PrimitiveTypes::getIntOrNull(1); // 1
-PrimitiveTypes::getIntOrNull('abcd'); // throws InvalidTypeException
-PrimitiveTypes::getIntOrNull('abcd', true); // null
-
-PrimitiveTypes::getFloat(1.1); // 1.1
-PrimitiveTypes::getFloat('1.1'); // 1.1
-PrimitiveTypes::getFloat(1); // 1.0
-PrimitiveTypes::getFloat('1'); // 1.0
-PrimitiveTypes::getFloat('xxx'); // throws InvalidTypeException
-PrimitiveTypes::getFloatOrNull(null); // null
-PrimitiveTypes::getFloatOrNull(1.0); // 1.0
-PrimitiveTypes::getFloatOrNull('abcd'); // throws InvalidTypeException
-PrimitiveTypes::getFloatOrNull('abcd', true); // null
-
-PrimitiveTypes::getString('xxx'); // 'xxx'
-PrimitiveTypes::getString(5); // '5'
-PrimitiveTypes::getString(5.0); // '5'
-PrimitiveTypes::getString(5.1); // '5.1'
-PrimitiveTypes::getStringOrNull(null); // null
-PrimitiveTypes::getStringOrNull('abcd'); // 'abcd'
-PrimitiveTypes::getStringOrNull([]); // throws InvalidTypeException
-PrimitiveTypes::getStringOrNull([], true); // null
-
-Arrays::getArray([1, 2]); // [1, 2]
-Arrays::getArray([1, 'abcd']); // [1, 'abcd']
-Arrays::getIntArray([1, '2']); // [1, 2]
-Arrays::getIntArrayOrNull([1, '2']); // returns int[]|null
-Arrays::getFloatArray([1, '2']); // [1.0, 2.0]
-Arrays::getFloatArrayOrNull([1, '2']); // returns float[]|null
-Arrays::getStringArray([1, '2']); // ['1', '2']
-Arrays::getStringArrayOrNull([1, '2']); // returns string[]|null
-
-// All PrimitiveTypes::get* methods have their extract equivalent:
-
-PrimitiveTypes::extractInt($data, 'key');
-PrimitiveTypes::extractIntOrNull($data, 'key');
-PrimitiveTypes::extractIntOrNull($data, 'key', true);
-
-PrimitiveTypes::extractString($data, 'key');
-PrimitiveTypes::extractStringOrNull($data, 'key');
-PrimitiveTypes::extractStringOrNull($data, 'key', true);
-
-PrimitiveTypes::extractFloat($data, 'key');
-PrimitiveTypes::extractFloatOrNull($data, 'key');
-PrimitiveTypes::extractFloatOrNull($data, 'key', true);
-
-Arrays::extractArray($data, 'key'); //returns mixed[]
-Arrays::extractArrayOrNull($data, 'key'); //returns mixed[]|null
-
-Arrays::extractIntArray($data, 'key'); //returns int[]
-Arrays::extractIntArrayOrNull($data, 'key'); //returns int[]|null
-
-Arrays::extractFloatArray($data, 'key'); //returns float[]
-Arrays::extractFloatArrayOrNull($data, 'key'); //returns float[]|null
-
-Arrays::extractStringArray($data, 'key'); //returns string[]
-Arrays::extractStringArrayOrNull($data, 'key'); //returns string[]|null
+IntType::from(666); // 666
+IntType::from('666'); // 666
+IntType::from(666.1); // throws InvalidTypeException
+IntType::from('abcd'); // throws InvalidTypeException
+IntType::from('abcd'); // throws InvalidTypeException
+IntType::fromOrNull(null); // null
+IntType::fromOrNull(1); // 1
+IntType::fromOrNull('abcd'); // throws InvalidTypeException
+IntType::fromOrNull('abcd', true); // null
+
+FloatType::from(1.1); // 1.1
+FloatType::from('1.1'); // 1.1
+FloatType::from(1); // 1.0
+FloatType::from('1'); // 1.0
+FloatType::from('xxx'); // throws InvalidTypeException
+FloatType::fromOrNull(null); // null
+FloatType::fromOrNull(1.0); // 1.0
+FloatType::fromOrNull('abcd'); // throws InvalidTypeException
+FloatType::fromOrNull('abcd', true); // null
+
+StringType::from('xxx'); // 'xxx'
+StringType::from(5); // '5'
+StringType::from(5.0); // '5'
+StringType::from(5.1); // '5.1'
+StringType::fromOrNull(null); // null
+StringType::fromOrNull('abcd'); // 'abcd'
+StringType::fromOrNull([]); // throws InvalidTypeException
+StringType::fromOrNull([], true); // null
+
+BoolType::from(true); // true
+BoolType::from(false); // false
+BoolType::from(1); // true
+BoolType::from(0); // false
+BoolType::from('1'); // true
+BoolType::from('0'); // false
+BoolType::from('true'); // true
+BoolType::from('false'); // false
+
+Arrays::from([1, 2]); // [1, 2]
+Arrays::from([1, 'abcd']); // [1, 'abcd']
+
+IntArray::from([1, '2']); // [1, 2]
+IntArray::fromOrNull([1, '2']); // returns int[]|null
+
+FloatArray::from([1, '2']); // [1.0, 2.0]
+FloatArray::fromOrNull([1, '2']); // returns float[]|null
+
+StringArray::from([1, '2']); // ['1', '2']
+StringArray::fromOrNull([1, '2']); // returns string[]|null
+
+BoolArray::from([1, '1']); // [true, true]
+BoolArray::fromOrNull([1, '1']); // returns bool[]|null
+
+// All primitive types have their extract equivalent:
+
+IntType::extract($data, 'key');
+IntType::extractOrNull($data, 'key');
+IntType::extractOrNull($data, 'key', true);
+
+StringType::extract($data, 'key');
+StringType::extractOrNull($data, 'key');
+StringType::extractOrNull($data, 'key', true);
+
+FloatType::extract($data, 'key');
+FloatType::extractOrNull($data, 'key');
+FloatType::extractOrNull($data, 'key', true);
+
+Arrays::extract($data, 'key'); //returns mixed[]
+Arrays::extractOrNull($data, 'key'); //returns mixed[]|null
+
+IntArray::extract($data, 'key'); //returns int[]
+IntArray::extractOrNull($data, 'key'); //returns int[]|null
+
+FloatArray::extract($data, 'key'); //returns float[]
+FloatArray::extractOrNull($data, 'key'); //returns float[]|null
+
+StringArray::extract($data, 'key'); //returns string[]
+StringArray::extractOrNull($data, 'key'); //returns string[]|null
+
+BoolArray::extract($data, 'key'); //returns bool[]
+BoolArray::extractOrNull($data, 'key'); //returns bool[]|null
 
 ```
 
diff --git a/src/Address.php b/src/Address.php
index 87e5dd2..a076b38 100644
--- a/src/Address.php
+++ b/src/Address.php
@@ -37,8 +37,8 @@ final class Address
 	private function __construct(
 		array $data
 	) {
-		$this->streetAndNumber = PrimitiveTypes::extractString($data, 'street_and_number');
-		$this->town = PrimitiveTypes::extractString($data, 'town');
+		$this->streetAndNumber = StringType::extract($data, 'street_and_number');
+		$this->town = StringType::extract($data, 'town');
 		$this->zipCode = ZipCode::extract($data, 'zip_code');
 		$this->country = CountryCode::extract($data, 'country');
 	}
diff --git a/src/Arrays.php b/src/Arrays.php
index b49e748..37557ef 100644
--- a/src/Arrays.php
+++ b/src/Arrays.php
@@ -6,16 +6,17 @@
 
 use SmartEmailing\Types\Helpers\ExtractableHelpers;
 
-abstract class Arrays
+abstract class Arrays implements ExtractableTypeInterface
 {
 
 	/**
 	 * @param mixed $value
 	 * @return array<mixed>
 	 */
-	final public static function getArray(
+	public static function from(
 		$value
-	): array {
+	): array
+	{
 		if (\is_array($value)) {
 			return $value;
 		}
@@ -26,12 +27,13 @@ final public static function getArray(
 	/**
 	 * @param mixed $value
 	 * @param bool $nullIfInvalid
-	 * @return array<mixed>|null
+	 * @return array<mixed>
 	 */
-	final public static function getArrayOrNull(
+	public static function fromOrNull(
 		$value,
-		bool $nullIfInvalid = false
-	): ?array {
+		bool $nullIfInvalid
+	): ?array
+	{
 		if (\is_array($value)) {
 			return $value;
 		}
@@ -41,7 +43,7 @@ final public static function getArrayOrNull(
 		}
 
 		try {
-			return self::getArray($value);
+			return self::from($value);
 		} catch (InvalidTypeException $e) {
 			if ($nullIfInvalid) {
 				return null;
@@ -52,14 +54,11 @@ final public static function getArrayOrNull(
 	}
 
 	/**
-	 * Preserves keys
-	 *
 	 * @param array<mixed> $data
 	 * @param string $key
 	 * @return array<mixed>
-	 * @throws \SmartEmailing\Types\InvalidTypeException
 	 */
-	final public static function extractArray(
+	public static function extract(
 		array $data,
 		string $key
 	): array
@@ -67,32 +66,30 @@ final public static function extractArray(
 		$value = ExtractableHelpers::extractValue($data, $key);
 
 		try {
-			return self::getArray($value);
+			return self::from($value);
 		} catch (InvalidTypeException $e) {
 			throw $e->wrap($key);
 		}
 	}
 
 	/**
-	 * Preserves keys
-	 *
 	 * @param array<mixed> $data
 	 * @param string $key
 	 * @param bool $nullIfInvalid
 	 * @return array<mixed>|null
-	 * @throws \SmartEmailing\Types\InvalidTypeException
 	 */
-	final public static function extractArrayOrNull(
+	public static function extractOrNull(
 		array $data,
 		string $key,
 		bool $nullIfInvalid = false
-	): ?array {
+	): ?array
+	{
 		if (!isset($data[$key])) {
 			return null;
 		}
 
 		try {
-			return self::extractArray($data, $key);
+			return self::extract($data, $key);
 		} catch (InvalidTypeException $e) {
 			if ($nullIfInvalid) {
 				return null;
@@ -104,52 +101,85 @@ final public static function extractArrayOrNull(
 
 	/**
 	 * @param mixed $value
-	 * @return array<int>
+	 * @return array<mixed>
+	 * @deprecated use Arrays::from
 	 */
-	final public static function getIntArray(
+	final public static function getArray(
 		$value
 	): array {
-		$array = self::getArray($value);
+		return self::from($value);
+	}
 
-		$return = [];
+	/**
+	 * @param mixed $value
+	 * @param bool $nullIfInvalid
+	 * @return array<mixed>|null
+	 * @deprecated use Arrays::::fromOrNull
+	 */
+	final public static function getArrayOrNull(
+		$value,
+		bool $nullIfInvalid = false
+	): ?array {
+		return self::fromOrNull($value, $nullIfInvalid);
+	}
 
-		foreach ($array as $index => $item) {
-			$return[$index] = PrimitiveTypes::getInt($item);
-		}
+	/**
+	 * Preserves keys
+	 *
+	 * @param array<mixed> $data
+	 * @param string $key
+	 * @return array<mixed>
+	 * @throws \SmartEmailing\Types\InvalidTypeException
+	 * @deprecated use Arrays::extract
+	 */
+	final public static function extractArray(
+		array $data,
+		string $key
+	): array
+	{
+		return self::extract($data, $key);
+	}
 
-		return $return;
+	/**
+	 * Preserves keys
+	 *
+	 * @param array<mixed> $data
+	 * @param string $key
+	 * @param bool $nullIfInvalid
+	 * @return array<mixed>|null
+	 * @throws \SmartEmailing\Types\InvalidTypeException
+	 * @deprecated use Arrays::extractOrNull
+	 */
+	final public static function extractArrayOrNull(
+		array $data,
+		string $key,
+		bool $nullIfInvalid = false
+	): ?array {
+		return self::extractOrNull($data, $key, $nullIfInvalid);
+	}
+
+	/**
+	 * @param mixed $value
+	 * @return array<int>
+	 * @deprecated use IntArray::from
+	 */
+	final public static function getIntArray(
+		$value
+	): array {
+		return IntArray::from($value);
 	}
 
 	/**
 	 * @param mixed $value
 	 * @param bool $nullIfInvalid
 	 * @return array<int>|null
+	 * @deprecated use IntArray::::fromOrNull
 	 */
 	final public static function getIntArrayOrNull(
 		$value,
 		bool $nullIfInvalid = false
 	): ?array {
-		$array = self::getArrayOrNull($value, $nullIfInvalid);
-
-		if ($array === null) {
-			return null;
-		}
-
-		$return = [];
-
-		try {
-			foreach ($array as $index => $item) {
-				$return[$index] = PrimitiveTypes::getInt($item);
-			}
-		} catch (InvalidTypeException $e) {
-			if ($nullIfInvalid) {
-				return null;
-			}
-
-			throw $e;
-		}
-
-		return $return;
+		return IntArray::fromOrNull($value, $nullIfInvalid);
 	}
 
 	/**
@@ -157,20 +187,13 @@ final public static function getIntArrayOrNull(
 	 * @param string $key
 	 * @return array<int>
 	 * @throws \SmartEmailing\Types\InvalidTypeException
+	 * @deprecated use IntArray::extract
 	 */
 	final public static function extractIntArray(
 		array $data,
 		string $key
 	): array {
-		$array = Arrays::extractArray($data, $key);
-
-		try {
-			$array = Arrays::getIntArray($array);
-		} catch (InvalidTypeException $e) {
-			throw $e->wrap($key);
-		}
-
-		return $array;
+		return IntArray::extract($data, $key);
 	}
 
 	/**
@@ -179,69 +202,38 @@ final public static function extractIntArray(
 	 * @param bool $nullIfInvalid
 	 * @return array<int>|null
 	 * @throws \SmartEmailing\Types\InvalidTypeException
+	 * @deprecated use IntArray::extractOrNull
 	 */
 	final public static function extractIntArrayOrNull(
 		array $data,
 		string $key,
 		bool $nullIfInvalid = false
 	): ?array {
-		$array = Arrays::extractArrayOrNull($data, $key, $nullIfInvalid);
-
-		if ($array === null) {
-			return null;
-		}
-
-		return self::getIntArrayOrNull($array, $nullIfInvalid);
+		return IntArray::extractOrNull($data, $key, $nullIfInvalid);
 	}
 
 	/**
 	 * @param mixed $value
 	 * @return array<float>
+	 * @deprecated use FloatArray::from
 	 */
 	final public static function getFloatArray(
 		$value
 	): array {
-		$array = self::getArray($value);
-
-		$return = [];
-
-		foreach ($array as $index => $item) {
-			$return[$index] = PrimitiveTypes::getFloat($item);
-		}
-
-		return $return;
+		return FloatArray::from($value);
 	}
 
 	/**
 	 * @param mixed $value
 	 * @param bool $nullIfInvalid
 	 * @return array<float>|null
+	 * @deprecated use FloatArray::::fromOrNull
 	 */
 	final public static function getFloatArrayOrNull(
 		$value,
 		bool $nullIfInvalid = false
 	): ?array {
-		$array = self::getArrayOrNull($value, $nullIfInvalid);
-
-		if ($array === null) {
-			return null;
-		}
-
-		$return = [];
-
-		try {
-			foreach ($array as $index => $item) {
-				$return[$index] = PrimitiveTypes::getFloat($item);
-			}
-		} catch (InvalidTypeException $e) {
-			if ($nullIfInvalid) {
-				return null;
-			}
-
-			throw $e;
-		}
-
-		return $return;
+		return FloatArray::fromOrNull($value, $nullIfInvalid);
 	}
 
 	/**
@@ -249,20 +241,13 @@ final public static function getFloatArrayOrNull(
 	 * @param string $key
 	 * @return array<float>
 	 * @throws \SmartEmailing\Types\InvalidTypeException
+	 * @deprecated use FloatArray::extract
 	 */
 	final public static function extractFloatArray(
 		array $data,
 		string $key
 	): array {
-		$array = Arrays::extractArray($data, $key);
-
-		try {
-			$array = Arrays::getFloatArray($array);
-		} catch (InvalidTypeException $e) {
-			throw $e->wrap($key);
-		}
-
-		return $array;
+		return FloatArray::extract($data, $key);
 	}
 
 	/**
@@ -271,69 +256,38 @@ final public static function extractFloatArray(
 	 * @param bool $nullIfInvalid
 	 * @return array<float>|null
 	 * @throws \SmartEmailing\Types\InvalidTypeException
+	 * @deprecated use FloatArray::extractOrNull
 	 */
 	final public static function extractFloatArrayOrNull(
 		array $data,
 		string $key,
 		bool $nullIfInvalid = false
 	): ?array {
-		$array = Arrays::extractArrayOrNull($data, $key, $nullIfInvalid);
-
-		if ($array === null) {
-			return null;
-		}
-
-		return self::getFloatArrayOrNull($array, $nullIfInvalid);
+		return FloatArray::extractOrNull($data, $key, $nullIfInvalid);
 	}
 
 	/**
 	 * @param mixed $value
 	 * @return array<string>
+	 * @deprecated use StringArray::from
 	 */
 	final public static function getStringArray(
 		$value
 	): array {
-		$array = self::getArray($value);
-
-		$return = [];
-
-		foreach ($array as $index => $item) {
-			$return[$index] = PrimitiveTypes::getString($item);
-		}
-
-		return $return;
+		return StringArray::from($value);
 	}
 
 	/**
 	 * @param mixed $value
 	 * @param bool $nullIfInvalid
 	 * @return array<string>|null
+	 * @deprecated use StringArray::::fromOrNull
 	 */
 	final public static function getStringArrayOrNull(
 		$value,
 		bool $nullIfInvalid = false
 	): ?array {
-		$array = self::getArrayOrNull($value, $nullIfInvalid);
-
-		if ($array === null) {
-			return null;
-		}
-
-		$return = [];
-
-		try {
-			foreach ($array as $index => $item) {
-				$return[$index] = PrimitiveTypes::getString($item);
-			}
-		} catch (InvalidTypeException $e) {
-			if ($nullIfInvalid) {
-				return null;
-			}
-
-			throw $e;
-		}
-
-		return $return;
+		return StringArray::fromOrNull($value, $nullIfInvalid);
 	}
 
 	/**
@@ -341,20 +295,13 @@ final public static function getStringArrayOrNull(
 	 * @param string $key
 	 * @return array<string>
 	 * @throws \SmartEmailing\Types\InvalidTypeException
+	 * @deprecated use StringArray::extract
 	 */
 	final public static function extractStringArray(
 		array $data,
 		string $key
 	): array {
-		$array = Arrays::extractArray($data, $key);
-
-		try {
-			$array = Arrays::getStringArray($array);
-		} catch (InvalidTypeException $e) {
-			throw $e->wrap($key);
-		}
-
-		return $array;
+		return StringArray::extract($data, $key);
 	}
 
 	/**
@@ -363,19 +310,14 @@ final public static function extractStringArray(
 	 * @param bool $nullIfInvalid
 	 * @return array<string>|null
 	 * @throws \SmartEmailing\Types\InvalidTypeException
+	 * @deprecated use StringArray::extractOrNull
 	 */
 	final public static function extractStringArrayOrNull(
 		array $data,
 		string $key,
 		bool $nullIfInvalid = false
 	): ?array {
-		$array = Arrays::extractArrayOrNull($data, $key, $nullIfInvalid);
-
-		if ($array === null) {
-			return null;
-		}
-
-		return self::getStringArrayOrNull($array, $nullIfInvalid);
+		return StringArray::extractOrNull($data, $key, $nullIfInvalid);
 	}
 
 }
diff --git a/src/BoolArray.php b/src/BoolArray.php
new file mode 100644
index 0000000..566e836
--- /dev/null
+++ b/src/BoolArray.php
@@ -0,0 +1,102 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace SmartEmailing\Types;
+
+abstract class BoolArray implements ExtractableTypeInterface
+{
+
+	/**
+	 * @param mixed $value
+	 * @return array<bool>
+	 */
+	final public static function from(
+		$value
+	): array {
+		$array = Arrays::from($value);
+
+		$return = [];
+
+		foreach ($array as $index => $item) {
+			$return[$index] = BoolType::from($item);
+		}
+
+		return $return;
+	}
+
+	/**
+	 * @param mixed $value
+	 * @param bool $nullIfInvalid
+	 * @return array<bool>|null
+	 */
+	final public static function fromOrNull(
+		$value,
+		bool $nullIfInvalid = false
+	): ?array {
+		$array = Arrays::fromOrNull($value, $nullIfInvalid);
+
+		if ($array === null) {
+			return null;
+		}
+
+		$return = [];
+
+		try {
+			foreach ($array as $index => $item) {
+				$return[$index] = BoolType::from($item);
+			}
+		} catch (InvalidTypeException $e) {
+			if ($nullIfInvalid) {
+				return null;
+			}
+
+			throw $e;
+		}
+
+		return $return;
+	}
+
+	/**
+	 * @param array<mixed> $data
+	 * @param string $key
+	 * @return array<bool>
+	 * @throws \SmartEmailing\Types\InvalidTypeException
+	 */
+	final public static function extract(
+		array $data,
+		string $key
+	): array {
+		$array = Arrays::extract($data, $key);
+
+		try {
+			$array = self::from($array);
+		} catch (InvalidTypeException $e) {
+			throw $e->wrap($key);
+		}
+
+		return $array;
+	}
+
+	/**
+	 * @param array<mixed> $data
+	 * @param string $key
+	 * @param bool $nullIfInvalid
+	 * @return array<bool>|null
+	 * @throws \SmartEmailing\Types\InvalidTypeException
+	 */
+	final public static function extractOrNull(
+		array $data,
+		string $key,
+		bool $nullIfInvalid = false
+	): ?array {
+		$array = Arrays::extractOrNull($data, $key, $nullIfInvalid);
+
+		if ($array === null) {
+			return null;
+		}
+
+		return self::fromOrNull($array, $nullIfInvalid);
+	}
+
+}
diff --git a/src/BoolType.php b/src/BoolType.php
new file mode 100644
index 0000000..be917d9
--- /dev/null
+++ b/src/BoolType.php
@@ -0,0 +1,109 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace SmartEmailing\Types;
+
+use Nette\Utils\Strings;
+use SmartEmailing\Types\Helpers\ExtractableHelpers;
+
+abstract class BoolType implements ExtractableTypeInterface
+{
+
+	/**
+	 * @param mixed $value
+	 * @return bool
+	 */
+	final public static function from(
+		$value
+	): bool {
+		if (\is_bool($value)) {
+			return $value;
+		}
+
+		if (\is_string($value)) {
+			$value = Strings::lower($value);
+		}
+
+		if (\in_array($value, [false, 0, '0', 'false'], true)) {
+			return false;
+		}
+
+		if (\in_array($value, [true, 1, '1', 'true'], true)) {
+			return true;
+		}
+
+		throw InvalidTypeException::typeError('bool', $value);
+	}
+
+	/**
+	 * @param mixed $value
+	 * @param bool $nullIfInvalid
+	 * @return bool|null
+	 */
+	final public static function fromOrNull(
+		$value,
+		bool $nullIfInvalid = false
+	): ?bool {
+		if ($value === null) {
+			return null;
+		}
+
+		try {
+			return self::from($value);
+		} catch (InvalidTypeException $e) {
+			if ($nullIfInvalid) {
+				return null;
+			}
+
+			throw $e;
+		}
+	}
+
+	/**
+	 * @param array<mixed> $data
+	 * @param string $key
+	 * @return bool
+	 * @throws \SmartEmailing\Types\InvalidTypeException
+	 */
+	final public static function extract(
+		array $data,
+		string $key
+	): bool {
+		$value = ExtractableHelpers::extractValue($data, $key);
+
+		try {
+			return self::from($value);
+		} catch (InvalidTypeException $e) {
+			throw $e->wrap($key);
+		}
+	}
+
+	/**
+	 * @param array<mixed> $data
+	 * @param string $key
+	 * @param bool $nullIfInvalid
+	 * @return bool|null
+	 * @throws \SmartEmailing\Types\InvalidTypeException
+	 */
+	final public static function extractOrNull(
+		array $data,
+		string $key,
+		bool $nullIfInvalid = false
+	): ?bool {
+		if (!isset($data[$key])) {
+			return null;
+		}
+
+		try {
+			return self::extract($data, $key);
+		} catch (InvalidTypeException $e) {
+			if ($nullIfInvalid) {
+				return null;
+			}
+
+			throw $e;
+		}
+	}
+
+}
diff --git a/src/DateTimes.php b/src/DateTimes.php
index acc2f80..49affaa 100644
--- a/src/DateTimes.php
+++ b/src/DateTimes.php
@@ -6,7 +6,7 @@
 
 use Nette\Utils\Arrays;
 
-abstract class DateTimes
+abstract class DateTimes implements ExtractableTypeInterface
 {
 
 	/**
@@ -43,12 +43,12 @@ final public static function from(
 
 	/**
 	 * @param mixed $value
-	 * @param bool $getNullIfInvalid
+	 * @param bool $nullIfInvalid
 	 * @return \DateTime
 	 */
 	public static function fromOrNull(
 		$value,
-		bool $getNullIfInvalid = false
+		bool $nullIfInvalid = false
 	): ?\DateTime {
 		if ($value === null) {
 			return null;
@@ -57,7 +57,7 @@ public static function fromOrNull(
 		try {
 			return self::from($value);
 		} catch (InvalidTypeException $e) {
-			if ($getNullIfInvalid) {
+			if ($nullIfInvalid) {
 				return null;
 			}
 
@@ -72,7 +72,7 @@ public static function fromOrNull(
 	 * @throws \SmartEmailing\Types\InvalidTypeException
 	 */
 	final public static function extract(
-		array &$data,
+		array $data,
 		string $key
 	): \DateTime {
 		$value = Arrays::get($data, $key, '');
@@ -84,6 +84,32 @@ final public static function extract(
 		}
 	}
 
+	/**
+	 * @param array<mixed> $data
+	 * @param string $key
+	 * @param bool $nullIfInvalid
+	 * @return \DateTime
+	 */
+	final public static function extractOrNull(
+		array $data,
+		string $key,
+		bool $nullIfInvalid = false
+	): ?\DateTime {
+		if (!isset($data[$key])) {
+			return null;
+		}
+
+		if ($nullIfInvalid) {
+			try {
+				return self::extract($data, $key);
+			} catch (InvalidTypeException $e) {
+				return null;
+			}
+		}
+
+		return self::extract($data, $key);
+	}
+
 	/**
 	 * @param array<mixed> $data
 	 * @param string $key
@@ -111,30 +137,4 @@ final public static function extractDateOrNull(
 		return Dates::extractOrNull($data, $key);
 	}
 
-	/**
-	 * @param array<mixed> $data
-	 * @param string $key
-	 * @param bool $getNullIfInvalid
-	 * @return \DateTime
-	 */
-	final public static function extractOrNull(
-		array &$data,
-		string $key,
-		bool $getNullIfInvalid = false
-	): ?\DateTime {
-		if (!isset($data[$key])) {
-			return null;
-		}
-
-		if ($getNullIfInvalid) {
-			try {
-				return self::extract($data, $key);
-			} catch (InvalidTypeException $e) {
-				return null;
-			}
-		}
-
-		return self::extract($data, $key);
-	}
-
 }
diff --git a/src/DateTimesImmutable.php b/src/DateTimesImmutable.php
index 0738fef..4bc0fe5 100644
--- a/src/DateTimesImmutable.php
+++ b/src/DateTimesImmutable.php
@@ -4,7 +4,7 @@
 
 namespace SmartEmailing\Types;
 
-abstract class DateTimesImmutable
+abstract class DateTimesImmutable implements ExtractableTypeInterface
 {
 
 	/**
@@ -21,14 +21,14 @@ final public static function from(
 
 	/**
 	 * @param mixed $value
-	 * @param bool $getNullIfInvalid
+	 * @param bool $nullIfInvalid
 	 * @return \DateTimeImmutable
 	 */
 	public static function fromOrNull(
 		$value,
-		bool $getNullIfInvalid = false
+		bool $nullIfInvalid = false
 	): ?\DateTimeImmutable {
-		$dateTime = DateTimes::fromOrNull($value, $getNullIfInvalid);
+		$dateTime = DateTimes::fromOrNull($value, $nullIfInvalid);
 
 		if ($dateTime === null) {
 			return null;
@@ -44,7 +44,7 @@ public static function fromOrNull(
 	 * @throws \SmartEmailing\Types\InvalidTypeException
 	 */
 	final public static function extract(
-		array &$data,
+		array $data,
 		string $key
 	): \DateTimeImmutable {
 		$dateTime = DateTimes::extract(
@@ -55,6 +55,30 @@ final public static function extract(
 		return self::immutate($dateTime);
 	}
 
+	/**
+	 * @param array<mixed> $data
+	 * @param string $key
+	 * @param bool $nullIfInvalid
+	 * @return \DateTimeImmutable
+	 */
+	final public static function extractOrNull(
+		array $data,
+		string $key,
+		bool $nullIfInvalid = false
+	): ?\DateTimeImmutable {
+		$dateTime = DateTimes::extractOrNull(
+			$data,
+			$key,
+			$nullIfInvalid
+		);
+
+		if ($dateTime === null) {
+			return null;
+		}
+
+		return self::immutate($dateTime);
+	}
+
 	/**
 	 * @param array<mixed> $data
 	 * @param string $key
@@ -82,30 +106,6 @@ final public static function extractDateOrNull(
 		return DatesImmutable::extractOrNull($data, $key);
 	}
 
-	/**
-	 * @param array<mixed> $data
-	 * @param string $key
-	 * @param bool $getNullIfInvalid
-	 * @return \DateTimeImmutable
-	 */
-	final public static function extractOrNull(
-		array &$data,
-		string $key,
-		bool $getNullIfInvalid = false
-	): ?\DateTimeImmutable {
-		$dateTime = DateTimes::extractOrNull(
-			$data,
-			$key,
-			$getNullIfInvalid
-		);
-
-		if ($dateTime === null) {
-			return null;
-		}
-
-		return self::immutate($dateTime);
-	}
-
 	private static function immutate(
 		\DateTime $dateTime
 	): \DateTimeImmutable {
diff --git a/src/Dates.php b/src/Dates.php
index 1de773f..af5ca8e 100644
--- a/src/Dates.php
+++ b/src/Dates.php
@@ -6,7 +6,7 @@
 
 use Nette\Utils\Arrays;
 
-abstract class Dates
+abstract class Dates implements ExtractableTypeInterface
 {
 
 	/**
@@ -35,12 +35,12 @@ final public static function from(
 
 	/**
 	 * @param mixed $value
-	 * @param bool $getNullIfInvalid
+	 * @param bool $nullIfInvalid
 	 * @return \DateTime
 	 */
 	public static function fromOrNull(
 		$value,
-		bool $getNullIfInvalid = false
+		bool $nullIfInvalid = false
 	): ?\DateTime {
 		if ($value === null) {
 			return null;
@@ -49,7 +49,7 @@ public static function fromOrNull(
 		try {
 			return self::from($value);
 		} catch (InvalidTypeException $e) {
-			if ($getNullIfInvalid) {
+			if ($nullIfInvalid) {
 				return null;
 			}
 
@@ -64,7 +64,7 @@ public static function fromOrNull(
 	 * @throws \SmartEmailing\Types\InvalidTypeException
 	 */
 	final public static function extract(
-		array &$data,
+		array $data,
 		string $key
 	): \DateTime {
 		$value = Arrays::get($data, $key, '');
@@ -79,19 +79,19 @@ final public static function extract(
 	/**
 	 * @param array<mixed> $data
 	 * @param string $key
-	 * @param bool $getNullIfInvalid
+	 * @param bool $nullIfInvalid
 	 * @return \DateTime
 	 */
 	final public static function extractOrNull(
-		array &$data,
+		array $data,
 		string $key,
-		bool $getNullIfInvalid = false
+		bool $nullIfInvalid = false
 	): ?\DateTime {
 		if (!isset($data[$key])) {
 			return null;
 		}
 
-		if ($getNullIfInvalid) {
+		if ($nullIfInvalid) {
 			try {
 				return self::extract($data, $key);
 			} catch (InvalidTypeException $e) {
diff --git a/src/DatesImmutable.php b/src/DatesImmutable.php
index 9295cc6..a304993 100644
--- a/src/DatesImmutable.php
+++ b/src/DatesImmutable.php
@@ -4,7 +4,7 @@
 
 namespace SmartEmailing\Types;
 
-abstract class DatesImmutable
+abstract class DatesImmutable implements ExtractableTypeInterface
 {
 
 	/**
@@ -21,14 +21,14 @@ final public static function from(
 
 	/**
 	 * @param mixed $value
-	 * @param bool $getNullIfInvalid
+	 * @param bool $nullIfInvalid
 	 * @return \DateTimeImmutable
 	 */
 	public static function fromOrNull(
 		$value,
-		bool $getNullIfInvalid = false
+		bool $nullIfInvalid = false
 	): ?\DateTimeImmutable {
-		$dateTime = Dates::fromOrNull($value, $getNullIfInvalid);
+		$dateTime = Dates::fromOrNull($value, $nullIfInvalid);
 
 		if ($dateTime === null) {
 			return null;
@@ -44,7 +44,7 @@ public static function fromOrNull(
 	 * @throws \SmartEmailing\Types\InvalidTypeException
 	 */
 	final public static function extract(
-		array &$data,
+		array $data,
 		string $key
 	): \DateTimeImmutable {
 		$dateTime = Dates::extract(
@@ -58,18 +58,18 @@ final public static function extract(
 	/**
 	 * @param array<mixed> $data
 	 * @param string $key
-	 * @param bool $getNullIfInvalid
+	 * @param bool $nullIfInvalid
 	 * @return \DateTimeImmutable
 	 */
 	final public static function extractOrNull(
-		array &$data,
+		array $data,
 		string $key,
-		bool $getNullIfInvalid = false
+		bool $nullIfInvalid = false
 	): ?\DateTimeImmutable {
 		$dateTime = Dates::extractOrNull(
 			$data,
 			$key,
-			$getNullIfInvalid
+			$nullIfInvalid
 		);
 
 		if ($dateTime === null) {
diff --git a/src/Duration.php b/src/Duration.php
index 11f9385..1b883b6 100644
--- a/src/Duration.php
+++ b/src/Duration.php
@@ -33,7 +33,7 @@ final class Duration implements ToStringInterface, ToArrayInterface
 	private function __construct(
 		array $data
 	) {
-		$this->value = PrimitiveTypes::extractInt($data, 'value');
+		$this->value = IntType::extract($data, 'value');
 		$this->unit = TimeUnit::extract($data, 'unit');
 
 		$now = new \DateTimeImmutable('now', new \DateTimeZone('UTC'));
@@ -53,13 +53,13 @@ public static function from(
 			return $data;
 		}
 
-		$string = PrimitiveTypes::getStringOrNull($data, true);
+		$string = StringType::fromOrNull($data, true);
 
 		if (\is_string($string)) {
 			return self::fromDateTimeModify($string);
 		}
 
-		$array = Arrays::getArrayOrNull($data, true);
+		$array = Arrays::fromOrNull($data, true);
 
 		if (\is_array($array)) {
 			return new self($data);
@@ -78,7 +78,7 @@ public static function fromDateTimeModify(
 			throw new InvalidTypeException('Duration: ' . $dateTimeModify . '  is not in valid duration format.');
 		}
 
-		$value = PrimitiveTypes::extractInt($matches, '2');
+		$value = IntType::extract($matches, '2');
 		$unit = TimeUnit::extract($matches, '3');
 
 		if ($matches[1] === '-') {
diff --git a/src/ExtractableTraits/ArrayExtractableTrait.php b/src/ExtractableTraits/ArrayExtractableTrait.php
index 02fd373..11829b5 100644
--- a/src/ExtractableTraits/ArrayExtractableTrait.php
+++ b/src/ExtractableTraits/ArrayExtractableTrait.php
@@ -20,7 +20,7 @@ abstract public function __construct(
 
 	/**
 	 * @param string|mixed|array<mixed> $data
-	 * @return self
+	 * @return static
 	 */
 	final public static function from(
 		$data
@@ -29,7 +29,7 @@ final public static function from(
 			return $data;
 		}
 
-		$data = Arrays::getArray($data);
+		$data = Arrays::from($data);
 
 		return new static($data);
 	}
diff --git a/src/ExtractableTraits/EnumExtractableTrait.php b/src/ExtractableTraits/EnumExtractableTrait.php
index e68c853..d1f31b5 100644
--- a/src/ExtractableTraits/EnumExtractableTrait.php
+++ b/src/ExtractableTraits/EnumExtractableTrait.php
@@ -4,26 +4,14 @@
 
 namespace SmartEmailing\Types\ExtractableTraits;
 
-use Consistence\Enum\Enum;
-
 trait EnumExtractableTrait
 {
 
 	use ExtractableTrait;
 
-	/**
-	 * @param mixed $value
-	 * @return \Consistence\Enum\Enum
-	 * @phpcsSuppress SlevomatCodingStandard.TypeHints.TypeHintDeclaration.MissingReturnTypeHint
-	 */
-	abstract public static function get(
-		$value
-	): Enum;
-
 	/**
 	 * @param mixed $data
-	 * @phpcsSuppress SlevomatCodingStandard.TypeHints.TypeHintDeclaration.MissingReturnTypeHint
-	 * @return self
+	 * @return static
 	 */
 	final public static function from(
 		$data
@@ -33,6 +21,6 @@ final public static function from(
 		}
 
 		return self::get($data);
-	}/** @noinspection ReturnTypeCanBeDeclaredInspection */
+	}
 
 }
diff --git a/src/ExtractableTraits/ExtractableTrait.php b/src/ExtractableTraits/ExtractableTrait.php
index a3d62a9..fd5b69e 100644
--- a/src/ExtractableTraits/ExtractableTrait.php
+++ b/src/ExtractableTraits/ExtractableTrait.php
@@ -14,7 +14,7 @@ trait ExtractableTrait
 
 	/**
 	 * @param string|mixed|array<mixed> $data
-	 * @return self
+	 * @return static
 	 */
 	abstract public static function from(
 		$data
@@ -23,7 +23,7 @@ abstract public static function from(
 	/**
 	 * @param mixed|array<mixed> $data
 	 * @param string $key
-	 * @return self
+	 * @return static
 	 * @throws \SmartEmailing\Types\InvalidTypeException
 	 */
 	public static function extract(
@@ -47,7 +47,7 @@ public static function extract(
 	/**
 	 * @param mixed $value
 	 * @param bool $getNullIfInvalid
-	 * @return self|null
+	 * @return static|null
 	 * @throws \SmartEmailing\Types\InvalidTypeException
 	 */
 	public static function fromOrNull(
@@ -74,7 +74,7 @@ public static function fromOrNull(
 	 * @param mixed|array<mixed> $data
 	 * @param string $key
 	 * @param bool $nullIfInvalid
-	 * @return self|null
+	 * @return static|null
 	 * @throws \SmartEmailing\Types\InvalidTypeException
 	 */
 	public static function extractOrNull(
@@ -105,7 +105,7 @@ public static function extractOrNull(
 	/**
 	 * @param array<mixed> $data
 	 * @param string $key
-	 * @return array<self>
+	 * @return array<static>
 	 * @throws \SmartEmailing\Types\InvalidTypeException
 	 */
 	public static function extractArrayOf(
@@ -113,7 +113,7 @@ public static function extractArrayOf(
 		string $key
 	): array
 	{
-		$typedArray = Arrays::extractArray($data, $key);
+		$typedArray = Arrays::extract($data, $key);
 
 		try {
 			return self::getArrayOf($typedArray);
@@ -125,7 +125,7 @@ public static function extractArrayOf(
 	/**
 	 * @param array<mixed> $data
 	 * @param string $key
-	 * @return array<self>
+	 * @return array<static>
 	 * @throws \SmartEmailing\Types\InvalidTypeException
 	 */
 	public static function extractArrayOfOrEmpty(
@@ -142,7 +142,7 @@ public static function extractArrayOfOrEmpty(
 
 	/**
 	 * @param array<mixed> $array
-	 * @return array<self>
+	 * @return array<static>
 	 */
 	public static function getArrayOf(
 		array $array
@@ -165,7 +165,7 @@ public static function getArrayOf(
 
 	/**
 	 * @param array<mixed> $array
-	 * @return array<self>
+	 * @return array<static>
 	 */
 	public static function getArrayOfSkipInvalid(
 		array $array
@@ -191,14 +191,14 @@ public static function getArrayOfSkipInvalid(
 	/**
 	 * @param array<mixed> $data
 	 * @param string $key
-	 * @return array<self>
+	 * @return array<static>
 	 */
 	public static function extractArrayOfSkipInvalid(
 		array $data,
 		string $key
 	): array
 	{
-		$typedArray = Arrays::extractArray($data, $key);
+		$typedArray = Arrays::extract($data, $key);
 
 		return self::getArrayOfSkipInvalid($typedArray);
 	}
@@ -207,7 +207,7 @@ public static function extractArrayOfSkipInvalid(
 	 * @param mixed|array<mixed> $data
 	 * @param string $key
 	 * @param bool $nullIfInvalid
-	 * @return self|null
+	 * @return static|null
 	 * @throws \SmartEmailing\Types\InvalidTypeException
 	 */
 	private static function tryToExtract(
diff --git a/src/ExtractableTraits/FloatExtractableTrait.php b/src/ExtractableTraits/FloatExtractableTrait.php
index 6730786..f7f4a23 100644
--- a/src/ExtractableTraits/FloatExtractableTrait.php
+++ b/src/ExtractableTraits/FloatExtractableTrait.php
@@ -4,7 +4,7 @@
 
 namespace SmartEmailing\Types\ExtractableTraits;
 
-use SmartEmailing\Types\PrimitiveTypes;
+use SmartEmailing\Types\FloatType;
 
 trait FloatExtractableTrait
 {
@@ -17,7 +17,7 @@ abstract public function __construct(
 
 	/**
 	 * @param string|mixed|array<mixed> $data
-	 * @return self
+	 * @return static
 	 */
 	final public static function from(
 		$data
@@ -26,7 +26,7 @@ final public static function from(
 			return $data;
 		}
 
-		$data = PrimitiveTypes::getFloat($data);
+		$data = FloatType::from($data);
 
 		return new static($data);
 	}
diff --git a/src/ExtractableTraits/IntExtractableTrait.php b/src/ExtractableTraits/IntExtractableTrait.php
index 7f0b3d2..ee8d878 100644
--- a/src/ExtractableTraits/IntExtractableTrait.php
+++ b/src/ExtractableTraits/IntExtractableTrait.php
@@ -4,7 +4,7 @@
 
 namespace SmartEmailing\Types\ExtractableTraits;
 
-use SmartEmailing\Types\PrimitiveTypes;
+use SmartEmailing\Types\IntType;
 
 trait IntExtractableTrait
 {
@@ -17,7 +17,7 @@ abstract public function __construct(
 
 	/**
 	 * @param string|mixed|array<mixed> $data
-	 * @return self
+	 * @return static
 	 */
 	final public static function from(
 		$data
@@ -26,7 +26,7 @@ final public static function from(
 			return $data;
 		}
 
-		$data = PrimitiveTypes::getInt($data);
+		$data = IntType::from($data);
 
 		return new static($data);
 	}
diff --git a/src/ExtractableTraits/StringExtractableTrait.php b/src/ExtractableTraits/StringExtractableTrait.php
index e14f5a6..e462e2a 100644
--- a/src/ExtractableTraits/StringExtractableTrait.php
+++ b/src/ExtractableTraits/StringExtractableTrait.php
@@ -4,7 +4,7 @@
 
 namespace SmartEmailing\Types\ExtractableTraits;
 
-use SmartEmailing\Types\PrimitiveTypes;
+use SmartEmailing\Types\StringType;
 
 trait StringExtractableTrait
 {
@@ -17,7 +17,7 @@ abstract public function __construct(
 
 	/**
 	 * @param string|mixed|array<mixed> $data
-	 * @return self
+	 * @return static
 	 */
 	final public static function from(
 		$data
@@ -26,7 +26,7 @@ final public static function from(
 			return $data;
 		}
 
-		$data = PrimitiveTypes::getString($data);
+		$data = StringType::from($data);
 
 		return new static($data);
 	}
diff --git a/src/ExtractableTypeInterface.php b/src/ExtractableTypeInterface.php
new file mode 100644
index 0000000..0ffd54f
--- /dev/null
+++ b/src/ExtractableTypeInterface.php
@@ -0,0 +1,50 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace SmartEmailing\Types;
+
+interface ExtractableTypeInterface
+{
+
+	/**
+	 * @param mixed $value
+	 * @return mixed
+	 */
+	public static function from(
+		$value
+	);
+
+	/**
+	 * @param mixed $value
+	 * @param bool $nullIfInvalid
+	 * @return mixed
+	 */
+	public static function fromOrNull(
+		$value,
+		bool $nullIfInvalid
+	);
+
+	/**
+	 * @param array<mixed> $data
+	 * @param string $key
+	 * @return mixed
+	 */
+	public static function extract(
+		array $data,
+		string $key
+	);
+
+	/**
+	 * @param array<mixed> $data
+	 * @param string $key
+	 * @param bool $nullIfInvalid
+	 * @return mixed
+	 */
+	public static function extractOrNull(
+		array $data,
+		string $key,
+		bool $nullIfInvalid
+	);
+
+}
diff --git a/src/FloatArray.php b/src/FloatArray.php
new file mode 100644
index 0000000..8329743
--- /dev/null
+++ b/src/FloatArray.php
@@ -0,0 +1,102 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace SmartEmailing\Types;
+
+abstract class FloatArray implements ExtractableTypeInterface
+{
+
+	/**
+	 * @param mixed $value
+	 * @return array<float>
+	 */
+	final public static function from(
+		$value
+	): array {
+		$array = Arrays::from($value);
+
+		$return = [];
+
+		foreach ($array as $index => $item) {
+			$return[$index] = FloatType::from($item);
+		}
+
+		return $return;
+	}
+
+	/**
+	 * @param mixed $value
+	 * @param bool $nullIfInvalid
+	 * @return array<float>|null
+	 */
+	final public static function fromOrNull(
+		$value,
+		bool $nullIfInvalid = false
+	): ?array {
+		$array = Arrays::fromOrNull($value, $nullIfInvalid);
+
+		if ($array === null) {
+			return null;
+		}
+
+		$return = [];
+
+		try {
+			foreach ($array as $index => $item) {
+				$return[$index] = FloatType::from($item);
+			}
+		} catch (InvalidTypeException $e) {
+			if ($nullIfInvalid) {
+				return null;
+			}
+
+			throw $e;
+		}
+
+		return $return;
+	}
+
+	/**
+	 * @param array<mixed> $data
+	 * @param string $key
+	 * @return array<float>
+	 * @throws \SmartEmailing\Types\InvalidTypeException
+	 */
+	final public static function extract(
+		array $data,
+		string $key
+	): array {
+		$array = Arrays::extract($data, $key);
+
+		try {
+			$array = self::from($array);
+		} catch (InvalidTypeException $e) {
+			throw $e->wrap($key);
+		}
+
+		return $array;
+	}
+
+	/**
+	 * @param array<mixed> $data
+	 * @param string $key
+	 * @param bool $nullIfInvalid
+	 * @return array<float>|null
+	 * @throws \SmartEmailing\Types\InvalidTypeException
+	 */
+	final public static function extractOrNull(
+		array $data,
+		string $key,
+		bool $nullIfInvalid = false
+	): ?array {
+		$array = Arrays::extractOrNull($data, $key, $nullIfInvalid);
+
+		if ($array === null) {
+			return null;
+		}
+
+		return self::fromOrNull($array, $nullIfInvalid);
+	}
+
+}
diff --git a/src/FloatType.php b/src/FloatType.php
new file mode 100644
index 0000000..96e2875
--- /dev/null
+++ b/src/FloatType.php
@@ -0,0 +1,104 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace SmartEmailing\Types;
+
+use SmartEmailing\Types\Helpers\ExtractableHelpers;
+
+abstract class FloatType implements ExtractableTypeInterface
+{
+
+	/**
+	 * @param mixed $value
+	 * @return float
+	 */
+	final public static function from(
+		$value
+	): float {
+		if (\is_string($value)) {
+			$value = \strtr(
+				$value,
+				[
+					',' => '.',
+				]
+			);
+		}
+
+		if (\is_numeric($value)) {
+			return (float) $value;
+		}
+
+		throw InvalidTypeException::typeError('float', $value);
+	}
+
+	/**
+	 * @param mixed $value
+	 * @param bool $nullIfInvalid
+	 * @return float|null
+	 */
+	final public static function fromOrNull(
+		$value,
+		bool $nullIfInvalid = false
+	): ?float {
+		if ($value === null) {
+			return null;
+		}
+
+		try {
+			return self::from($value);
+		} catch (InvalidTypeException $e) {
+			if ($nullIfInvalid) {
+				return null;
+			}
+
+			throw $e;
+		}
+	}
+
+	/**
+	 * @param array<mixed> $data
+	 * @param string $key
+	 * @return float
+	 */
+	final public static function extract(
+		array $data,
+		string $key
+	): float {
+		$value = ExtractableHelpers::extractValue($data, $key);
+
+		try {
+			return self::from($value);
+		} catch (InvalidTypeException $e) {
+			throw $e->wrap($key);
+		}
+	}
+
+	/**
+	 * @param array<float> $data
+	 * @param string $key
+	 * @param bool $nullIfInvalid
+	 * @return float
+	 * @throws \SmartEmailing\Types\InvalidTypeException
+	 */
+	final public static function extractOrNull(
+		array $data,
+		string $key,
+		bool $nullIfInvalid = false
+	): ?float {
+		if (!isset($data[$key])) {
+			return null;
+		}
+
+		try {
+			return self::extract($data, $key);
+		} catch (InvalidTypeException $e) {
+			if ($nullIfInvalid) {
+				return null;
+			}
+
+			throw $e;
+		}
+	}
+
+}
diff --git a/src/IntArray.php b/src/IntArray.php
new file mode 100644
index 0000000..d8e8810
--- /dev/null
+++ b/src/IntArray.php
@@ -0,0 +1,102 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace SmartEmailing\Types;
+
+abstract class IntArray implements ExtractableTypeInterface
+{
+
+	/**
+	 * @param mixed $value
+	 * @return array<int>
+	 */
+	final public static function from(
+		$value
+	): array {
+		$array = Arrays::from($value);
+
+		$return = [];
+
+		foreach ($array as $index => $item) {
+			$return[$index] = IntType::from($item);
+		}
+
+		return $return;
+	}
+
+	/**
+	 * @param mixed $value
+	 * @param bool $nullIfInvalid
+	 * @return array<int>|null
+	 */
+	final public static function fromOrNull(
+		$value,
+		bool $nullIfInvalid = false
+	): ?array {
+		$array = Arrays::fromOrNull($value, $nullIfInvalid);
+
+		if ($array === null) {
+			return null;
+		}
+
+		$return = [];
+
+		try {
+			foreach ($array as $index => $item) {
+				$return[$index] = IntType::from($item);
+			}
+		} catch (InvalidTypeException $e) {
+			if ($nullIfInvalid) {
+				return null;
+			}
+
+			throw $e;
+		}
+
+		return $return;
+	}
+
+	/**
+	 * @param array<mixed> $data
+	 * @param string $key
+	 * @return array<int>
+	 * @throws \SmartEmailing\Types\InvalidTypeException
+	 */
+	final public static function extract(
+		array $data,
+		string $key
+	): array {
+		$array = Arrays::extract($data, $key);
+
+		try {
+			$array = self::from($array);
+		} catch (InvalidTypeException $e) {
+			throw $e->wrap($key);
+		}
+
+		return $array;
+	}
+
+	/**
+	 * @param array<mixed> $data
+	 * @param string $key
+	 * @param bool $nullIfInvalid
+	 * @return array<int>|null
+	 * @throws \SmartEmailing\Types\InvalidTypeException
+	 */
+	final public static function extractOrNull(
+		array $data,
+		string $key,
+		bool $nullIfInvalid = false
+	): ?array {
+		$array = Arrays::extractOrNull($data, $key, $nullIfInvalid);
+
+		if ($array === null) {
+			return null;
+		}
+
+		return self::fromOrNull($array, $nullIfInvalid);
+	}
+
+}
diff --git a/src/IntType.php b/src/IntType.php
new file mode 100644
index 0000000..fb270df
--- /dev/null
+++ b/src/IntType.php
@@ -0,0 +1,97 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace SmartEmailing\Types;
+
+use Nette\Utils\Validators;
+use SmartEmailing\Types\Helpers\ExtractableHelpers;
+
+abstract class IntType implements ExtractableTypeInterface
+{
+
+	/**
+	 * @param mixed $value
+	 * @return int
+	 */
+	final public static function from(
+		$value
+	): int {
+		if (Validators::isNumericInt($value)) {
+			return (int) $value;
+		}
+
+		throw InvalidTypeException::typeError('int', $value);
+	}
+
+	/**
+	 * @param mixed $value
+	 * @param bool $nullIfInvalid
+	 * @return int|null
+	 */
+	final public static function fromOrNull(
+		$value,
+		bool $nullIfInvalid = false
+	): ?int {
+		if ($value === null) {
+			return null;
+		}
+
+		try {
+			return self::from($value);
+		} catch (InvalidTypeException $e) {
+			if ($nullIfInvalid) {
+				return null;
+			}
+
+			throw $e;
+		}
+	}
+
+	/**
+	 * @param array<mixed> $data
+	 * @param string $key
+	 * @return int
+	 * @throws \SmartEmailing\Types\InvalidTypeException
+	 */
+	final public static function extract(
+		array $data,
+		string $key
+	): int {
+		$value = ExtractableHelpers::extractValue($data, $key);
+
+		try {
+			return self::from($value);
+		} catch (InvalidTypeException $e) {
+			throw $e->wrap($key);
+		}
+	}
+
+	/**
+	 * @param array<mixed> $data
+	 * @param string $key
+	 * @param bool $nullIfInvalid
+	 * @return int
+	 * @throws \SmartEmailing\Types\InvalidTypeException
+	 */
+	final public static function extractOrNull(
+		array $data,
+		string $key,
+		bool $nullIfInvalid = false
+	): ?int {
+		if (!isset($data[$key])) {
+			return null;
+		}
+
+		try {
+			return self::extract($data, $key);
+		} catch (InvalidTypeException $e) {
+			if ($nullIfInvalid) {
+				return null;
+			}
+
+			throw $e;
+		}
+	}
+
+}
diff --git a/src/JsonString.php b/src/JsonString.php
index 1e3364d..d719e32 100644
--- a/src/JsonString.php
+++ b/src/JsonString.php
@@ -43,13 +43,13 @@ public static function from(
 			return $data;
 		}
 
-		$string = PrimitiveTypes::getStringOrNull($data, true);
+		$string = StringType::fromOrNull($data, true);
 
 		if (\is_string($string)) {
 			return new static($string);
 		}
 
-		$array = Arrays::getArrayOrNull($data, true);
+		$array = Arrays::fromOrNull($data, true);
 
 		if (\is_array($array)) {
 			return self::encode($data);
diff --git a/src/KeyValuePair.php b/src/KeyValuePair.php
index 1c615d0..75b9463 100644
--- a/src/KeyValuePair.php
+++ b/src/KeyValuePair.php
@@ -27,8 +27,8 @@ final class KeyValuePair implements ToArrayInterface
 	private function __construct(
 		array $data
 	) {
-		$this->key = PrimitiveTypes::extractString($data, 'key');
-		$this->value = PrimitiveTypes::extractString($data, 'value');
+		$this->key = StringType::extract($data, 'key');
+		$this->value = StringType::extract($data, 'value');
 	}
 
 	public function getKey(): string
diff --git a/src/LoginCredentials.php b/src/LoginCredentials.php
index d2e2a86..48f5d1a 100644
--- a/src/LoginCredentials.php
+++ b/src/LoginCredentials.php
@@ -27,8 +27,8 @@ final class LoginCredentials
 	private function __construct(
 		array $data
 	) {
-		$this->login = PrimitiveTypes::extractString($data, 'login');
-		$this->password = PrimitiveTypes::extractString($data, 'password');
+		$this->login = StringType::extract($data, 'login');
+		$this->password = StringType::extract($data, 'password');
 	}
 
 	public function getLogin(): string
diff --git a/src/Price.php b/src/Price.php
index c751313..8f36da1 100644
--- a/src/Price.php
+++ b/src/Price.php
@@ -33,8 +33,8 @@ private function __construct(
 		array $data
 	)
 	{
-		$this->withoutVat = PrimitiveTypes::extractFloat($data, 'without_vat');
-		$this->withVat = PrimitiveTypes::extractFloat($data, 'with_vat');
+		$this->withoutVat = FloatType::extract($data, 'without_vat');
+		$this->withVat = FloatType::extract($data, 'with_vat');
 		$this->currency = CurrencyCode::extract($data, 'currency');
 	}
 
diff --git a/src/PrimitiveTypes.php b/src/PrimitiveTypes.php
index 29e3388..b1547f7 100644
--- a/src/PrimitiveTypes.php
+++ b/src/PrimitiveTypes.php
@@ -4,49 +4,34 @@
 
 namespace SmartEmailing\Types;
 
-use Nette\Utils\Strings;
-use Nette\Utils\Validators;
-use SmartEmailing\Types\Helpers\ExtractableHelpers;
-
+/**
+ * @deprecated use StringType, IntType, FloatType, BoolType, StringArray, IntArray, FloatArray, BoolArray instead
+ */
 abstract class PrimitiveTypes
 {
 
 	/**
 	 * @param mixed $value
 	 * @return int
+	 * @deprecated use IntType::from
 	 */
 	final public static function getInt(
 		$value
 	): int {
-		if (Validators::isNumericInt($value)) {
-			return (int) $value;
-		}
-
-		throw InvalidTypeException::typeError('int', $value);
+		return IntType::from($value);
 	}
 
 	/**
 	 * @param mixed $value
 	 * @param bool $nullIfInvalid
 	 * @return int|null
+	 * @deprecated use IntType::fromOrNull
 	 */
 	final public static function getIntOrNull(
 		$value,
 		bool $nullIfInvalid = false
 	): ?int {
-		if ($value === null) {
-			return null;
-		}
-
-		try {
-			return self::getInt($value);
-		} catch (InvalidTypeException $e) {
-			if ($nullIfInvalid) {
-				return null;
-			}
-
-			throw $e;
-		}
+		return IntType::fromOrNull($value, $nullIfInvalid);
 	}
 
 	/**
@@ -54,83 +39,66 @@ final public static function getIntOrNull(
 	 * @param string $key
 	 * @return int
 	 * @throws \SmartEmailing\Types\InvalidTypeException
+	 * @deprecated use IntType::extract
 	 */
 	final public static function extractInt(
 		array $data,
 		string $key
 	): int {
-		$value = ExtractableHelpers::extractValue($data, $key);
+		return IntType::extract($data, $key);
+	}
 
-		try {
-			return self::getInt($value);
-		} catch (InvalidTypeException $e) {
-			throw $e->wrap($key);
-		}
+	/**
+	 * @param array<mixed> $data
+	 * @param string $key
+	 * @param bool $nullIfInvalid
+	 * @return int
+	 * @throws \SmartEmailing\Types\InvalidTypeException
+	 * @deprecated use IntType::extractOrNull
+	 */
+	final public static function extractIntOrNull(
+		array $data,
+		string $key,
+		bool $nullIfInvalid = false
+	): ?int {
+		return IntType::extractOrNull($data, $key, $nullIfInvalid);
 	}
 
 	/**
 	 * @param mixed $value
 	 * @return float
+	 * @deprecated use FloatType::from
 	 */
 	final public static function getFloat(
 		$value
 	): float {
-		if (\is_string($value)) {
-			$value = \strtr(
-				$value,
-				[
-					',' => '.',
-				]
-			);
-		}
-
-		if (\is_numeric($value)) {
-			return (float) $value;
-		}
-
-		throw InvalidTypeException::typeError('float', $value);
+		return FloatType::from($value);
 	}
 
 	/**
 	 * @param mixed $value
 	 * @param bool $nullIfInvalid
 	 * @return float|null
+	 * @deprecated use FloatType::fromOrNull
 	 */
 	final public static function getFloatOrNull(
 		$value,
 		bool $nullIfInvalid = false
 	): ?float {
-		if ($value === null) {
-			return null;
-		}
-
-		try {
-			return self::getFloat($value);
-		} catch (InvalidTypeException $e) {
-			if ($nullIfInvalid) {
-				return null;
-			}
-
-			throw $e;
-		}
+		return FloatType::fromOrNull($value, $nullIfInvalid);
 	}
 
 	/**
 	 * @param array<mixed> $data
 	 * @param string $key
 	 * @return float
+	 * @deprecated use FloatType::extract
 	 */
 	final public static function extractFloat(
 		array $data,
 		string $key
 	): float {
-		$value = ExtractableHelpers::extractValue($data, $key);
-
-		try {
-			return self::getFloat($value);
-		} catch (InvalidTypeException $e) {
-			throw $e->wrap($key);
-		}
+		return FloatType::extract($data, $key);
 	}
 
 	/**
@@ -139,147 +107,38 @@ final public static function extractFloat(
 	 * @param bool $nullIfInvalid
 	 * @return float
 	 * @throws \SmartEmailing\Types\InvalidTypeException
+	 * @deprecated use FloatType::extractOrNull
 	 */
 	final public static function extractFloatOrNull(
 		array $data,
 		string $key,
 		bool $nullIfInvalid = false
 	): ?float {
-		if (!isset($data[$key])) {
-			return null;
-		}
-
-		try {
-			return self::extractFloat($data, $key);
-		} catch (InvalidTypeException $e) {
-			if ($nullIfInvalid) {
-				return null;
-			}
-
-			throw $e;
-		}
-	}
-
-	/**
-	 * @param array<mixed> $data
-	 * @param string $key
-	 * @param bool $nullIfInvalid
-	 * @return int
-	 * @throws \SmartEmailing\Types\InvalidTypeException
-	 */
-	final public static function extractIntOrNull(
-		array $data,
-		string $key,
-		bool $nullIfInvalid = false
-	): ?int {
-		if (!isset($data[$key])) {
-			return null;
-		}
-
-		try {
-			return self::extractInt($data, $key);
-		} catch (InvalidTypeException $e) {
-			if ($nullIfInvalid) {
-				return null;
-			}
-
-			throw $e;
-		}
-	}
-
-	/**
-	 * @param array<mixed> $data
-	 * @param string $key
-	 * @param bool $nullIfInvalid
-	 * @return bool|null
-	 * @throws \SmartEmailing\Types\InvalidTypeException
-	 */
-	final public static function extractBoolOrNull(
-		array $data,
-		string $key,
-		bool $nullIfInvalid = false
-	): ?bool {
-		if (!isset($data[$key])) {
-			return null;
-		}
-
-		try {
-			return self::extractBool($data, $key);
-		} catch (InvalidTypeException $e) {
-			if ($nullIfInvalid) {
-				return null;
-			}
-
-			throw $e;
-		}
-	}
-
-	/**
-	 * @param array<mixed> $data
-	 * @param string $key
-	 * @param bool $nullIfInvalid
-	 * @return string|null
-	 * @throws \SmartEmailing\Types\InvalidTypeException
-	 */
-	final public static function extractStringOrNull(
-		array $data,
-		string $key,
-		bool $nullIfInvalid = false
-	): ?string {
-		if (
-			!isset($data[$key])
-			|| $data[$key] === ''
-		) {
-			return null;
-		}
-
-		try {
-			return self::extractString($data, $key);
-		} catch (InvalidTypeException $e) {
-			if ($nullIfInvalid) {
-				return null;
-			}
-
-			throw $e;
-		}
+		return FloatType::extractOrNull($data, $key, $nullIfInvalid);
 	}
 
 	/**
 	 * @param mixed $value
 	 * @return string
+	 * @deprecated use StringType::from
 	 */
 	final public static function getString(
 		$value
 	): string {
-		if (\is_scalar($value)) {
-			return (string) $value;
-		}
-
-		throw InvalidTypeException::typeError('string', $value);
+		return StringType::from($value);
 	}
 
 	/**
 	 * @param mixed $value
 	 * @param bool $nullIfInvalid
 	 * @return string|null
+	 * @deprecated use StringType::fromOrNull
 	 */
 	final public static function getStringOrNull(
 		$value,
 		bool $nullIfInvalid = false
 	): ?string {
-		if ($value === null) {
-			return null;
-		}
-
-		try {
-			return self::getString($value);
-		} catch (InvalidTypeException $e) {
-			if ($nullIfInvalid) {
-				return null;
-			}
-
-			throw $e;
-		}
+		return StringType::fromOrNull($value, $nullIfInvalid);
 	}
 
 	/**
@@ -287,79 +146,53 @@ final public static function getStringOrNull(
 	 * @param string $key
 	 * @return string
 	 * @throws \SmartEmailing\Types\InvalidTypeException
+	 * @deprecated use StringType::extract
 	 */
 	final public static function extractString(
 		array $data,
 		string $key
 	): string {
-		$value = ExtractableHelpers::extractValue($data, $key);
+		return StringType::extract($data, $key);
+	}
 
-		try {
-			return self::getString($value);
-		} catch (InvalidTypeException $e) {
-			throw $e->wrap($key);
-		}
+	/**
+	 * @param array<mixed> $data
+	 * @param string $key
+	 * @param bool $nullIfInvalid
+	 * @return string|null
+	 * @throws \SmartEmailing\Types\InvalidTypeException
+	 * @deprecated use StringType::extractOrNull
+	 */
+	final public static function extractStringOrNull(
+		array $data,
+		string $key,
+		bool $nullIfInvalid = false
+	): ?string {
+		return StringType::extractOrNull($data, $key, $nullIfInvalid);
 	}
 
 	/**
 	 * @param mixed $value
 	 * @return bool
+	 * @deprecated use BoolType::from
 	 */
 	final public static function getBool(
 		$value
 	): bool {
-		if (\is_bool($value)) {
-			return $value;
-		}
-
-		if (\is_string($value)) {
-			$value = Strings::lower($value);
-		}
-
-		if (\in_array($value, [false, 0, '0', 'false'], true)) {
-			return false;
-		}
-
-		if (\in_array($value, [true, 1, '1', 'true'], true)) {
-			return true;
-		}
-
-		throw InvalidTypeException::typeError('bool', $value);
+		return BoolType::from($value);
 	}
 
 	/**
 	 * @param mixed $value
 	 * @param bool $nullIfInvalid
 	 * @return bool|null
+	 * @deprecated use BoolType::fromOrNull
 	 */
 	final public static function getBoolOrNull(
 		$value,
 		bool $nullIfInvalid = false
 	): ?bool {
-		if ($value === null) {
-			return null;
-		}
-
-		try {
-			return self::getBool($value);
-		} catch (InvalidTypeException $e) {
-			if ($nullIfInvalid) {
-				return null;
-			}
-
-			throw $e;
-		}
-	}
-
-	/**
-	 * @param mixed $value
-	 * @return array<mixed>
-	 * @deprecated use Arrays::getArray instead
-	 */
-	final public static function getArray(
-		$value
-	): array {
-		return Arrays::getArray($value);
+		return BoolType::fromOrNull($value, $nullIfInvalid);
 	}
 
 	/**
@@ -367,52 +200,40 @@ final public static function getArray(
 	 * @param string $key
 	 * @return bool
 	 * @throws \SmartEmailing\Types\InvalidTypeException
+	 * @deprecated use BoolType::extract
 	 */
 	final public static function extractBool(
 		array $data,
 		string $key
 	): bool {
-		$value = ExtractableHelpers::extractValue($data, $key);
-
-		try {
-			return self::getBool($value);
-		} catch (InvalidTypeException $e) {
-			throw $e->wrap($key);
-		}
+		return BoolType::extract($data, $key);
 	}
 
 	/**
 	 * @param array<mixed> $data
 	 * @param string $key
-	 * @return array<string>
+	 * @param bool $nullIfInvalid
+	 * @return bool|null
 	 * @throws \SmartEmailing\Types\InvalidTypeException
-	 * @deprecated use Arrays::extractStringArray
+	 * @deprecated use BoolType::extractOrNull
 	 */
-	final public static function extractStringArray(
+	final public static function extractBoolOrNull(
 		array $data,
-		string $key
-	): array {
-		return Arrays::extractStringArray(
-			$data,
-			$key
-		);
+		string $key,
+		bool $nullIfInvalid = false
+	): ?bool {
+		return BoolType::extractOrNull($data, $key, $nullIfInvalid);
 	}
 
 	/**
-	 * @param array<mixed> $data
-	 * @param string $key
-	 * @return array<int>
-	 * @throws \SmartEmailing\Types\InvalidTypeException
-	 * @deprecated use Arrays::extractIntArray
+	 * @param mixed $value
+	 * @return array<mixed>
+	 * @deprecated use Arrays::from instead
 	 */
-	final public static function extractIntArray(
-		array $data,
-		string $key
+	final public static function getArray(
+		$value
 	): array {
-		return Arrays::extractIntArray(
-			$data,
-			$key
-		);
+		return Arrays::from($value);
 	}
 
 	/**
@@ -422,14 +243,14 @@ final public static function extractIntArray(
 	 * @param string $key
 	 * @return array<mixed>
 	 * @throws \SmartEmailing\Types\InvalidTypeException
-	 * @deprecated use Arrays::extractArray
+	 * @deprecated use Arrays::extract
 	 */
 	final public static function extractArray(
 		array &$data,
 		string $key
 	): array
 	{
-		return Arrays::extractArray(
+		return Arrays::extract(
 			$data,
 			$key
 		);
@@ -440,16 +261,53 @@ final public static function extractArray(
 	 *
 	 * @param array<mixed> $data
 	 * @param string $key
+	 * @param bool $nullIfInvalid
 	 * @return array<mixed>|null
 	 * @throws \SmartEmailing\Types\InvalidTypeException
-	 * @deprecated use Arrays::extractArrayOrNull
+	 * @deprecated use Arrays::extractOrNull
 	 */
 	final public static function extractArrayOrNull(
 		array &$data,
-		string $key
+		string $key,
+		bool $nullIfInvalid = false
 	): ?array
 	{
-		return Arrays::extractArrayOrNull(
+		return Arrays::extractOrNull(
+			$data,
+			$key,
+			$nullIfInvalid
+		);
+	}
+
+	/**
+	 * @param array<mixed> $data
+	 * @param string $key
+	 * @return array<string>
+	 * @throws \SmartEmailing\Types\InvalidTypeException
+	 * @deprecated use StringArray::extract
+	 */
+	final public static function extractStringArray(
+		array $data,
+		string $key
+	): array {
+		return StringArray::extract(
+			$data,
+			$key
+		);
+	}
+
+	/**
+	 * @param array<mixed> $data
+	 * @param string $key
+	 * @return array<int>
+	 * @throws \SmartEmailing\Types\InvalidTypeException
+	 * @deprecated use IntArray::extract
+	 */
+	final public static function extractIntArray(
+		array $data,
+		string $key
+	): array {
+		return IntArray::extract(
 			$data,
 			$key
 		);
diff --git a/src/StringArray.php b/src/StringArray.php
new file mode 100644
index 0000000..f6b959d
--- /dev/null
+++ b/src/StringArray.php
@@ -0,0 +1,102 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace SmartEmailing\Types;
+
+abstract class StringArray implements ExtractableTypeInterface
+{
+
+	/**
+	 * @param mixed $value
+	 * @return array<string>
+	 */
+	final public static function from(
+		$value
+	): array {
+		$array = Arrays::from($value);
+
+		$return = [];
+
+		foreach ($array as $index => $item) {
+			$return[$index] = StringType::from($item);
+		}
+
+		return $return;
+	}
+
+	/**
+	 * @param mixed $value
+	 * @param bool $nullIfInvalid
+	 * @return array<string>|null
+	 */
+	final public static function fromOrNull(
+		$value,
+		bool $nullIfInvalid = false
+	): ?array {
+		$array = Arrays::fromOrNull($value, $nullIfInvalid);
+
+		if ($array === null) {
+			return null;
+		}
+
+		$return = [];
+
+		try {
+			foreach ($array as $index => $item) {
+				$return[$index] = StringType::from($item);
+			}
+		} catch (InvalidTypeException $e) {
+			if ($nullIfInvalid) {
+				return null;
+			}
+
+			throw $e;
+		}
+
+		return $return;
+	}
+
+	/**
+	 * @param array<mixed> $data
+	 * @param string $key
+	 * @return array<string>
+	 * @throws \SmartEmailing\Types\InvalidTypeException
+	 */
+	final public static function extract(
+		array $data,
+		string $key
+	): array {
+		$array = Arrays::extract($data, $key);
+
+		try {
+			$array = self::from($array);
+		} catch (InvalidTypeException $e) {
+			throw $e->wrap($key);
+		}
+
+		return $array;
+	}
+
+	/**
+	 * @param array<mixed> $data
+	 * @param string $key
+	 * @param bool $nullIfInvalid
+	 * @return array<string>|null
+	 * @throws \SmartEmailing\Types\InvalidTypeException
+	 */
+	final public static function extractOrNull(
+		array $data,
+		string $key,
+		bool $nullIfInvalid = false
+	): ?array {
+		$array = Arrays::extractOrNull($data, $key, $nullIfInvalid);
+
+		if ($array === null) {
+			return null;
+		}
+
+		return self::fromOrNull($array, $nullIfInvalid);
+	}
+
+}
diff --git a/src/StringType.php b/src/StringType.php
new file mode 100644
index 0000000..c68b229
--- /dev/null
+++ b/src/StringType.php
@@ -0,0 +1,99 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace SmartEmailing\Types;
+
+use SmartEmailing\Types\Helpers\ExtractableHelpers;
+
+abstract class StringType implements ExtractableTypeInterface
+{
+
+	/**
+	 * @param mixed $value
+	 * @return string
+	 */
+	final public static function from(
+		$value
+	): string {
+		if (\is_scalar($value)) {
+			return (string) $value;
+		}
+
+		throw InvalidTypeException::typeError('string', $value);
+	}
+
+	/**
+	 * @param mixed $value
+	 * @param bool $nullIfInvalid
+	 * @return string|null
+	 */
+	final public static function fromOrNull(
+		$value,
+		bool $nullIfInvalid = false
+	): ?string {
+		if ($value === null) {
+			return null;
+		}
+
+		try {
+			return self::from($value);
+		} catch (InvalidTypeException $e) {
+			if ($nullIfInvalid) {
+				return null;
+			}
+
+			throw $e;
+		}
+	}
+
+	/**
+	 * @param array<mixed> $data
+	 * @param string $key
+	 * @return string
+	 * @throws \SmartEmailing\Types\InvalidTypeException
+	 */
+	final public static function extract(
+		array $data,
+		string $key
+	): string {
+		$value = ExtractableHelpers::extractValue($data, $key);
+
+		try {
+			return self::from($value);
+		} catch (InvalidTypeException $e) {
+			throw $e->wrap($key);
+		}
+	}
+
+	/**
+	 * @param array<mixed> $data
+	 * @param string $key
+	 * @param bool $nullIfInvalid
+	 * @return string|null
+	 * @throws \SmartEmailing\Types\InvalidTypeException
+	 */
+	final public static function extractOrNull(
+		array $data,
+		string $key,
+		bool $nullIfInvalid = false
+	): ?string {
+		if (
+			!isset($data[$key])
+			|| $data[$key] === ''
+		) {
+			return null;
+		}
+
+		try {
+			return self::extract($data, $key);
+		} catch (InvalidTypeException $e) {
+			if ($nullIfInvalid) {
+				return null;
+			}
+
+			throw $e;
+		}
+	}
+
+}
diff --git a/src/UniqueIntArray.php b/src/UniqueIntArray.php
index 10f873a..e98569e 100644
--- a/src/UniqueIntArray.php
+++ b/src/UniqueIntArray.php
@@ -31,7 +31,7 @@ private function __construct(
 
 		foreach ($data as $value) {
 			try {
-				$this->add(PrimitiveTypes::getInt($value));
+				$this->add(IntType::from($value));
 			} catch (InvalidTypeException $e) {
 				throw InvalidTypeException::typeError('all members of array to be int', $value);
 			}
diff --git a/src/UniqueStringArray.php b/src/UniqueStringArray.php
index 42ca95f..5d02377 100644
--- a/src/UniqueStringArray.php
+++ b/src/UniqueStringArray.php
@@ -31,7 +31,7 @@ private function __construct(
 
 		foreach ($data as $value) {
 			try {
-				$this->add(PrimitiveTypes::getString($value));
+				$this->add(StringType::from($value));
 			} catch (InvalidTypeException $e) {
 				throw InvalidTypeException::typeError('all members of array to be string', $value);
 			}
diff --git a/tests/BoolArrayTest.php b/tests/BoolArrayTest.php
new file mode 100644
index 0000000..9f1fd72
--- /dev/null
+++ b/tests/BoolArrayTest.php
@@ -0,0 +1,69 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace SmartEmailing\Types;
+
+use Tester\Assert;
+use Tester\TestCase;
+
+require_once __DIR__ . '/bootstrap.php';
+
+final class BoolArrayTest extends TestCase
+{
+
+	public function testGet(): void
+	{
+		Assert::same(
+			[true, false, true, false],
+			BoolArray::from([1, 0, 'true', 'false'])
+		);
+
+		Assert::exception(
+			static function (): void {
+				BoolArray::from([1, 0, 'true', 'not false']);
+			},
+			InvalidTypeException::class
+		);
+	}
+
+	public function testGetOrNull(): void
+	{
+		Assert::same(null, BoolArray::fromOrNull(null));
+
+		Assert::same(null, BoolArray::fromOrNull(['not true'], true));
+
+		Assert::same(
+			[true, false, true, false],
+			BoolArray::fromOrNull([1, 0, 'true', 'false'])
+		);
+
+		Assert::exception(
+			static function (): void {
+				BoolArray::fromOrNull([1, 0, 'true', 'not false']);
+			},
+			InvalidTypeException::class
+		);
+	}
+
+	public function textExtract(): void
+	{
+		Assert::same(
+			[true, false, true, false],
+			BoolArray::extract(['a' => [1, 0, 'true', 'false']], 'a')
+		);
+	}
+
+	public function textExtractOrNull(): void
+	{
+		Assert::null(BoolArray::extractOrNull([], 'a'));
+
+		Assert::same(
+			[true, false, true, false],
+			BoolArray::extractOrNull(['a' => [1, 0, 'true', 'false']], 'a')
+		);
+	}
+
+}
+
+(new BoolArrayTest())->run();