diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..cd59682
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,6 @@
+## ide
+.idea
+
+## composer
+vendor
+composer.lock
diff --git a/bin/.gitignore b/bin/.gitignore
new file mode 100644
index 0000000..007ad75
--- /dev/null
+++ b/bin/.gitignore
@@ -0,0 +1,3 @@
+## composer
+composer.lock
+vendor
diff --git a/bin/composer.json b/bin/composer.json
new file mode 100644
index 0000000..551dc2e
--- /dev/null
+++ b/bin/composer.json
@@ -0,0 +1,8 @@
+{
+    "require": {
+        "php": ">=8.0",
+        "nette/neon": "^3.3",
+        "nette/php-generator": "^3.6",
+        "nette/schema": "^1.2"
+    }
+}
diff --git a/bin/generate.php b/bin/generate.php
new file mode 100644
index 0000000..4cd2fd0
--- /dev/null
+++ b/bin/generate.php
@@ -0,0 +1,269 @@
+<?php declare(strict_types = 1);
+
+use Nette\Neon\Neon;
+use Nette\PhpGenerator\ClassType;
+use Nette\PhpGenerator\Helpers;
+use Nette\PhpGenerator\PhpFile;
+use Nette\PhpGenerator\PhpNamespace;
+use Nette\PhpGenerator\Printer;
+use Nette\Schema\Expect;
+use Nette\Schema\Processor;
+use Nette\Utils\FileSystem;
+use Nette\Utils\Strings;
+use Nette\Utils\Type;
+use Utilitte\Asserts\Exceptions\AssertionFailedException;
+use Utilitte\Asserts\TypeAssert;
+
+require __DIR__ . '/vendor/autoload.php';
+
+class DefaultPrinter extends Printer
+{
+
+	public function __construct()
+	{
+		parent::__construct();
+
+		$this->linesBetweenMethods = 1;
+		$this->linesBetweenProperties = 1;
+	}
+
+	public function printFile(PhpFile $file): string
+	{
+		$namespaces = [];
+		foreach ($file->getNamespaces() as $namespace) {
+			$namespaces[] = $this->printNamespace($namespace);
+		}
+
+		return Strings::normalize(
+				"<?php"
+				. ($file->hasStrictTypes() ? " declare(strict_types = 1);\n" : '')
+				. ($file->getComment() ? "\n" . Helpers::formatDocComment($file->getComment() . "\n") : '')
+				. "\n"
+				. implode("\n\n", $namespaces)
+			) . "\n";
+	}
+
+	public function printClass(ClassType $class, PhpNamespace $namespace = null): string
+	{
+		$lines = explode("\n", parent::printClass($class, $namespace));
+		foreach ($lines as $i => $line) {
+			if (preg_match('#^\s*(final|abstract)?\s*(class|interface|trait)#', $line)) {
+				array_splice($lines, $i + 2, 0, '');
+
+				break;
+			}
+		}
+
+		array_splice($lines, -2, 0, '');
+
+		return implode("\n", $lines);
+	}
+
+}
+
+class TypeAssertionGenerator
+{
+
+	public function __construct(
+		private string $arrayTypeAssertTraitName,
+		private string $typeAssertTraitName,
+		private string $typeAssertClassName,
+		private string $typeAssertionException,
+		private array $types,
+	)
+	{
+	}
+
+	public function runArray(array $types): string
+	{
+		$file = new PhpFile();
+		$file->setStrictTypes();
+		$namespace = $file->addNamespace(Helpers::extractNamespace($this->arrayTypeAssertTraitName));
+		$namespace->addUse($this->typeAssertClassName);
+		$class = $namespace->addTrait(Helpers::extractShortName($this->arrayTypeAssertTraitName));
+		$class->addComment('@internal');
+
+		foreach ($types as $type) {
+			$type = Type::fromString($type);
+
+			if ($type->isIntersection()) {
+				throw new LogicException('Intersection is not supported.');
+			}
+
+			$this->generateArray($type, $class, $namespace);
+		}
+
+		return (new DefaultPrinter())->printFile($file);
+	}
+
+	public function run(array $types): string
+	{
+		$file = new PhpFile();
+		$file->setStrictTypes();
+		$namespace = $file->addNamespace(Helpers::extractNamespace($this->typeAssertTraitName));
+		$namespace->addUse($this->typeAssertionException);
+		$class = $namespace->addTrait(Helpers::extractShortName($this->typeAssertTraitName));
+		$class->addComment('@internal');
+
+		foreach ($types as $type) {
+			$type = Type::fromString($type);
+
+			if ($type->isIntersection()) {
+				throw new LogicException('Intersection is not supported.');
+			}
+
+			$this->generate($type, $class, $namespace);
+		}
+
+		return (new DefaultPrinter())->printFile($file);
+	}
+
+	private function generateArray(Type $type, ClassType $class, PhpNamespace $namespace): void
+	{
+		$method = $class->addMethod($methodName = $this->generateName($type));
+		$method->addParameter('array')
+			->setType('mixed');
+		$method->addParameter('key')
+			->setType('int|string');
+		$method->setReturnType($this->returnType($type))
+			->setStatic();
+
+		$method->addBody(sprintf('return %s::%s(self::get($array, $key));', $namespace->simplifyType($this->typeAssertClassName), $methodName));
+	}
+
+	private function generate(Type $type, ClassType $class, PhpNamespace $namespace): void
+	{
+		$method = $class->addMethod($this->generateName($type));
+		$method->addParameter('value')
+			->setType('mixed');
+		$method->setReturnType($this->returnType($type))
+			->setStatic();
+
+		$expandedType = $this->typeToStringExpanded($type);
+
+		$assertions = [];
+		$epilogs = [];
+		$prologs = [];
+		foreach ($type->getTypes() as $singleType) {
+			$struct = $this->types[$singleType->getSingleName()];
+			$assertions = array_merge($assertions, $struct->assertions);
+			if ($struct->prolog) {
+				$prologs[] = $struct->prolog;
+			}
+			if ($struct->epilog) {
+				$epilogs[] = $struct->epilogs;
+			}
+		}
+
+		if ($prologs) {
+			$method->addBody(implode("\n", $prologs));
+			$method->addBody('');
+		}
+
+		$method->addBody(
+			sprintf('if (%s) {', $this->generateCondition($assertions))
+		);
+		$method->addBody(
+			sprintf(
+				"\tthrow new %s(self::createErrorMessage(\$value, ?));",
+				$namespace->simplifyName($this->typeAssertionException)
+			),
+			[$expandedType]
+		);
+		$method->addBody('}');
+
+		if ($epilogs) {
+			$method->addBody('');
+			$method->addBody(implode("\n", $epilogs));
+		}
+
+		$method->addBody('');
+		$method->addBody('return $value;');
+	}
+
+	private function typeToStringExpanded(Type $type): string
+	{
+		$types = [];
+		foreach ($type->getTypes() as $type) {
+			$types[] = $type->getSingleName();
+		}
+
+		return implode('|', $types);
+	}
+
+	private function generateName(Type $type): string
+	{
+		$methodName = '';
+		foreach ($type->getNames() as $name) {
+			$methodName .= ucfirst($name) . 'Or';
+		}
+
+		return lcfirst(substr($methodName, 0, -2));
+	}
+
+	private function generateCondition(array $validators): string
+	{
+		return implode(' && ', $validators);
+	}
+
+	private function returnType(Type $type): string
+	{
+		$returnType = '';
+		foreach ($type->getTypes() as $type) {
+			if ($type->isBuiltin()) {
+				$returnType .= $type->getSingleName() . '|';
+			} else {
+				$struct = $this->types[$type->getSingleName()] ?? throw new LogicException(
+					sprintf('Return type for type "%s" does not exist.', $type->getSingleName())
+				);
+
+				foreach ($struct->returns as $item) {
+					$returnType .= $item . '|';
+				}
+			}
+		}
+
+		return (string) Type::fromString(substr($returnType, 0, -1));
+	}
+
+}
+
+$types = [
+	'array',
+	'array|null',
+	'object',
+	'object|null',
+	'string',
+	'string|null',
+	'int',
+	'int|null',
+	'float',
+	'float|null',
+	'int|float',
+	'int|float|null',
+	'numeric',
+	'numericInt',
+	'numericInt|null',
+	'numericFloat',
+	'numericFloat|null',
+];
+
+$data = (new Processor())->process(Expect::structure([
+	'types' => Expect::arrayOf(Expect::structure([
+		'assertions' => Expect::anyOf(Expect::string(), Expect::arrayOf('string'))->castTo('array')->default([]),
+		'returns' => Expect::anyOf(Expect::string(), Expect::arrayOf('string'))->castTo('array')->default([]),
+		'prolog' => Expect::string()->default(null),
+		'epilog' => Expect::string()->default(null),
+	])),
+]), Neon::decode(FileSystem::read(__DIR__ . '/methods.neon')));
+
+$generator = new TypeAssertionGenerator(
+	'Utilitte\Asserts\Mixins\ArrayTypeAssertTrait',
+	'Utilitte\Asserts\Mixins\TypeAssertTrait',
+	TypeAssert::class,
+	AssertionFailedException::class,
+	$data->types,
+);
+
+FileSystem::write(__DIR__ . '/../src/Mixins/TypeAssertTrait.php', $generator->run($types));
+FileSystem::write(__DIR__ . '/../src/Mixins/ArrayTypeAssertTrait.php', $generator->runArray($types));
diff --git a/bin/methods.neon b/bin/methods.neon
new file mode 100644
index 0000000..24e43ac
--- /dev/null
+++ b/bin/methods.neon
@@ -0,0 +1,38 @@
+types:
+	int:
+		assertions: '!is_int($value)'
+	float:
+		assertions: '!is_float($value)'
+	array:
+		assertions: '!is_array($value)'
+	object:
+		assertions: '!is_object($value)'
+	string:
+		assertions: '!is_string($value)'
+	null:
+		assertions: '$value !== null'
+
+	numeric:
+		assertions: '!is_float($value) && !is_int($value)'
+		returns: [float, int]
+		prolog: """
+		if (is_string($value) && is_numeric($value)) {
+			$value = str_contains($value, '.') ? (float) $value : (int) $value;
+		}
+		"""
+	numericFloat:
+		assertions: '!is_float($value)'
+		returns: float
+		prolog: """
+		if (is_string($value) && is_numeric($value)) {
+			$value = (float) preg_replace('#\\.0*$#D', '', $value);
+		}
+		"""
+	numericInt:
+		assertions: '!is_int($value)'
+		returns: int
+		prolog: """
+		if (is_string($value) && is_numeric($value) && preg_match('#^[0-9]+$#D', $value)) {
+			$value = (int) preg_replace('#\\.0*$#D', '', $value);
+		}
+		"""
diff --git a/composer.json b/composer.json
new file mode 100644
index 0000000..c2658c2
--- /dev/null
+++ b/composer.json
@@ -0,0 +1,13 @@
+{
+	"name": "utilitte/asserts",
+	"autoload": {
+		"psr-4": {
+			"Utilitte\\Asserts\\": "src"
+		}
+	},
+	"require": {
+		"php": ">= 8.0",
+		"nette/tester": "^2.4",
+		"nette/utils": "^3.2"
+	}
+}
diff --git a/src/ArrayTypeAssert.php b/src/ArrayTypeAssert.php
new file mode 100644
index 0000000..96b64ba
--- /dev/null
+++ b/src/ArrayTypeAssert.php
@@ -0,0 +1,68 @@
+<?php declare(strict_types = 1);
+
+namespace Utilitte\Asserts;
+
+use Nette\Utils\Helpers;
+use Utilitte\Asserts\Exceptions\OutOfBoundsException;
+use Utilitte\Asserts\Mixins;
+use Utilitte\Asserts\Traits;
+
+final class ArrayTypeAssert
+{
+
+	use Mixins\ArrayTypeAssertTrait;
+	use Traits\ArrayTypeAssertTrait;
+
+	private static function createOutOfBoundsErrorMessage(mixed $array, int $position, int|string $currentKey, array $keys): string
+	{
+		$path = self::withPath(array_slice($keys, 0, $position));
+		$isArray = is_array($array);
+
+		return sprintf(
+			'Undefined key "%s" in array%s%s%s.',
+			$currentKey,
+			$path,
+			!$isArray ? sprintf(', because array%s is %s', $path, get_debug_type($array)) : '',
+			$isArray ? self::didYouMean($array, $currentKey) : '',
+		);
+	}
+
+	private static function get(array $array, string|int $key): mixed
+	{
+		if (is_string($key) && str_contains($key, '.')) {
+			$key = explode('.', $key);
+		} else {
+			$key = (array) $key;
+		}
+
+		foreach ($key as $index => $k) {
+			if (is_array($array) && array_key_exists($k, $array)) {
+				$array = $array[$k];
+			} else {
+				throw new OutOfBoundsException(self::createOutOfBoundsErrorMessage($array, $index, $k, $key));
+			}
+		}
+
+		return $array;
+	}
+
+	private static function didYouMean(array $array, string $key): string
+	{
+		$suggestion = Helpers::getSuggestion(array_filter(array_keys($array), 'is_string'), $key);
+		if (!$suggestion) {
+			return '';
+		}
+
+		return sprintf(', did you mean "%s"?', $suggestion);
+	}
+
+	private static function withPath(array $path): string
+	{
+		if (!$path) {
+			return '';
+		}
+
+		return sprintf('[%s]', implode('][', $path));
+	}
+
+}
diff --git a/src/Exceptions/AssertionFailedException.php b/src/Exceptions/AssertionFailedException.php
new file mode 100644
index 0000000..0907efd
--- /dev/null
+++ b/src/Exceptions/AssertionFailedException.php
@@ -0,0 +1,10 @@
+<?php declare(strict_types = 1);
+
+namespace Utilitte\Asserts\Exceptions;
+
+use LogicException;
+
+class AssertionFailedException extends LogicException
+{
+
+}
diff --git a/src/Exceptions/OutOfBoundsException.php b/src/Exceptions/OutOfBoundsException.php
new file mode 100644
index 0000000..c8edcd0
--- /dev/null
+++ b/src/Exceptions/OutOfBoundsException.php
@@ -0,0 +1,10 @@
+<?php declare(strict_types = 1);
+
+namespace Utilitte\Asserts\Exceptions;
+
+use LogicException;
+
+final class OutOfBoundsException extends LogicException
+{
+
+}
diff --git a/src/Mixins/ArrayTypeAssertTrait.php b/src/Mixins/ArrayTypeAssertTrait.php
new file mode 100644
index 0000000..e236654
--- /dev/null
+++ b/src/Mixins/ArrayTypeAssertTrait.php
@@ -0,0 +1,98 @@
+<?php declare(strict_types = 1);
+
+namespace Utilitte\Asserts\Mixins;
+
+use Utilitte\Asserts\TypeAssert;
+
+/**
+ * @internal
+ */
+trait ArrayTypeAssertTrait
+{
+
+	public static function array(mixed $array, int|string $key): array
+	{
+		return TypeAssert::array(self::get($array, $key));
+	}
+
+	public static function arrayOrNull(mixed $array, int|string $key): ?array
+	{
+		return TypeAssert::arrayOrNull(self::get($array, $key));
+	}
+
+	public static function object(mixed $array, int|string $key): object
+	{
+		return TypeAssert::object(self::get($array, $key));
+	}
+
+	public static function objectOrNull(mixed $array, int|string $key): ?object
+	{
+		return TypeAssert::objectOrNull(self::get($array, $key));
+	}
+
+	public static function string(mixed $array, int|string $key): string
+	{
+		return TypeAssert::string(self::get($array, $key));
+	}
+
+	public static function stringOrNull(mixed $array, int|string $key): ?string
+	{
+		return TypeAssert::stringOrNull(self::get($array, $key));
+	}
+
+	public static function int(mixed $array, int|string $key): int
+	{
+		return TypeAssert::int(self::get($array, $key));
+	}
+
+	public static function intOrNull(mixed $array, int|string $key): ?int
+	{
+		return TypeAssert::intOrNull(self::get($array, $key));
+	}
+
+	public static function float(mixed $array, int|string $key): float
+	{
+		return TypeAssert::float(self::get($array, $key));
+	}
+
+	public static function floatOrNull(mixed $array, int|string $key): ?float
+	{
+		return TypeAssert::floatOrNull(self::get($array, $key));
+	}
+
+	public static function intOrFloat(mixed $array, int|string $key): int|float
+	{
+		return TypeAssert::intOrFloat(self::get($array, $key));
+	}
+
+	public static function intOrFloatOrNull(mixed $array, int|string $key): int|float|null
+	{
+		return TypeAssert::intOrFloatOrNull(self::get($array, $key));
+	}
+
+	public static function numeric(mixed $array, int|string $key): float|int
+	{
+		return TypeAssert::numeric(self::get($array, $key));
+	}
+
+	public static function numericInt(mixed $array, int|string $key): int
+	{
+		return TypeAssert::numericInt(self::get($array, $key));
+	}
+
+	public static function numericIntOrNull(mixed $array, int|string $key): ?int
+	{
+		return TypeAssert::numericIntOrNull(self::get($array, $key));
+	}
+
+	public static function numericFloat(mixed $array, int|string $key): float
+	{
+		return TypeAssert::numericFloat(self::get($array, $key));
+	}
+
+	public static function numericFloatOrNull(mixed $array, int|string $key): ?float
+	{
+		return TypeAssert::numericFloatOrNull(self::get($array, $key));
+	}
+
+}
diff --git a/src/Mixins/TypeAssertTrait.php b/src/Mixins/TypeAssertTrait.php
new file mode 100644
index 0000000..410e1f2
--- /dev/null
+++ b/src/Mixins/TypeAssertTrait.php
@@ -0,0 +1,186 @@
+<?php declare(strict_types = 1);
+
+namespace Utilitte\Asserts\Mixins;
+
+use Utilitte\Asserts\Exceptions\AssertionFailedException;
+
+/**
+ * @internal
+ */
+trait TypeAssertTrait
+{
+
+	public static function array(mixed $value): array
+	{
+		if (!is_array($value)) {
+			throw new AssertionFailedException(self::createErrorMessage($value, 'array'));
+		}
+
+		return $value;
+	}
+
+	public static function arrayOrNull(mixed $value): ?array
+	{
+		if (!is_array($value) && $value !== null) {
+			throw new AssertionFailedException(self::createErrorMessage($value, 'array|null'));
+		}
+
+		return $value;
+	}
+
+	public static function object(mixed $value): object
+	{
+		if (!is_object($value)) {
+			throw new AssertionFailedException(self::createErrorMessage($value, 'object'));
+		}
+
+		return $value;
+	}
+
+	public static function objectOrNull(mixed $value): ?object
+	{
+		if (!is_object($value) && $value !== null) {
+			throw new AssertionFailedException(self::createErrorMessage($value, 'object|null'));
+		}
+
+		return $value;
+	}
+
+	public static function string(mixed $value): string
+	{
+		if (!is_string($value)) {
+			throw new AssertionFailedException(self::createErrorMessage($value, 'string'));
+		}
+
+		return $value;
+	}
+
+	public static function stringOrNull(mixed $value): ?string
+	{
+		if (!is_string($value) && $value !== null) {
+			throw new AssertionFailedException(self::createErrorMessage($value, 'string|null'));
+		}
+
+		return $value;
+	}
+
+	public static function int(mixed $value): int
+	{
+		if (!is_int($value)) {
+			throw new AssertionFailedException(self::createErrorMessage($value, 'int'));
+		}
+
+		return $value;
+	}
+
+	public static function intOrNull(mixed $value): ?int
+	{
+		if (!is_int($value) && $value !== null) {
+			throw new AssertionFailedException(self::createErrorMessage($value, 'int|null'));
+		}
+
+		return $value;
+	}
+
+	public static function float(mixed $value): float
+	{
+		if (!is_float($value)) {
+			throw new AssertionFailedException(self::createErrorMessage($value, 'float'));
+		}
+
+		return $value;
+	}
+
+	public static function floatOrNull(mixed $value): ?float
+	{
+		if (!is_float($value) && $value !== null) {
+			throw new AssertionFailedException(self::createErrorMessage($value, 'float|null'));
+		}
+
+		return $value;
+	}
+
+	public static function intOrFloat(mixed $value): int|float
+	{
+		if (!is_int($value) && !is_float($value)) {
+			throw new AssertionFailedException(self::createErrorMessage($value, 'int|float'));
+		}
+
+		return $value;
+	}
+
+	public static function intOrFloatOrNull(mixed $value): int|float|null
+	{
+		if (!is_int($value) && !is_float($value) && $value !== null) {
+			throw new AssertionFailedException(self::createErrorMessage($value, 'int|float|null'));
+		}
+
+		return $value;
+	}
+
+	public static function numeric(mixed $value): float|int
+	{
+		if (is_string($value) && is_numeric($value)) {
+			$value = str_contains($value, '.') ? (float) $value : (int) $value;
+		}
+
+		if (!is_float($value) && !is_int($value)) {
+			throw new AssertionFailedException(self::createErrorMessage($value, 'numeric'));
+		}
+
+		return $value;
+	}
+
+	public static function numericInt(mixed $value): int
+	{
+		if (is_string($value) && is_numeric($value) && preg_match('#^[0-9]+$#D', $value)) {
+			$value = (int) preg_replace('#\.0*$#D', '', $value);
+		}
+
+		if (!is_int($value)) {
+			throw new AssertionFailedException(self::createErrorMessage($value, 'numericInt'));
+		}
+
+		return $value;
+	}
+
+	public static function numericIntOrNull(mixed $value): ?int
+	{
+		if (is_string($value) && is_numeric($value) && preg_match('#^[0-9]+$#D', $value)) {
+			$value = (int) preg_replace('#\.0*$#D', '', $value);
+		}
+
+		if (!is_int($value) && $value !== null) {
+			throw new AssertionFailedException(self::createErrorMessage($value, 'numericInt|null'));
+		}
+
+		return $value;
+	}
+
+	public static function numericFloat(mixed $value): float
+	{
+		if (is_string($value) && is_numeric($value)) {
+			$value = (float) preg_replace('#\.0*$#D', '', $value);
+		}
+
+		if (!is_float($value)) {
+			throw new AssertionFailedException(self::createErrorMessage($value, 'numericFloat'));
+		}
+
+		return $value;
+	}
+
+	public static function numericFloatOrNull(mixed $value): ?float
+	{
+		if (is_string($value) && is_numeric($value)) {
+			$value = (float) preg_replace('#\.0*$#D', '', $value);
+		}
+
+		if (!is_float($value) && $value !== null) {
+			throw new AssertionFailedException(self::createErrorMessage($value, 'numericFloat|null'));
+		}
+
+		return $value;
+	}
+
+}
diff --git a/src/Traits/ArrayTypeAssertTrait.php b/src/Traits/ArrayTypeAssertTrait.php
new file mode 100644
index 0000000..ff83e00
--- /dev/null
+++ b/src/Traits/ArrayTypeAssertTrait.php
@@ -0,0 +1,32 @@
+<?php declare(strict_types = 1);
+
+namespace Utilitte\Asserts\Traits;
+
+use Utilitte\Asserts\TypeAssert;
+
+trait ArrayTypeAssertTrait
+{
+
+	/**
+	 * @template T of object
+	 * @param mixed[] $array
+	 * @param class-string<T> $type
+	 * @return T
+	 */
+	public static function instance(array $array, string|int $key, string $type): object
+	{
+		return TypeAssert::instance(self::get($array, $key), $type);
+	}
+
+	/**
+	 * @template T of object
+	 * @param mixed[] $array
+	 * @param class-string<T> $type
+	 * @return T|null
+	 */
+	public static function instanceOrNull(array $array, string|int $key, string $type): ?object
+	{
+		return TypeAssert::instanceOrNull(self::get($array, $key), $type);
+	}
+
+}
diff --git a/src/Traits/TypeAssertTrait.php b/src/Traits/TypeAssertTrait.php
new file mode 100644
index 0000000..fd9d35d
--- /dev/null
+++ b/src/Traits/TypeAssertTrait.php
@@ -0,0 +1,71 @@
+<?php declare(strict_types = 1);
+
+namespace Utilitte\Asserts\Traits;
+
+use LogicException;
+use Nette\Utils\Type;
+use Utilitte\Asserts\Exceptions\AssertionFailedException;
+
+trait TypeAssertTrait
+{
+
+	/**
+	 * @template T of object
+	 * @param mixed $value
+	 * @param class-string<T> $type
+	 * @return T
+	 */
+	public static function instance(mixed $value, string $type): object
+	{
+		self::checkInstanceStruct($typeStruct = Type::fromString($type));
+
+		if (is_object($value)) {
+			foreach ($typeStruct->getNames() as $singleType) {
+				if ($value instanceof $singleType) {
+					return $value;
+				}
+			}
+		}
+
+		throw new AssertionFailedException(self::createErrorMessage($value, $type));
+	}
+
+	/**
+	 * @template T of object
+	 * @param mixed $value
+	 * @param class-string<T> $type
+	 * @return T|null
+	 */
+	public static function instanceOrNull(mixed $value, string $type): ?object
+	{
+		self::checkInstanceStruct($typeStruct = Type::fromString($type));
+
+		if ($value === null) {
+			return null;
+		}
+
+		if (is_object($value)) {
+			foreach ($typeStruct->getNames() as $singleType) {
+				if ($value instanceof $singleType) {
+					return $value;
+				}
+			}
+		}
+
+		throw new AssertionFailedException(self::createErrorMessage($value, $type));
+	}
+
+	private static function checkInstanceStruct(Type $type): void
+	{
+		if ($type->isIntersection()) {
+			throw new LogicException('Intersection type in instance is not supported.');
+		}
+
+		foreach ($type->getTypes() as $singleType) {
+			if ($singleType->isBuiltin()) {
+				throw new LogicException(sprintf('Invalid type "%s" in instance.', $singleType->getSingleName()));
+			}
+		}
+	}
+
+}
diff --git a/src/TypeAssert.php b/src/TypeAssert.php
new file mode 100644
index 0000000..6cd92f7
--- /dev/null
+++ b/src/TypeAssert.php
@@ -0,0 +1,19 @@
+<?php declare(strict_types = 1);
+
+namespace Utilitte\Asserts;
+
+use Utilitte\Asserts\Mixins;
+use Utilitte\Asserts\Traits;
+
+final class TypeAssert
+{
+
+	use Mixins\TypeAssertTrait;
+	use Traits\TypeAssertTrait;
+
+	private static function createErrorMessage(mixed $value, string $type): string
+	{
+		return sprintf('Variable must be of the type %s, %s given.', $type, get_debug_type($value));
+	}
+
+}
diff --git a/tests/ArrayTypeAssert.test.phpt b/tests/ArrayTypeAssert.test.phpt
new file mode 100644
index 0000000..0eef249
--- /dev/null
+++ b/tests/ArrayTypeAssert.test.phpt
@@ -0,0 +1,31 @@
+<?php declare(strict_types = 1);
+
+use Tester\Assert;
+use Utilitte\Asserts\ArrayTypeAssert;
+use Utilitte\Asserts\TypeAssert;
+
+require __DIR__ . '/_bootstrap.php';
+
+$array = [
+	['john', 'doe', 'nested' => 'nested'],
+	'foo' => ['bar' => 'bar'],
+	'first' => [
+		'second' => [
+			'third' => [],
+		],
+	],
+];
+
+Assert::same('bar', ArrayTypeAssert::string($array, 'foo.bar'));
+
+Assert::exception(fn () => ArrayTypeAssert::string($array, 'fo'), \Utilitte\Asserts\Exceptions\OutOfBoundsException::class);
+
+Assert::same('bar', ArrayTypeAssert::string([
+	'foo' => ['bar' => 'bar'],
+], 'foo.bar'));
+
+Assert::exception(fn () => ArrayTypeAssert::string($array, 'foo.ba'), \Utilitte\Asserts\Exceptions\OutOfBoundsException::class);
+Assert::exception(fn () => ArrayTypeAssert::string($array, '0.nested.xxx'), \Utilitte\Asserts\Exceptions\OutOfBoundsException::class);
+
+
+Assert::same('nested', ArrayTypeAssert::string($array, '0.nested'));
diff --git a/tests/_bootstrap.php b/tests/_bootstrap.php
new file mode 100644
index 0000000..558d6ec
--- /dev/null
+++ b/tests/_bootstrap.php
@@ -0,0 +1,3 @@
+<?php declare(strict_types = 1);
+
+require __DIR__ . '/../vendor/autoload.php';