diff --git a/src/Type/Php/FilterFunctionReturnTypeHelper.php b/src/Type/Php/FilterFunctionReturnTypeHelper.php
index ee7169f71bb..720168b23d1 100644
--- a/src/Type/Php/FilterFunctionReturnTypeHelper.php
+++ b/src/Type/Php/FilterFunctionReturnTypeHelper.php
@@ -27,6 +27,7 @@
 use PHPStan\Type\StringType;
 use PHPStan\Type\Type;
 use PHPStan\Type\TypeCombinator;
+use PHPStan\Type\TypeTraverser;
 use PHPStan\Type\UnionType;
 use function array_key_exists;
 use function array_merge;
@@ -167,9 +168,42 @@ public function getType(Type $inputType, ?Type $filterType, ?Type $flagsType): T
 
 		if ($inputIsArray->yes() && ($hasRequireArrayFlag->yes() || $hasForceArrayFlag->yes())) {
 			$inputArrayKeyType = $inputType->getIterableKeyType();
-			$inputType = $inputType->getIterableValueType();
+			$inputValueType = $inputType->getIterableValueType();
+			$filteredValueType = $this->filterTypeComponents($inputValueType, $filterType, $flagsType, $filterValue, $defaultType, $mixedType, $hasOptions, $options);
+
+			return new ArrayType($inputArrayKeyType, $filteredValueType);
 		}
 
+		if ($hasRequireArrayFlag->yes()) {
+			$type = $this->filterTypeComponents($inputType, $filterType, $flagsType, $filterValue, $defaultType, $mixedType, $hasOptions, $options);
+			$type = new ArrayType($mixedType, $type);
+			if (!$inputIsArray->yes()) {
+				$type = TypeCombinator::union($type, $defaultType);
+			}
+			return $type;
+		}
+
+		if ($hasForceArrayFlag->yes()) {
+			$type = $this->filterTypeComponents($inputType, $filterType, $flagsType, $filterValue, $defaultType, $mixedType, $hasOptions, $options);
+			return new ArrayType($mixedType, $type);
+		}
+
+		$type = $this->filterScalarType($inputType, $filterValue, $defaultType, $flagsType, $mixedType, $hasOptions, $options);
+
+		if ($this->hasFlag('FILTER_THROW_ON_FAILURE', $flagsType)->yes()) {
+			$type = TypeCombinator::remove($type, $defaultType);
+		}
+
+		return $type;
+	}
+
+	/**
+	 * Applies the filter to a scalar input type (no array wrapping).
+	 *
+	 * @param array<string, ?Type> $options
+	 */
+	private function filterScalarType(Type $inputType, int $filterValue, Type $defaultType, ?Type $flagsType, MixedType $mixedType, TrinaryLogic $hasOptions, array $options): Type
+	{
 		if ($inputType->isScalar()->no() && $inputType->isNull()->no()) {
 			$exactType = $defaultType;
 		} else {
@@ -197,24 +231,34 @@ public function getType(Type $inputType, ?Type $filterType, ?Type $flagsType): T
 			}
 		}
 
-		if ($hasRequireArrayFlag->yes()) {
-			$type = new ArrayType($inputArrayKeyType ?? $mixedType, $type);
-			if (!$inputIsArray->yes()) {
-				$type = TypeCombinator::union($type, $defaultType);
-			}
-		}
-
-		if ($hasRequireArrayFlag->no() && $hasForceArrayFlag->yes()) {
-			return new ArrayType($inputArrayKeyType ?? $mixedType, $type);
-		}
-
-		if ($this->hasFlag('FILTER_THROW_ON_FAILURE', $flagsType)->yes()) {
-			$type = TypeCombinator::remove($type, $defaultType);
-		}
-
 		return $type;
 	}
 
+	/**
+	 * Recursively filters each component of a type that may contain arrays.
+	 * Array components are recursively filtered via getType(), scalar components
+	 * are filtered via filterScalarType(), and maybe-array components produce
+	 * a union of both.
+	 *
+	 * @param array<string, ?Type> $options
+	 */
+	private function filterTypeComponents(Type $type, ?Type $filterType, ?Type $flagsType, int $filterValue, Type $defaultType, MixedType $mixedType, TrinaryLogic $hasOptions, array $options): Type
+	{
+		return TypeTraverser::map($type, function (Type $innerType, callable $traverse) use ($filterType, $flagsType, $filterValue, $defaultType, $mixedType, $hasOptions, $options): Type {
+			if ($innerType instanceof UnionType || $innerType instanceof IntersectionType) {
+				return $traverse($innerType);
+			}
+			if ($innerType->isArray()->yes()) {
+				return $this->getType($innerType, $filterType, $flagsType);
+			}
+			$scalarResult = $this->filterScalarType($innerType, $filterValue, $defaultType, $flagsType, $mixedType, $hasOptions, $options);
+			if ($innerType->isArray()->maybe()) {
+				return TypeCombinator::union($scalarResult, new ArrayType($mixedType, $mixedType));
+			}
+			return $scalarResult;
+		});
+	}
+
 	/**
 	 * @return array<int, Type>
 	 */
diff --git a/tests/PHPStan/Analyser/nsrt/bug-11339.php b/tests/PHPStan/Analyser/nsrt/bug-11339.php
new file mode 100644
index 00000000000..07beafcb2f3
--- /dev/null
+++ b/tests/PHPStan/Analyser/nsrt/bug-11339.php
@@ -0,0 +1,92 @@
+<?php declare(strict_types = 1);
+
+namespace Bug11339;
+
+use function PHPStan\Testing\assertType;
+
+// assume query string to be ?a[a][b][]=a&a[a][b][]=b
+
+$f = filter_input(INPUT_GET, 'a', FILTER_DEFAULT, FILTER_FORCE_ARRAY);
+assertType('array<array|string|false>|null', $f);
+
+$g = filter_input(INPUT_GET, 'a', FILTER_DEFAULT, FILTER_REQUIRE_ARRAY);
+assertType('array<array|string|false>|false|null', $g);
+
+$h = filter_input(INPUT_GET, 'a', FILTER_VALIDATE_INT, FILTER_FORCE_ARRAY);
+assertType('array<array|int|false>|null', $h);
+
+$i = filter_input(INPUT_GET, 'a', FILTER_VALIDATE_INT, FILTER_REQUIRE_ARRAY);
+assertType('array<array|int|false>|false|null', $i);
+
+// filter_var with known scalar should not include array in value type
+$j = filter_var('foo', FILTER_DEFAULT, FILTER_FORCE_ARRAY);
+assertType("array<'foo'>", $j);
+
+$k = filter_var('foo', FILTER_VALIDATE_INT, FILTER_FORCE_ARRAY);
+assertType('array<false>', $k);
+
+/**
+ * @param array<int> $arrayOfInt
+ * @param array<array<int>> $arrayOfArrayOfInt
+ * @param array<int|array<int>> $arrayOfIntOrArrayOfInt
+ */
+function typedArrayInputs(array $arrayOfInt, array $arrayOfArrayOfInt, array $arrayOfIntOrArrayOfInt): void
+{
+	// array<int> - values are ints, not arrays, so no array in value type
+	$l = filter_var($arrayOfInt, FILTER_VALIDATE_INT, ['flags' => FILTER_REQUIRE_ARRAY]);
+	assertType('array<int>', $l);
+
+	$m = filter_var($arrayOfInt, FILTER_VALIDATE_INT, ['flags' => FILTER_REQUIRE_ARRAY|FILTER_NULL_ON_FAILURE]);
+	assertType('array<int>', $m);
+
+	// array<array<int>> - values are arrays, recursively filtered
+	$n = filter_var($arrayOfArrayOfInt, FILTER_VALIDATE_INT, ['flags' => FILTER_REQUIRE_ARRAY]);
+	assertType('array<array<int>>', $n);
+
+	$o = filter_var($arrayOfArrayOfInt, FILTER_VALIDATE_INT, ['flags' => FILTER_REQUIRE_ARRAY|FILTER_NULL_ON_FAILURE]);
+	assertType('array<array<int>>', $o);
+
+	// array<int|array<int>> - mixed values, both scalar and array possible
+	$p = filter_var($arrayOfIntOrArrayOfInt, FILTER_VALIDATE_INT, ['flags' => FILTER_REQUIRE_ARRAY]);
+	assertType('array<array<int>|int>', $p);
+
+	$q = filter_var($arrayOfIntOrArrayOfInt, FILTER_VALIDATE_INT, ['flags' => FILTER_REQUIRE_ARRAY|FILTER_NULL_ON_FAILURE]);
+	assertType('array<array<int>|int>', $q);
+
+	// FORCE_ARRAY with typed arrays
+	$r = filter_var($arrayOfInt, FILTER_VALIDATE_INT, ['flags' => FILTER_FORCE_ARRAY]);
+	assertType('array<int>', $r);
+
+	$s = filter_var($arrayOfArrayOfInt, FILTER_VALIDATE_INT, ['flags' => FILTER_FORCE_ARRAY]);
+	assertType('array<array<int>>', $s);
+}
+
+/**
+ * Union-typed inputs (scalar | array) exercise the inputIsArray->maybe() path
+ *
+ * @param int|array<int> $intOrArrayOfInt
+ * @param string|array<string> $stringOrArrayOfString
+ */
+function unionTypedInputs(int|array $intOrArrayOfInt, string|array $stringOrArrayOfString): void
+{
+	// FORCE_ARRAY: scalar part filtered, array part recursively filtered
+	$a = filter_var($intOrArrayOfInt, FILTER_VALIDATE_INT, ['flags' => FILTER_FORCE_ARRAY]);
+	assertType('array<array<int>|int>', $a);
+
+	$b = filter_var($stringOrArrayOfString, FILTER_DEFAULT, ['flags' => FILTER_FORCE_ARRAY]);
+	assertType('array<array<string>|string>', $b);
+
+	// REQUIRE_ARRAY: scalar input returns false, array input recursively filtered
+	$c = filter_var($intOrArrayOfInt, FILTER_VALIDATE_INT, ['flags' => FILTER_REQUIRE_ARRAY]);
+	assertType('array<array<int>|int>|false', $c);
+
+	$d = filter_var($stringOrArrayOfString, FILTER_DEFAULT, ['flags' => FILTER_REQUIRE_ARRAY]);
+	assertType('array<array<string>|string>|false', $d);
+
+	// REQUIRE_ARRAY with NULL_ON_FAILURE
+	$e = filter_var($intOrArrayOfInt, FILTER_VALIDATE_INT, ['flags' => FILTER_REQUIRE_ARRAY|FILTER_NULL_ON_FAILURE]);
+	assertType('array<array<int>|int>|null', $e);
+
+	$f = filter_var($stringOrArrayOfString, FILTER_DEFAULT, ['flags' => FILTER_REQUIRE_ARRAY|FILTER_NULL_ON_FAILURE]);
+	assertType('array<array<string>|string>|null', $f);
+}
diff --git a/tests/PHPStan/Analyser/nsrt/discussion-9134.php b/tests/PHPStan/Analyser/nsrt/discussion-9134.php
index c431d86ec6f..df66c48477f 100644
--- a/tests/PHPStan/Analyser/nsrt/discussion-9134.php
+++ b/tests/PHPStan/Analyser/nsrt/discussion-9134.php
@@ -6,7 +6,7 @@
 
 $var = $_GET["data"];
 $res = filter_var($var, FILTER_VALIDATE_INT, FILTER_REQUIRE_ARRAY);
-assertType('array<int|false>|false', $res);
+assertType('array<array|int|false>|false', $res);
 if (is_array($res) === false) {
 	throw new \RuntimeException();
 }
diff --git a/tests/PHPStan/Analyser/nsrt/filter-input.php b/tests/PHPStan/Analyser/nsrt/filter-input.php
index 466862d85bd..da8cd9df0bf 100644
--- a/tests/PHPStan/Analyser/nsrt/filter-input.php
+++ b/tests/PHPStan/Analyser/nsrt/filter-input.php
@@ -34,8 +34,8 @@ public function doFoo(string $foo): void
 		assertType('int|false|null', filter_input(INPUT_GET, 'foo', FILTER_VALIDATE_INT));
 		assertType('int|false|null', filter_input(INPUT_GET, 'foo', FILTER_VALIDATE_INT, ['flags' => FILTER_NULL_ON_FAILURE]));
 		assertType("'invalid'|int|null", filter_input(INPUT_GET, 'foo', FILTER_VALIDATE_INT, ['options' => ['default' => 'invalid']]));
-		assertType('array<int|false>|null', filter_input(INPUT_GET, 'foo', FILTER_VALIDATE_INT, ['flags' => FILTER_FORCE_ARRAY]));
-		assertType('array<int|null>|false', filter_input(INPUT_GET, 'foo', FILTER_VALIDATE_INT, ['flags' => FILTER_FORCE_ARRAY|FILTER_NULL_ON_FAILURE]));
+		assertType('array<array|int|false>|null', filter_input(INPUT_GET, 'foo', FILTER_VALIDATE_INT, ['flags' => FILTER_FORCE_ARRAY]));
+		assertType('array<array|int|null>|false', filter_input(INPUT_GET, 'foo', FILTER_VALIDATE_INT, ['flags' => FILTER_FORCE_ARRAY|FILTER_NULL_ON_FAILURE]));
 		assertType('0|int<17, 19>|null', filter_input(INPUT_GET, 'foo', FILTER_VALIDATE_INT, ['options' => ['default' => 0, 'min_range' => 17, 'max_range' => 19]]));
 	}
 
diff --git a/tests/PHPStan/Analyser/nsrt/filter-var.php b/tests/PHPStan/Analyser/nsrt/filter-var.php
index 34d23f9c8fd..e5bb48e4179 100644
--- a/tests/PHPStan/Analyser/nsrt/filter-var.php
+++ b/tests/PHPStan/Analyser/nsrt/filter-var.php
@@ -23,28 +23,28 @@ public function doFoo($mixed, array $stringMixedMap): void
 		assertType('null', filter_var(17, FILTER_VALIDATE_INT, ['flags' => FILTER_REQUIRE_ARRAY|FILTER_NULL_ON_FAILURE]));
 		assertType('false', filter_var('foo', FILTER_VALIDATE_INT, ['flags' => FILTER_REQUIRE_ARRAY]));
 		assertType('null', filter_var('foo', FILTER_VALIDATE_INT, ['flags' => FILTER_REQUIRE_ARRAY|FILTER_NULL_ON_FAILURE]));
-		assertType('array<int|false>|false', filter_var($mixed, FILTER_VALIDATE_INT, ['flags' => FILTER_REQUIRE_ARRAY]));
-		assertType('array<int|null>|null', filter_var($mixed, FILTER_VALIDATE_INT, ['flags' => FILTER_REQUIRE_ARRAY|FILTER_NULL_ON_FAILURE]));
-		assertType('array<string, int|false>', filter_var($stringMixedMap, FILTER_VALIDATE_INT, ['flags' => FILTER_REQUIRE_ARRAY]));
-		assertType('array<string, int|null>', filter_var($stringMixedMap, FILTER_VALIDATE_INT, ['flags' => FILTER_REQUIRE_ARRAY|FILTER_NULL_ON_FAILURE]));
+		assertType('array<array|int|false>|false', filter_var($mixed, FILTER_VALIDATE_INT, ['flags' => FILTER_REQUIRE_ARRAY]));
+		assertType('array<array|int|null>|null', filter_var($mixed, FILTER_VALIDATE_INT, ['flags' => FILTER_REQUIRE_ARRAY|FILTER_NULL_ON_FAILURE]));
+		assertType('array<string, array|int|false>', filter_var($stringMixedMap, FILTER_VALIDATE_INT, ['flags' => FILTER_REQUIRE_ARRAY]));
+		assertType('array<string, array|int|null>', filter_var($stringMixedMap, FILTER_VALIDATE_INT, ['flags' => FILTER_REQUIRE_ARRAY|FILTER_NULL_ON_FAILURE]));
 
 		assertType('array<17>', filter_var(17, FILTER_VALIDATE_INT, ['flags' => FILTER_FORCE_ARRAY]));
 		assertType('array<17>', filter_var(17, FILTER_VALIDATE_INT, ['flags' => FILTER_FORCE_ARRAY|FILTER_NULL_ON_FAILURE]));
 		assertType('array<false>', filter_var('foo', FILTER_VALIDATE_INT, ['flags' => FILTER_FORCE_ARRAY]));
 		assertType('array<null>', filter_var('foo', FILTER_VALIDATE_INT, ['flags' => FILTER_FORCE_ARRAY|FILTER_NULL_ON_FAILURE]));
-	 	assertType('array<int|false>', filter_var($mixed, FILTER_VALIDATE_INT, ['flags' => FILTER_FORCE_ARRAY]));
-		assertType('array<int|null>', filter_var($mixed, FILTER_VALIDATE_INT, ['flags' => FILTER_FORCE_ARRAY|FILTER_NULL_ON_FAILURE]));
-		assertType('array<string, int|false>', filter_var($stringMixedMap, FILTER_VALIDATE_INT, ['flags' => FILTER_FORCE_ARRAY]));
-		assertType('array<string, int|null>', filter_var($stringMixedMap, FILTER_VALIDATE_INT, ['flags' => FILTER_FORCE_ARRAY|FILTER_NULL_ON_FAILURE]));
+	 	assertType('array<array|int|false>', filter_var($mixed, FILTER_VALIDATE_INT, ['flags' => FILTER_FORCE_ARRAY]));
+		assertType('array<array|int|null>', filter_var($mixed, FILTER_VALIDATE_INT, ['flags' => FILTER_FORCE_ARRAY|FILTER_NULL_ON_FAILURE]));
+		assertType('array<string, array|int|false>', filter_var($stringMixedMap, FILTER_VALIDATE_INT, ['flags' => FILTER_FORCE_ARRAY]));
+		assertType('array<string, array|int|null>', filter_var($stringMixedMap, FILTER_VALIDATE_INT, ['flags' => FILTER_FORCE_ARRAY|FILTER_NULL_ON_FAILURE]));
 
 		assertType('false', filter_var(17, FILTER_VALIDATE_INT, ['flags' => FILTER_REQUIRE_ARRAY|FILTER_FORCE_ARRAY]));
 		assertType('null', filter_var(17, FILTER_VALIDATE_INT, ['flags' => FILTER_REQUIRE_ARRAY|FILTER_FORCE_ARRAY|FILTER_NULL_ON_FAILURE]));
 		assertType('false', filter_var('foo', FILTER_VALIDATE_INT, ['flags' => FILTER_REQUIRE_ARRAY|FILTER_FORCE_ARRAY]));
 		assertType('null', filter_var('foo', FILTER_VALIDATE_INT, ['flags' => FILTER_REQUIRE_ARRAY|FILTER_FORCE_ARRAY|FILTER_NULL_ON_FAILURE]));
-		assertType('array<int|false>|false', filter_var($mixed, FILTER_VALIDATE_INT, ['flags' => FILTER_REQUIRE_ARRAY|FILTER_FORCE_ARRAY]));
-		assertType('array<int|null>|null', filter_var($mixed, FILTER_VALIDATE_INT, ['flags' => FILTER_REQUIRE_ARRAY|FILTER_FORCE_ARRAY|FILTER_NULL_ON_FAILURE]));
-		assertType('array<string, int|false>', filter_var($stringMixedMap, FILTER_VALIDATE_INT, ['flags' => FILTER_REQUIRE_ARRAY|FILTER_FORCE_ARRAY]));
-		assertType('array<string, int|null>', filter_var($stringMixedMap, FILTER_VALIDATE_INT, ['flags' => FILTER_REQUIRE_ARRAY|FILTER_FORCE_ARRAY|FILTER_NULL_ON_FAILURE]));
+		assertType('array<array|int|false>|false', filter_var($mixed, FILTER_VALIDATE_INT, ['flags' => FILTER_REQUIRE_ARRAY|FILTER_FORCE_ARRAY]));
+		assertType('array<array|int|null>|null', filter_var($mixed, FILTER_VALIDATE_INT, ['flags' => FILTER_REQUIRE_ARRAY|FILTER_FORCE_ARRAY|FILTER_NULL_ON_FAILURE]));
+		assertType('array<string, array|int|false>', filter_var($stringMixedMap, FILTER_VALIDATE_INT, ['flags' => FILTER_REQUIRE_ARRAY|FILTER_FORCE_ARRAY]));
+		assertType('array<string, array|int|null>', filter_var($stringMixedMap, FILTER_VALIDATE_INT, ['flags' => FILTER_REQUIRE_ARRAY|FILTER_FORCE_ARRAY|FILTER_NULL_ON_FAILURE]));
 
 		assertType('0|int<17, 19>', filter_var($mixed, FILTER_VALIDATE_INT, ['options' => ['default' => 0, 'min_range' => 17, 'max_range' => 19]]));
 
diff --git a/tests/PHPStan/Analyser/nsrt/filterVar.php b/tests/PHPStan/Analyser/nsrt/filterVar.php
index 8b189d755a6..74039410b70 100644
--- a/tests/PHPStan/Analyser/nsrt/filterVar.php
+++ b/tests/PHPStan/Analyser/nsrt/filterVar.php
@@ -19,14 +19,14 @@ function () {
 	assertType('string|null', filter_var($mixed, FILTER_DEFAULT , ["flags" => FILTER_NULL_ON_FAILURE | FILTER_FLAG_IPV4]));
 	assertType('string|null', filter_var($mixed, FILTER_DEFAULT , ["flags" => $nullFilter]));
 	assertType('FilterVar\\Analyser|string', filter_var($mixed, FILTER_DEFAULT , ["options" => ["default" => new Analyser]]));
-	assertType('array<string|null>', filter_var($mixed, FILTER_DEFAULT , FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY));
-	assertType('array<string|null>', filter_var($mixed, FILTER_DEFAULT , FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY | FILTER_FLAG_IPV4));
-	assertType('array<string|false>', filter_var($mixed, FILTER_DEFAULT , FILTER_FORCE_ARRAY));
-	assertType('array<string|null>', filter_var($mixed, FILTER_DEFAULT , ["flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
-	assertType('array<string|false>', filter_var($mixed, FILTER_DEFAULT , ["flags" => FILTER_FORCE_ARRAY | FILTER_FLAG_IPV4]));
-	assertType('array<string|false>', filter_var($mixed, FILTER_DEFAULT , ["flags" => $forceArrayFilter]));
-	assertType('array<FilterVar\Analyser|string>', filter_var($mixed, FILTER_DEFAULT , ["options" => ["default" => new Analyser], "flags" => FILTER_FORCE_ARRAY]));
-	assertType('array<FilterVar\Analyser|string>', filter_var($mixed, FILTER_DEFAULT , ["options" => ["default" => new Analyser], "flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
+	assertType('array<array|string|null>', filter_var($mixed, FILTER_DEFAULT , FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY));
+	assertType('array<array|string|null>', filter_var($mixed, FILTER_DEFAULT , FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY | FILTER_FLAG_IPV4));
+	assertType('array<array|string|false>', filter_var($mixed, FILTER_DEFAULT , FILTER_FORCE_ARRAY));
+	assertType('array<array|string|null>', filter_var($mixed, FILTER_DEFAULT , ["flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
+	assertType('array<array|string|false>', filter_var($mixed, FILTER_DEFAULT , ["flags" => FILTER_FORCE_ARRAY | FILTER_FLAG_IPV4]));
+	assertType('array<array|string|false>', filter_var($mixed, FILTER_DEFAULT , ["flags" => $forceArrayFilter]));
+	assertType('array<array|FilterVar\Analyser|string>', filter_var($mixed, FILTER_DEFAULT , ["options" => ["default" => new Analyser], "flags" => FILTER_FORCE_ARRAY]));
+	assertType('array<array|FilterVar\Analyser|string>', filter_var($mixed, FILTER_DEFAULT , ["options" => ["default" => new Analyser], "flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
 	assertType('string|false', filter_var($mixed, FILTER_UNSAFE_RAW ));
 	assertType('mixed', filter_var($mixed, FILTER_UNSAFE_RAW , $mixed));
 	assertType('mixed', filter_var($mixed, FILTER_UNSAFE_RAW , ["flags" => $mixed]));
@@ -35,14 +35,14 @@ function () {
 	assertType('string|null', filter_var($mixed, FILTER_UNSAFE_RAW , ["flags" => FILTER_NULL_ON_FAILURE | FILTER_FLAG_IPV4]));
 	assertType('string|null', filter_var($mixed, FILTER_UNSAFE_RAW , ["flags" => $nullFilter]));
 	assertType('FilterVar\\Analyser|string', filter_var($mixed, FILTER_UNSAFE_RAW , ["options" => ["default" => new Analyser]]));
-	assertType('array<string|null>', filter_var($mixed, FILTER_UNSAFE_RAW , FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY));
-	assertType('array<string|null>', filter_var($mixed, FILTER_UNSAFE_RAW , FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY | FILTER_FLAG_IPV4));
-	assertType('array<string|false>', filter_var($mixed, FILTER_UNSAFE_RAW , FILTER_FORCE_ARRAY));
-	assertType('array<string|null>', filter_var($mixed, FILTER_UNSAFE_RAW , ["flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
-	assertType('array<string|false>', filter_var($mixed, FILTER_UNSAFE_RAW , ["flags" => FILTER_FORCE_ARRAY | FILTER_FLAG_IPV4]));
-	assertType('array<string|false>', filter_var($mixed, FILTER_UNSAFE_RAW , ["flags" => $forceArrayFilter]));
-	assertType('array<FilterVar\Analyser|string>', filter_var($mixed, FILTER_UNSAFE_RAW , ["options" => ["default" => new Analyser], "flags" => FILTER_FORCE_ARRAY]));
-	assertType('array<FilterVar\Analyser|string>', filter_var($mixed, FILTER_UNSAFE_RAW , ["options" => ["default" => new Analyser], "flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
+	assertType('array<array|string|null>', filter_var($mixed, FILTER_UNSAFE_RAW , FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY));
+	assertType('array<array|string|null>', filter_var($mixed, FILTER_UNSAFE_RAW , FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY | FILTER_FLAG_IPV4));
+	assertType('array<array|string|false>', filter_var($mixed, FILTER_UNSAFE_RAW , FILTER_FORCE_ARRAY));
+	assertType('array<array|string|null>', filter_var($mixed, FILTER_UNSAFE_RAW , ["flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
+	assertType('array<array|string|false>', filter_var($mixed, FILTER_UNSAFE_RAW , ["flags" => FILTER_FORCE_ARRAY | FILTER_FLAG_IPV4]));
+	assertType('array<array|string|false>', filter_var($mixed, FILTER_UNSAFE_RAW , ["flags" => $forceArrayFilter]));
+	assertType('array<array|FilterVar\Analyser|string>', filter_var($mixed, FILTER_UNSAFE_RAW , ["options" => ["default" => new Analyser], "flags" => FILTER_FORCE_ARRAY]));
+	assertType('array<array|FilterVar\Analyser|string>', filter_var($mixed, FILTER_UNSAFE_RAW , ["options" => ["default" => new Analyser], "flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
 	assertType('string|false', filter_var($mixed, FILTER_SANITIZE_EMAIL ));
 	assertType('mixed', filter_var($mixed, FILTER_SANITIZE_EMAIL , $mixed));
 	assertType('mixed', filter_var($mixed, FILTER_SANITIZE_EMAIL , ["flags" => $mixed]));
@@ -51,14 +51,14 @@ function () {
 	assertType('string|null', filter_var($mixed, FILTER_SANITIZE_EMAIL , ["flags" => FILTER_NULL_ON_FAILURE | FILTER_FLAG_IPV4]));
 	assertType('string|null', filter_var($mixed, FILTER_SANITIZE_EMAIL , ["flags" => $nullFilter]));
 	assertType('FilterVar\\Analyser|string', filter_var($mixed, FILTER_SANITIZE_EMAIL , ["options" => ["default" => new Analyser]]));
-	assertType('array<string|null>', filter_var($mixed, FILTER_SANITIZE_EMAIL , FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY));
-	assertType('array<string|null>', filter_var($mixed, FILTER_SANITIZE_EMAIL , FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY | FILTER_FLAG_IPV4));
-	assertType('array<string|false>', filter_var($mixed, FILTER_SANITIZE_EMAIL , FILTER_FORCE_ARRAY));
-	assertType('array<string|null>', filter_var($mixed, FILTER_SANITIZE_EMAIL , ["flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
-	assertType('array<string|false>', filter_var($mixed, FILTER_SANITIZE_EMAIL , ["flags" => FILTER_FORCE_ARRAY | FILTER_FLAG_IPV4]));
-	assertType('array<string|false>', filter_var($mixed, FILTER_SANITIZE_EMAIL , ["flags" => $forceArrayFilter]));
-	assertType('array<FilterVar\Analyser|string>', filter_var($mixed, FILTER_SANITIZE_EMAIL , ["options" => ["default" => new Analyser], "flags" => FILTER_FORCE_ARRAY]));
-	assertType('array<FilterVar\Analyser|string>', filter_var($mixed, FILTER_SANITIZE_EMAIL , ["options" => ["default" => new Analyser], "flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
+	assertType('array<array|string|null>', filter_var($mixed, FILTER_SANITIZE_EMAIL , FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY));
+	assertType('array<array|string|null>', filter_var($mixed, FILTER_SANITIZE_EMAIL , FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY | FILTER_FLAG_IPV4));
+	assertType('array<array|string|false>', filter_var($mixed, FILTER_SANITIZE_EMAIL , FILTER_FORCE_ARRAY));
+	assertType('array<array|string|null>', filter_var($mixed, FILTER_SANITIZE_EMAIL , ["flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
+	assertType('array<array|string|false>', filter_var($mixed, FILTER_SANITIZE_EMAIL , ["flags" => FILTER_FORCE_ARRAY | FILTER_FLAG_IPV4]));
+	assertType('array<array|string|false>', filter_var($mixed, FILTER_SANITIZE_EMAIL , ["flags" => $forceArrayFilter]));
+	assertType('array<array|FilterVar\Analyser|string>', filter_var($mixed, FILTER_SANITIZE_EMAIL , ["options" => ["default" => new Analyser], "flags" => FILTER_FORCE_ARRAY]));
+	assertType('array<array|FilterVar\Analyser|string>', filter_var($mixed, FILTER_SANITIZE_EMAIL , ["options" => ["default" => new Analyser], "flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
 	assertType('string|false', filter_var($mixed, FILTER_SANITIZE_ENCODED ));
 	assertType('mixed', filter_var($mixed, FILTER_SANITIZE_ENCODED , $mixed));
 	assertType('mixed', filter_var($mixed, FILTER_SANITIZE_ENCODED , ["flags" => $mixed]));
@@ -67,14 +67,14 @@ function () {
 	assertType('string|null', filter_var($mixed, FILTER_SANITIZE_ENCODED , ["flags" => FILTER_NULL_ON_FAILURE | FILTER_FLAG_IPV4]));
 	assertType('string|null', filter_var($mixed, FILTER_SANITIZE_ENCODED , ["flags" => $nullFilter]));
 	assertType('FilterVar\\Analyser|string', filter_var($mixed, FILTER_SANITIZE_ENCODED , ["options" => ["default" => new Analyser]]));
-	assertType('array<string|null>', filter_var($mixed, FILTER_SANITIZE_ENCODED , FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY));
-	assertType('array<string|null>', filter_var($mixed, FILTER_SANITIZE_ENCODED , FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY | FILTER_FLAG_IPV4));
-	assertType('array<string|false>', filter_var($mixed, FILTER_SANITIZE_ENCODED , FILTER_FORCE_ARRAY));
-	assertType('array<string|null>', filter_var($mixed, FILTER_SANITIZE_ENCODED , ["flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
-	assertType('array<string|false>', filter_var($mixed, FILTER_SANITIZE_ENCODED , ["flags" => FILTER_FORCE_ARRAY | FILTER_FLAG_IPV4]));
-	assertType('array<string|false>', filter_var($mixed, FILTER_SANITIZE_ENCODED , ["flags" => $forceArrayFilter]));
-	assertType('array<FilterVar\Analyser|string>', filter_var($mixed, FILTER_SANITIZE_ENCODED , ["options" => ["default" => new Analyser], "flags" => FILTER_FORCE_ARRAY]));
-	assertType('array<FilterVar\Analyser|string>', filter_var($mixed, FILTER_SANITIZE_ENCODED , ["options" => ["default" => new Analyser], "flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
+	assertType('array<array|string|null>', filter_var($mixed, FILTER_SANITIZE_ENCODED , FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY));
+	assertType('array<array|string|null>', filter_var($mixed, FILTER_SANITIZE_ENCODED , FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY | FILTER_FLAG_IPV4));
+	assertType('array<array|string|false>', filter_var($mixed, FILTER_SANITIZE_ENCODED , FILTER_FORCE_ARRAY));
+	assertType('array<array|string|null>', filter_var($mixed, FILTER_SANITIZE_ENCODED , ["flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
+	assertType('array<array|string|false>', filter_var($mixed, FILTER_SANITIZE_ENCODED , ["flags" => FILTER_FORCE_ARRAY | FILTER_FLAG_IPV4]));
+	assertType('array<array|string|false>', filter_var($mixed, FILTER_SANITIZE_ENCODED , ["flags" => $forceArrayFilter]));
+	assertType('array<array|FilterVar\Analyser|string>', filter_var($mixed, FILTER_SANITIZE_ENCODED , ["options" => ["default" => new Analyser], "flags" => FILTER_FORCE_ARRAY]));
+	assertType('array<array|FilterVar\Analyser|string>', filter_var($mixed, FILTER_SANITIZE_ENCODED , ["options" => ["default" => new Analyser], "flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
 	assertType('string|false', filter_var($mixed, FILTER_SANITIZE_NUMBER_FLOAT ));
 	assertType('mixed', filter_var($mixed, FILTER_SANITIZE_NUMBER_FLOAT , $mixed));
 	assertType('mixed', filter_var($mixed, FILTER_SANITIZE_NUMBER_FLOAT , ["flags" => $mixed]));
@@ -83,14 +83,14 @@ function () {
 	assertType('string|null', filter_var($mixed, FILTER_SANITIZE_NUMBER_FLOAT , ["flags" => FILTER_NULL_ON_FAILURE | FILTER_FLAG_IPV4]));
 	assertType('string|null', filter_var($mixed, FILTER_SANITIZE_NUMBER_FLOAT , ["flags" => $nullFilter]));
 	assertType('FilterVar\\Analyser|string', filter_var($mixed, FILTER_SANITIZE_NUMBER_FLOAT , ["options" => ["default" => new Analyser]]));
-	assertType('array<string|null>', filter_var($mixed, FILTER_SANITIZE_NUMBER_FLOAT , FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY));
-	assertType('array<string|null>', filter_var($mixed, FILTER_SANITIZE_NUMBER_FLOAT , FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY | FILTER_FLAG_IPV4));
-	assertType('array<string|false>', filter_var($mixed, FILTER_SANITIZE_NUMBER_FLOAT , FILTER_FORCE_ARRAY));
-	assertType('array<string|null>', filter_var($mixed, FILTER_SANITIZE_NUMBER_FLOAT , ["flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
-	assertType('array<string|false>', filter_var($mixed, FILTER_SANITIZE_NUMBER_FLOAT , ["flags" => FILTER_FORCE_ARRAY | FILTER_FLAG_IPV4]));
-	assertType('array<string|false>', filter_var($mixed, FILTER_SANITIZE_NUMBER_FLOAT , ["flags" => $forceArrayFilter]));
-	assertType('array<FilterVar\Analyser|string>', filter_var($mixed, FILTER_SANITIZE_NUMBER_FLOAT , ["options" => ["default" => new Analyser], "flags" => FILTER_FORCE_ARRAY]));
-	assertType('array<FilterVar\Analyser|string>', filter_var($mixed, FILTER_SANITIZE_NUMBER_FLOAT , ["options" => ["default" => new Analyser], "flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
+	assertType('array<array|string|null>', filter_var($mixed, FILTER_SANITIZE_NUMBER_FLOAT , FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY));
+	assertType('array<array|string|null>', filter_var($mixed, FILTER_SANITIZE_NUMBER_FLOAT , FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY | FILTER_FLAG_IPV4));
+	assertType('array<array|string|false>', filter_var($mixed, FILTER_SANITIZE_NUMBER_FLOAT , FILTER_FORCE_ARRAY));
+	assertType('array<array|string|null>', filter_var($mixed, FILTER_SANITIZE_NUMBER_FLOAT , ["flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
+	assertType('array<array|string|false>', filter_var($mixed, FILTER_SANITIZE_NUMBER_FLOAT , ["flags" => FILTER_FORCE_ARRAY | FILTER_FLAG_IPV4]));
+	assertType('array<array|string|false>', filter_var($mixed, FILTER_SANITIZE_NUMBER_FLOAT , ["flags" => $forceArrayFilter]));
+	assertType('array<array|FilterVar\Analyser|string>', filter_var($mixed, FILTER_SANITIZE_NUMBER_FLOAT , ["options" => ["default" => new Analyser], "flags" => FILTER_FORCE_ARRAY]));
+	assertType('array<array|FilterVar\Analyser|string>', filter_var($mixed, FILTER_SANITIZE_NUMBER_FLOAT , ["options" => ["default" => new Analyser], "flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
 	assertType('string|false', filter_var($mixed, FILTER_SANITIZE_NUMBER_INT ));
 	assertType('mixed', filter_var($mixed, FILTER_SANITIZE_NUMBER_INT , $mixed));
 	assertType('mixed', filter_var($mixed, FILTER_SANITIZE_NUMBER_INT , ["flags" => $mixed]));
@@ -99,14 +99,14 @@ function () {
 	assertType('string|null', filter_var($mixed, FILTER_SANITIZE_NUMBER_INT , ["flags" => FILTER_NULL_ON_FAILURE | FILTER_FLAG_IPV4]));
 	assertType('string|null', filter_var($mixed, FILTER_SANITIZE_NUMBER_INT , ["flags" => $nullFilter]));
 	assertType('FilterVar\\Analyser|string', filter_var($mixed, FILTER_SANITIZE_NUMBER_INT , ["options" => ["default" => new Analyser]]));
-	assertType('array<string|null>', filter_var($mixed, FILTER_SANITIZE_NUMBER_INT , FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY));
-	assertType('array<string|null>', filter_var($mixed, FILTER_SANITIZE_NUMBER_INT , FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY | FILTER_FLAG_IPV4));
-	assertType('array<string|false>', filter_var($mixed, FILTER_SANITIZE_NUMBER_INT , FILTER_FORCE_ARRAY));
-	assertType('array<string|null>', filter_var($mixed, FILTER_SANITIZE_NUMBER_INT , ["flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
-	assertType('array<string|false>', filter_var($mixed, FILTER_SANITIZE_NUMBER_INT , ["flags" => FILTER_FORCE_ARRAY | FILTER_FLAG_IPV4]));
-	assertType('array<string|false>', filter_var($mixed, FILTER_SANITIZE_NUMBER_INT , ["flags" => $forceArrayFilter]));
-	assertType('array<FilterVar\Analyser|string>', filter_var($mixed, FILTER_SANITIZE_NUMBER_INT , ["options" => ["default" => new Analyser], "flags" => FILTER_FORCE_ARRAY]));
-	assertType('array<FilterVar\Analyser|string>', filter_var($mixed, FILTER_SANITIZE_NUMBER_INT , ["options" => ["default" => new Analyser], "flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
+	assertType('array<array|string|null>', filter_var($mixed, FILTER_SANITIZE_NUMBER_INT , FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY));
+	assertType('array<array|string|null>', filter_var($mixed, FILTER_SANITIZE_NUMBER_INT , FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY | FILTER_FLAG_IPV4));
+	assertType('array<array|string|false>', filter_var($mixed, FILTER_SANITIZE_NUMBER_INT , FILTER_FORCE_ARRAY));
+	assertType('array<array|string|null>', filter_var($mixed, FILTER_SANITIZE_NUMBER_INT , ["flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
+	assertType('array<array|string|false>', filter_var($mixed, FILTER_SANITIZE_NUMBER_INT , ["flags" => FILTER_FORCE_ARRAY | FILTER_FLAG_IPV4]));
+	assertType('array<array|string|false>', filter_var($mixed, FILTER_SANITIZE_NUMBER_INT , ["flags" => $forceArrayFilter]));
+	assertType('array<array|FilterVar\Analyser|string>', filter_var($mixed, FILTER_SANITIZE_NUMBER_INT , ["options" => ["default" => new Analyser], "flags" => FILTER_FORCE_ARRAY]));
+	assertType('array<array|FilterVar\Analyser|string>', filter_var($mixed, FILTER_SANITIZE_NUMBER_INT , ["options" => ["default" => new Analyser], "flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
 	assertType('string|false', filter_var($mixed, FILTER_SANITIZE_SPECIAL_CHARS ));
 	assertType('mixed', filter_var($mixed, FILTER_SANITIZE_SPECIAL_CHARS , $mixed));
 	assertType('mixed', filter_var($mixed, FILTER_SANITIZE_SPECIAL_CHARS , ["flags" => $mixed]));
@@ -115,14 +115,14 @@ function () {
 	assertType('string|null', filter_var($mixed, FILTER_SANITIZE_SPECIAL_CHARS , ["flags" => FILTER_NULL_ON_FAILURE | FILTER_FLAG_IPV4]));
 	assertType('string|null', filter_var($mixed, FILTER_SANITIZE_SPECIAL_CHARS , ["flags" => $nullFilter]));
 	assertType('FilterVar\\Analyser|string', filter_var($mixed, FILTER_SANITIZE_SPECIAL_CHARS , ["options" => ["default" => new Analyser]]));
-	assertType('array<string|null>', filter_var($mixed, FILTER_SANITIZE_SPECIAL_CHARS , FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY));
-	assertType('array<string|null>', filter_var($mixed, FILTER_SANITIZE_SPECIAL_CHARS , FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY | FILTER_FLAG_IPV4));
-	assertType('array<string|false>', filter_var($mixed, FILTER_SANITIZE_SPECIAL_CHARS , FILTER_FORCE_ARRAY));
-	assertType('array<string|null>', filter_var($mixed, FILTER_SANITIZE_SPECIAL_CHARS , ["flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
-	assertType('array<string|false>', filter_var($mixed, FILTER_SANITIZE_SPECIAL_CHARS , ["flags" => FILTER_FORCE_ARRAY | FILTER_FLAG_IPV4]));
-	assertType('array<string|false>', filter_var($mixed, FILTER_SANITIZE_SPECIAL_CHARS , ["flags" => $forceArrayFilter]));
-	assertType('array<FilterVar\Analyser|string>', filter_var($mixed, FILTER_SANITIZE_SPECIAL_CHARS , ["options" => ["default" => new Analyser], "flags" => FILTER_FORCE_ARRAY]));
-	assertType('array<FilterVar\Analyser|string>', filter_var($mixed, FILTER_SANITIZE_SPECIAL_CHARS , ["options" => ["default" => new Analyser], "flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
+	assertType('array<array|string|null>', filter_var($mixed, FILTER_SANITIZE_SPECIAL_CHARS , FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY));
+	assertType('array<array|string|null>', filter_var($mixed, FILTER_SANITIZE_SPECIAL_CHARS , FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY | FILTER_FLAG_IPV4));
+	assertType('array<array|string|false>', filter_var($mixed, FILTER_SANITIZE_SPECIAL_CHARS , FILTER_FORCE_ARRAY));
+	assertType('array<array|string|null>', filter_var($mixed, FILTER_SANITIZE_SPECIAL_CHARS , ["flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
+	assertType('array<array|string|false>', filter_var($mixed, FILTER_SANITIZE_SPECIAL_CHARS , ["flags" => FILTER_FORCE_ARRAY | FILTER_FLAG_IPV4]));
+	assertType('array<array|string|false>', filter_var($mixed, FILTER_SANITIZE_SPECIAL_CHARS , ["flags" => $forceArrayFilter]));
+	assertType('array<array|FilterVar\Analyser|string>', filter_var($mixed, FILTER_SANITIZE_SPECIAL_CHARS , ["options" => ["default" => new Analyser], "flags" => FILTER_FORCE_ARRAY]));
+	assertType('array<array|FilterVar\Analyser|string>', filter_var($mixed, FILTER_SANITIZE_SPECIAL_CHARS , ["options" => ["default" => new Analyser], "flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
 	assertType('string|false', filter_var($mixed, FILTER_SANITIZE_STRING ));
 	assertType('mixed', filter_var($mixed, FILTER_SANITIZE_STRING , $mixed));
 	assertType('mixed', filter_var($mixed, FILTER_SANITIZE_STRING , ["flags" => $mixed]));
@@ -131,14 +131,14 @@ function () {
 	assertType('string|null', filter_var($mixed, FILTER_SANITIZE_STRING , ["flags" => FILTER_NULL_ON_FAILURE | FILTER_FLAG_IPV4]));
 	assertType('string|null', filter_var($mixed, FILTER_SANITIZE_STRING , ["flags" => $nullFilter]));
 	assertType('FilterVar\\Analyser|string', filter_var($mixed, FILTER_SANITIZE_STRING , ["options" => ["default" => new Analyser]]));
-	assertType('array<string|null>', filter_var($mixed, FILTER_SANITIZE_STRING , FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY));
-	assertType('array<string|null>', filter_var($mixed, FILTER_SANITIZE_STRING , FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY | FILTER_FLAG_IPV4));
-	assertType('array<string|false>', filter_var($mixed, FILTER_SANITIZE_STRING , FILTER_FORCE_ARRAY));
-	assertType('array<string|null>', filter_var($mixed, FILTER_SANITIZE_STRING , ["flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
-	assertType('array<string|false>', filter_var($mixed, FILTER_SANITIZE_STRING , ["flags" => FILTER_FORCE_ARRAY | FILTER_FLAG_IPV4]));
-	assertType('array<string|false>', filter_var($mixed, FILTER_SANITIZE_STRING , ["flags" => $forceArrayFilter]));
-	assertType('array<FilterVar\Analyser|string>', filter_var($mixed, FILTER_SANITIZE_STRING , ["options" => ["default" => new Analyser], "flags" => FILTER_FORCE_ARRAY]));
-	assertType('array<FilterVar\Analyser|string>', filter_var($mixed, FILTER_SANITIZE_STRING , ["options" => ["default" => new Analyser], "flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
+	assertType('array<array|string|null>', filter_var($mixed, FILTER_SANITIZE_STRING , FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY));
+	assertType('array<array|string|null>', filter_var($mixed, FILTER_SANITIZE_STRING , FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY | FILTER_FLAG_IPV4));
+	assertType('array<array|string|false>', filter_var($mixed, FILTER_SANITIZE_STRING , FILTER_FORCE_ARRAY));
+	assertType('array<array|string|null>', filter_var($mixed, FILTER_SANITIZE_STRING , ["flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
+	assertType('array<array|string|false>', filter_var($mixed, FILTER_SANITIZE_STRING , ["flags" => FILTER_FORCE_ARRAY | FILTER_FLAG_IPV4]));
+	assertType('array<array|string|false>', filter_var($mixed, FILTER_SANITIZE_STRING , ["flags" => $forceArrayFilter]));
+	assertType('array<array|FilterVar\Analyser|string>', filter_var($mixed, FILTER_SANITIZE_STRING , ["options" => ["default" => new Analyser], "flags" => FILTER_FORCE_ARRAY]));
+	assertType('array<array|FilterVar\Analyser|string>', filter_var($mixed, FILTER_SANITIZE_STRING , ["options" => ["default" => new Analyser], "flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
 	assertType('string|false', filter_var($mixed, FILTER_SANITIZE_URL ));
 	assertType('mixed', filter_var($mixed, FILTER_SANITIZE_URL , $mixed));
 	assertType('mixed', filter_var($mixed, FILTER_SANITIZE_URL , ["flags" => $mixed]));
@@ -147,14 +147,14 @@ function () {
 	assertType('string|null', filter_var($mixed, FILTER_SANITIZE_URL , ["flags" => FILTER_NULL_ON_FAILURE | FILTER_FLAG_IPV4]));
 	assertType('string|null', filter_var($mixed, FILTER_SANITIZE_URL , ["flags" => $nullFilter]));
 	assertType('FilterVar\\Analyser|string', filter_var($mixed, FILTER_SANITIZE_URL , ["options" => ["default" => new Analyser]]));
-	assertType('array<string|null>', filter_var($mixed, FILTER_SANITIZE_URL , FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY));
-	assertType('array<string|null>', filter_var($mixed, FILTER_SANITIZE_URL , FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY | FILTER_FLAG_IPV4));
-	assertType('array<string|false>', filter_var($mixed, FILTER_SANITIZE_URL , FILTER_FORCE_ARRAY));
-	assertType('array<string|null>', filter_var($mixed, FILTER_SANITIZE_URL , ["flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
-	assertType('array<string|false>', filter_var($mixed, FILTER_SANITIZE_URL , ["flags" => FILTER_FORCE_ARRAY | FILTER_FLAG_IPV4]));
-	assertType('array<string|false>', filter_var($mixed, FILTER_SANITIZE_URL , ["flags" => $forceArrayFilter]));
-	assertType('array<FilterVar\Analyser|string>', filter_var($mixed, FILTER_SANITIZE_URL , ["options" => ["default" => new Analyser], "flags" => FILTER_FORCE_ARRAY]));
-	assertType('array<FilterVar\Analyser|string>', filter_var($mixed, FILTER_SANITIZE_URL , ["options" => ["default" => new Analyser], "flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
+	assertType('array<array|string|null>', filter_var($mixed, FILTER_SANITIZE_URL , FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY));
+	assertType('array<array|string|null>', filter_var($mixed, FILTER_SANITIZE_URL , FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY | FILTER_FLAG_IPV4));
+	assertType('array<array|string|false>', filter_var($mixed, FILTER_SANITIZE_URL , FILTER_FORCE_ARRAY));
+	assertType('array<array|string|null>', filter_var($mixed, FILTER_SANITIZE_URL , ["flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
+	assertType('array<array|string|false>', filter_var($mixed, FILTER_SANITIZE_URL , ["flags" => FILTER_FORCE_ARRAY | FILTER_FLAG_IPV4]));
+	assertType('array<array|string|false>', filter_var($mixed, FILTER_SANITIZE_URL , ["flags" => $forceArrayFilter]));
+	assertType('array<array|FilterVar\Analyser|string>', filter_var($mixed, FILTER_SANITIZE_URL , ["options" => ["default" => new Analyser], "flags" => FILTER_FORCE_ARRAY]));
+	assertType('array<array|FilterVar\Analyser|string>', filter_var($mixed, FILTER_SANITIZE_URL , ["options" => ["default" => new Analyser], "flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
 	assertType('string|false', filter_var($mixed, FILTER_VALIDATE_REGEXP ));
 	assertType('mixed', filter_var($mixed, FILTER_VALIDATE_REGEXP , $mixed));
 	assertType('mixed', filter_var($mixed, FILTER_VALIDATE_REGEXP , ["flags" => $mixed]));
@@ -163,14 +163,14 @@ function () {
 	assertType('string|null', filter_var($mixed, FILTER_VALIDATE_REGEXP , ["flags" => FILTER_NULL_ON_FAILURE | FILTER_FLAG_IPV4]));
 	assertType('string|null', filter_var($mixed, FILTER_VALIDATE_REGEXP , ["flags" => $nullFilter]));
 	assertType('FilterVar\\Analyser|string', filter_var($mixed, FILTER_VALIDATE_REGEXP , ["options" => ["default" => new Analyser]]));
-	assertType('array<string|null>', filter_var($mixed, FILTER_VALIDATE_REGEXP , FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY));
-	assertType('array<string|null>', filter_var($mixed, FILTER_VALIDATE_REGEXP , FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY | FILTER_FLAG_IPV4));
-	assertType('array<string|false>', filter_var($mixed, FILTER_VALIDATE_REGEXP , FILTER_FORCE_ARRAY));
-	assertType('array<string|null>', filter_var($mixed, FILTER_VALIDATE_REGEXP , ["flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
-	assertType('array<string|false>', filter_var($mixed, FILTER_VALIDATE_REGEXP , ["flags" => FILTER_FORCE_ARRAY | FILTER_FLAG_IPV4]));
-	assertType('array<string|false>', filter_var($mixed, FILTER_VALIDATE_REGEXP , ["flags" => $forceArrayFilter]));
-	assertType('array<FilterVar\Analyser|string>', filter_var($mixed, FILTER_VALIDATE_REGEXP , ["options" => ["default" => new Analyser], "flags" => FILTER_FORCE_ARRAY]));
-	assertType('array<FilterVar\Analyser|string>', filter_var($mixed, FILTER_VALIDATE_REGEXP , ["options" => ["default" => new Analyser], "flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
+	assertType('array<array|string|null>', filter_var($mixed, FILTER_VALIDATE_REGEXP , FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY));
+	assertType('array<array|string|null>', filter_var($mixed, FILTER_VALIDATE_REGEXP , FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY | FILTER_FLAG_IPV4));
+	assertType('array<array|string|false>', filter_var($mixed, FILTER_VALIDATE_REGEXP , FILTER_FORCE_ARRAY));
+	assertType('array<array|string|null>', filter_var($mixed, FILTER_VALIDATE_REGEXP , ["flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
+	assertType('array<array|string|false>', filter_var($mixed, FILTER_VALIDATE_REGEXP , ["flags" => FILTER_FORCE_ARRAY | FILTER_FLAG_IPV4]));
+	assertType('array<array|string|false>', filter_var($mixed, FILTER_VALIDATE_REGEXP , ["flags" => $forceArrayFilter]));
+	assertType('array<array|FilterVar\Analyser|string>', filter_var($mixed, FILTER_VALIDATE_REGEXP , ["options" => ["default" => new Analyser], "flags" => FILTER_FORCE_ARRAY]));
+	assertType('array<array|FilterVar\Analyser|string>', filter_var($mixed, FILTER_VALIDATE_REGEXP , ["options" => ["default" => new Analyser], "flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
 	assertType('string|false', filter_var($mixed, FILTER_SANITIZE_ADD_SLASHES ));
 	assertType('mixed', filter_var($mixed, FILTER_SANITIZE_ADD_SLASHES , $mixed));
 	assertType('mixed', filter_var($mixed, FILTER_SANITIZE_ADD_SLASHES , ["flags" => $mixed]));
@@ -179,14 +179,14 @@ function () {
 	assertType('string|null', filter_var($mixed, FILTER_SANITIZE_ADD_SLASHES , ["flags" => FILTER_NULL_ON_FAILURE | FILTER_FLAG_IPV4]));
 	assertType('string|null', filter_var($mixed, FILTER_SANITIZE_ADD_SLASHES , ["flags" => $nullFilter]));
 	assertType('FilterVar\\Analyser|string', filter_var($mixed, FILTER_SANITIZE_ADD_SLASHES , ["options" => ["default" => new Analyser]]));
-	assertType('array<string|null>', filter_var($mixed, FILTER_SANITIZE_ADD_SLASHES , FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY));
-	assertType('array<string|null>', filter_var($mixed, FILTER_SANITIZE_ADD_SLASHES , FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY | FILTER_FLAG_IPV4));
-	assertType('array<string|false>', filter_var($mixed, FILTER_SANITIZE_ADD_SLASHES , FILTER_FORCE_ARRAY));
-	assertType('array<string|null>', filter_var($mixed, FILTER_SANITIZE_ADD_SLASHES , ["flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
-	assertType('array<string|false>', filter_var($mixed, FILTER_SANITIZE_ADD_SLASHES , ["flags" => FILTER_FORCE_ARRAY | FILTER_FLAG_IPV4]));
-	assertType('array<string|false>', filter_var($mixed, FILTER_SANITIZE_ADD_SLASHES , ["flags" => $forceArrayFilter]));
-	assertType('array<FilterVar\Analyser|string>', filter_var($mixed, FILTER_SANITIZE_ADD_SLASHES , ["options" => ["default" => new Analyser], "flags" => FILTER_FORCE_ARRAY]));
-	assertType('array<FilterVar\Analyser|string>', filter_var($mixed, FILTER_SANITIZE_ADD_SLASHES , ["options" => ["default" => new Analyser], "flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
+	assertType('array<array|string|null>', filter_var($mixed, FILTER_SANITIZE_ADD_SLASHES , FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY));
+	assertType('array<array|string|null>', filter_var($mixed, FILTER_SANITIZE_ADD_SLASHES , FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY | FILTER_FLAG_IPV4));
+	assertType('array<array|string|false>', filter_var($mixed, FILTER_SANITIZE_ADD_SLASHES , FILTER_FORCE_ARRAY));
+	assertType('array<array|string|null>', filter_var($mixed, FILTER_SANITIZE_ADD_SLASHES , ["flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
+	assertType('array<array|string|false>', filter_var($mixed, FILTER_SANITIZE_ADD_SLASHES , ["flags" => FILTER_FORCE_ARRAY | FILTER_FLAG_IPV4]));
+	assertType('array<array|string|false>', filter_var($mixed, FILTER_SANITIZE_ADD_SLASHES , ["flags" => $forceArrayFilter]));
+	assertType('array<array|FilterVar\Analyser|string>', filter_var($mixed, FILTER_SANITIZE_ADD_SLASHES , ["options" => ["default" => new Analyser], "flags" => FILTER_FORCE_ARRAY]));
+	assertType('array<array|FilterVar\Analyser|string>', filter_var($mixed, FILTER_SANITIZE_ADD_SLASHES , ["options" => ["default" => new Analyser], "flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
 	assertType('non-falsy-string|false', filter_var($mixed, FILTER_VALIDATE_EMAIL ));
 	assertType('mixed', filter_var($mixed, FILTER_VALIDATE_EMAIL , $mixed));
 	assertType('mixed', filter_var($mixed, FILTER_VALIDATE_EMAIL , ["flags" => $mixed]));
@@ -195,14 +195,14 @@ function () {
 	assertType('non-falsy-string|null', filter_var($mixed, FILTER_VALIDATE_EMAIL , ["flags" => FILTER_NULL_ON_FAILURE | FILTER_FLAG_IPV4]));
 	assertType('non-falsy-string|null', filter_var($mixed, FILTER_VALIDATE_EMAIL , ["flags" => $nullFilter]));
 	assertType('FilterVar\\Analyser|non-falsy-string', filter_var($mixed, FILTER_VALIDATE_EMAIL , ["options" => ["default" => new Analyser]]));
-	assertType('array<non-falsy-string|null>', filter_var($mixed, FILTER_VALIDATE_EMAIL , FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY));
-	assertType('array<non-falsy-string|null>', filter_var($mixed, FILTER_VALIDATE_EMAIL , FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY | FILTER_FLAG_IPV4));
-	assertType('array<non-falsy-string|false>', filter_var($mixed, FILTER_VALIDATE_EMAIL , FILTER_FORCE_ARRAY));
-	assertType('array<non-falsy-string|null>', filter_var($mixed, FILTER_VALIDATE_EMAIL , ["flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
-	assertType('array<non-falsy-string|false>', filter_var($mixed, FILTER_VALIDATE_EMAIL , ["flags" => FILTER_FORCE_ARRAY | FILTER_FLAG_IPV4]));
-	assertType('array<non-falsy-string|false>', filter_var($mixed, FILTER_VALIDATE_EMAIL , ["flags" => $forceArrayFilter]));
-	assertType('array<FilterVar\Analyser|non-falsy-string>', filter_var($mixed, FILTER_VALIDATE_EMAIL , ["options" => ["default" => new Analyser], "flags" => FILTER_FORCE_ARRAY]));
-	assertType('array<FilterVar\Analyser|non-falsy-string>', filter_var($mixed, FILTER_VALIDATE_EMAIL , ["options" => ["default" => new Analyser], "flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
+	assertType('array<array|non-falsy-string|null>', filter_var($mixed, FILTER_VALIDATE_EMAIL , FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY));
+	assertType('array<array|non-falsy-string|null>', filter_var($mixed, FILTER_VALIDATE_EMAIL , FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY | FILTER_FLAG_IPV4));
+	assertType('array<array|non-falsy-string|false>', filter_var($mixed, FILTER_VALIDATE_EMAIL , FILTER_FORCE_ARRAY));
+	assertType('array<array|non-falsy-string|null>', filter_var($mixed, FILTER_VALIDATE_EMAIL , ["flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
+	assertType('array<array|non-falsy-string|false>', filter_var($mixed, FILTER_VALIDATE_EMAIL , ["flags" => FILTER_FORCE_ARRAY | FILTER_FLAG_IPV4]));
+	assertType('array<array|non-falsy-string|false>', filter_var($mixed, FILTER_VALIDATE_EMAIL , ["flags" => $forceArrayFilter]));
+	assertType('array<array|FilterVar\Analyser|non-falsy-string>', filter_var($mixed, FILTER_VALIDATE_EMAIL , ["options" => ["default" => new Analyser], "flags" => FILTER_FORCE_ARRAY]));
+	assertType('array<array|FilterVar\Analyser|non-falsy-string>', filter_var($mixed, FILTER_VALIDATE_EMAIL , ["options" => ["default" => new Analyser], "flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
 	assertType('non-falsy-string|false', filter_var($mixed, FILTER_VALIDATE_IP ));
 	assertType('mixed', filter_var($mixed, FILTER_VALIDATE_IP , $mixed));
 	assertType('mixed', filter_var($mixed, FILTER_VALIDATE_IP , ["flags" => $mixed]));
@@ -211,14 +211,14 @@ function () {
 	assertType('non-falsy-string|null', filter_var($mixed, FILTER_VALIDATE_IP , ["flags" => FILTER_NULL_ON_FAILURE | FILTER_FLAG_IPV4]));
 	assertType('non-falsy-string|null', filter_var($mixed, FILTER_VALIDATE_IP , ["flags" => $nullFilter]));
 	assertType('FilterVar\\Analyser|non-falsy-string', filter_var($mixed, FILTER_VALIDATE_IP , ["options" => ["default" => new Analyser]]));
-	assertType('array<non-falsy-string|null>', filter_var($mixed, FILTER_VALIDATE_IP , FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY));
-	assertType('array<non-falsy-string|null>', filter_var($mixed, FILTER_VALIDATE_IP , FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY | FILTER_FLAG_IPV4));
-	assertType('array<non-falsy-string|false>', filter_var($mixed, FILTER_VALIDATE_IP , FILTER_FORCE_ARRAY));
-	assertType('array<non-falsy-string|null>', filter_var($mixed, FILTER_VALIDATE_IP , ["flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
-	assertType('array<non-falsy-string|false>', filter_var($mixed, FILTER_VALIDATE_IP , ["flags" => FILTER_FORCE_ARRAY | FILTER_FLAG_IPV4]));
-	assertType('array<non-falsy-string|false>', filter_var($mixed, FILTER_VALIDATE_IP , ["flags" => $forceArrayFilter]));
-	assertType('array<FilterVar\Analyser|non-falsy-string>', filter_var($mixed, FILTER_VALIDATE_IP , ["options" => ["default" => new Analyser], "flags" => FILTER_FORCE_ARRAY]));
-	assertType('array<FilterVar\Analyser|non-falsy-string>', filter_var($mixed, FILTER_VALIDATE_IP , ["options" => ["default" => new Analyser], "flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
+	assertType('array<array|non-falsy-string|null>', filter_var($mixed, FILTER_VALIDATE_IP , FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY));
+	assertType('array<array|non-falsy-string|null>', filter_var($mixed, FILTER_VALIDATE_IP , FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY | FILTER_FLAG_IPV4));
+	assertType('array<array|non-falsy-string|false>', filter_var($mixed, FILTER_VALIDATE_IP , FILTER_FORCE_ARRAY));
+	assertType('array<array|non-falsy-string|null>', filter_var($mixed, FILTER_VALIDATE_IP , ["flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
+	assertType('array<array|non-falsy-string|false>', filter_var($mixed, FILTER_VALIDATE_IP , ["flags" => FILTER_FORCE_ARRAY | FILTER_FLAG_IPV4]));
+	assertType('array<array|non-falsy-string|false>', filter_var($mixed, FILTER_VALIDATE_IP , ["flags" => $forceArrayFilter]));
+	assertType('array<array|FilterVar\Analyser|non-falsy-string>', filter_var($mixed, FILTER_VALIDATE_IP , ["options" => ["default" => new Analyser], "flags" => FILTER_FORCE_ARRAY]));
+	assertType('array<array|FilterVar\Analyser|non-falsy-string>', filter_var($mixed, FILTER_VALIDATE_IP , ["options" => ["default" => new Analyser], "flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
 	assertType('non-falsy-string|false', filter_var($mixed, $filterIp ));
 	assertType('mixed', filter_var($mixed, $filterIp , $mixed));
 	assertType('mixed', filter_var($mixed, $filterIp , ["flags" => $mixed]));
@@ -227,14 +227,14 @@ function () {
 	assertType('non-falsy-string|null', filter_var($mixed, $filterIp , ["flags" => FILTER_NULL_ON_FAILURE | FILTER_FLAG_IPV4]));
 	assertType('non-falsy-string|null', filter_var($mixed, $filterIp , ["flags" => $nullFilter]));
 	assertType('FilterVar\\Analyser|non-falsy-string', filter_var($mixed, $filterIp , ["options" => ["default" => new Analyser]]));
-	assertType('array<non-falsy-string|null>', filter_var($mixed, $filterIp , FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY));
-	assertType('array<non-falsy-string|null>', filter_var($mixed, $filterIp , FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY | FILTER_FLAG_IPV4));
-	assertType('array<non-falsy-string|false>', filter_var($mixed, $filterIp , FILTER_FORCE_ARRAY));
-	assertType('array<non-falsy-string|null>', filter_var($mixed, $filterIp , ["flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
-	assertType('array<non-falsy-string|false>', filter_var($mixed, $filterIp , ["flags" => FILTER_FORCE_ARRAY | FILTER_FLAG_IPV4]));
-	assertType('array<non-falsy-string|false>', filter_var($mixed, $filterIp , ["flags" => $forceArrayFilter]));
-	assertType('array<FilterVar\Analyser|non-falsy-string>', filter_var($mixed, $filterIp , ["options" => ["default" => new Analyser], "flags" => FILTER_FORCE_ARRAY]));
-	assertType('array<FilterVar\Analyser|non-falsy-string>', filter_var($mixed, $filterIp , ["options" => ["default" => new Analyser], "flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
+	assertType('array<array|non-falsy-string|null>', filter_var($mixed, $filterIp , FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY));
+	assertType('array<array|non-falsy-string|null>', filter_var($mixed, $filterIp , FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY | FILTER_FLAG_IPV4));
+	assertType('array<array|non-falsy-string|false>', filter_var($mixed, $filterIp , FILTER_FORCE_ARRAY));
+	assertType('array<array|non-falsy-string|null>', filter_var($mixed, $filterIp , ["flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
+	assertType('array<array|non-falsy-string|false>', filter_var($mixed, $filterIp , ["flags" => FILTER_FORCE_ARRAY | FILTER_FLAG_IPV4]));
+	assertType('array<array|non-falsy-string|false>', filter_var($mixed, $filterIp , ["flags" => $forceArrayFilter]));
+	assertType('array<array|FilterVar\Analyser|non-falsy-string>', filter_var($mixed, $filterIp , ["options" => ["default" => new Analyser], "flags" => FILTER_FORCE_ARRAY]));
+	assertType('array<array|FilterVar\Analyser|non-falsy-string>', filter_var($mixed, $filterIp , ["options" => ["default" => new Analyser], "flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
 	assertType('non-falsy-string|false', filter_var($mixed, FILTER_VALIDATE_MAC ));
 	assertType('mixed', filter_var($mixed, FILTER_VALIDATE_MAC , $mixed));
 	assertType('mixed', filter_var($mixed, FILTER_VALIDATE_MAC , ["flags" => $mixed]));
@@ -243,14 +243,14 @@ function () {
 	assertType('non-falsy-string|null', filter_var($mixed, FILTER_VALIDATE_MAC , ["flags" => FILTER_NULL_ON_FAILURE | FILTER_FLAG_IPV4]));
 	assertType('non-falsy-string|null', filter_var($mixed, FILTER_VALIDATE_MAC , ["flags" => $nullFilter]));
 	assertType('FilterVar\\Analyser|non-falsy-string', filter_var($mixed, FILTER_VALIDATE_MAC , ["options" => ["default" => new Analyser]]));
-	assertType('array<non-falsy-string|null>', filter_var($mixed, FILTER_VALIDATE_MAC , FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY));
-	assertType('array<non-falsy-string|null>', filter_var($mixed, FILTER_VALIDATE_MAC , FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY | FILTER_FLAG_IPV4));
-	assertType('array<non-falsy-string|false>', filter_var($mixed, FILTER_VALIDATE_MAC , FILTER_FORCE_ARRAY));
-	assertType('array<non-falsy-string|null>', filter_var($mixed, FILTER_VALIDATE_MAC , ["flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
-	assertType('array<non-falsy-string|false>', filter_var($mixed, FILTER_VALIDATE_MAC , ["flags" => FILTER_FORCE_ARRAY | FILTER_FLAG_IPV4]));
-	assertType('array<non-falsy-string|false>', filter_var($mixed, FILTER_VALIDATE_MAC , ["flags" => $forceArrayFilter]));
-	assertType('array<FilterVar\Analyser|non-falsy-string>', filter_var($mixed, FILTER_VALIDATE_MAC , ["options" => ["default" => new Analyser], "flags" => FILTER_FORCE_ARRAY]));
-	assertType('array<FilterVar\Analyser|non-falsy-string>', filter_var($mixed, FILTER_VALIDATE_MAC , ["options" => ["default" => new Analyser], "flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
+	assertType('array<array|non-falsy-string|null>', filter_var($mixed, FILTER_VALIDATE_MAC , FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY));
+	assertType('array<array|non-falsy-string|null>', filter_var($mixed, FILTER_VALIDATE_MAC , FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY | FILTER_FLAG_IPV4));
+	assertType('array<array|non-falsy-string|false>', filter_var($mixed, FILTER_VALIDATE_MAC , FILTER_FORCE_ARRAY));
+	assertType('array<array|non-falsy-string|null>', filter_var($mixed, FILTER_VALIDATE_MAC , ["flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
+	assertType('array<array|non-falsy-string|false>', filter_var($mixed, FILTER_VALIDATE_MAC , ["flags" => FILTER_FORCE_ARRAY | FILTER_FLAG_IPV4]));
+	assertType('array<array|non-falsy-string|false>', filter_var($mixed, FILTER_VALIDATE_MAC , ["flags" => $forceArrayFilter]));
+	assertType('array<array|FilterVar\Analyser|non-falsy-string>', filter_var($mixed, FILTER_VALIDATE_MAC , ["options" => ["default" => new Analyser], "flags" => FILTER_FORCE_ARRAY]));
+	assertType('array<array|FilterVar\Analyser|non-falsy-string>', filter_var($mixed, FILTER_VALIDATE_MAC , ["options" => ["default" => new Analyser], "flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
 	assertType('non-falsy-string|false', filter_var($mixed, FILTER_VALIDATE_URL ));
 	assertType('mixed', filter_var($mixed, FILTER_VALIDATE_URL , $mixed));
 	assertType('mixed', filter_var($mixed, FILTER_VALIDATE_URL , ["flags" => $mixed]));
@@ -259,14 +259,14 @@ function () {
 	assertType('non-falsy-string|null', filter_var($mixed, FILTER_VALIDATE_URL , ["flags" => FILTER_NULL_ON_FAILURE | FILTER_FLAG_IPV4]));
 	assertType('non-falsy-string|null', filter_var($mixed, FILTER_VALIDATE_URL , ["flags" => $nullFilter]));
 	assertType('FilterVar\\Analyser|non-falsy-string', filter_var($mixed, FILTER_VALIDATE_URL , ["options" => ["default" => new Analyser]]));
-	assertType('array<non-falsy-string|null>', filter_var($mixed, FILTER_VALIDATE_URL , FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY));
-	assertType('array<non-falsy-string|null>', filter_var($mixed, FILTER_VALIDATE_URL , FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY | FILTER_FLAG_IPV4));
-	assertType('array<non-falsy-string|false>', filter_var($mixed, FILTER_VALIDATE_URL , FILTER_FORCE_ARRAY));
-	assertType('array<non-falsy-string|null>', filter_var($mixed, FILTER_VALIDATE_URL , ["flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
-	assertType('array<non-falsy-string|false>', filter_var($mixed, FILTER_VALIDATE_URL , ["flags" => FILTER_FORCE_ARRAY | FILTER_FLAG_IPV4]));
-	assertType('array<non-falsy-string|false>', filter_var($mixed, FILTER_VALIDATE_URL , ["flags" => $forceArrayFilter]));
-	assertType('array<FilterVar\Analyser|non-falsy-string>', filter_var($mixed, FILTER_VALIDATE_URL , ["options" => ["default" => new Analyser], "flags" => FILTER_FORCE_ARRAY]));
-	assertType('array<FilterVar\Analyser|non-falsy-string>', filter_var($mixed, FILTER_VALIDATE_URL , ["options" => ["default" => new Analyser], "flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
+	assertType('array<array|non-falsy-string|null>', filter_var($mixed, FILTER_VALIDATE_URL , FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY));
+	assertType('array<array|non-falsy-string|null>', filter_var($mixed, FILTER_VALIDATE_URL , FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY | FILTER_FLAG_IPV4));
+	assertType('array<array|non-falsy-string|false>', filter_var($mixed, FILTER_VALIDATE_URL , FILTER_FORCE_ARRAY));
+	assertType('array<array|non-falsy-string|null>', filter_var($mixed, FILTER_VALIDATE_URL , ["flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
+	assertType('array<array|non-falsy-string|false>', filter_var($mixed, FILTER_VALIDATE_URL , ["flags" => FILTER_FORCE_ARRAY | FILTER_FLAG_IPV4]));
+	assertType('array<array|non-falsy-string|false>', filter_var($mixed, FILTER_VALIDATE_URL , ["flags" => $forceArrayFilter]));
+	assertType('array<array|FilterVar\Analyser|non-falsy-string>', filter_var($mixed, FILTER_VALIDATE_URL , ["options" => ["default" => new Analyser], "flags" => FILTER_FORCE_ARRAY]));
+	assertType('array<array|FilterVar\Analyser|non-falsy-string>', filter_var($mixed, FILTER_VALIDATE_URL , ["options" => ["default" => new Analyser], "flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
 	assertType('int|false', filter_var($mixed, FILTER_VALIDATE_INT ));
 	assertType('mixed', filter_var($mixed, FILTER_VALIDATE_INT , $mixed));
 	assertType('mixed', filter_var($mixed, FILTER_VALIDATE_INT , ["flags" => $mixed]));
@@ -275,14 +275,14 @@ function () {
 	assertType('int|null', filter_var($mixed, FILTER_VALIDATE_INT , ["flags" => FILTER_NULL_ON_FAILURE | FILTER_FLAG_IPV4]));
 	assertType('int|null', filter_var($mixed, FILTER_VALIDATE_INT , ["flags" => $nullFilter]));
 	assertType('FilterVar\\Analyser|int', filter_var($mixed, FILTER_VALIDATE_INT , ["options" => ["default" => new Analyser]]));
-	assertType('array<int|null>', filter_var($mixed, FILTER_VALIDATE_INT , FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY));
-	assertType('array<int|null>', filter_var($mixed, FILTER_VALIDATE_INT , FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY | FILTER_FLAG_IPV4));
-	assertType('array<int|false>', filter_var($mixed, FILTER_VALIDATE_INT , FILTER_FORCE_ARRAY));
-	assertType('array<int|null>', filter_var($mixed, FILTER_VALIDATE_INT , ["flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
-	assertType('array<int|false>', filter_var($mixed, FILTER_VALIDATE_INT , ["flags" => FILTER_FORCE_ARRAY | FILTER_FLAG_IPV4]));
-	assertType('array<int|false>', filter_var($mixed, FILTER_VALIDATE_INT , ["flags" => $forceArrayFilter]));
-	assertType('array<FilterVar\Analyser|int>', filter_var($mixed, FILTER_VALIDATE_INT , ["options" => ["default" => new Analyser], "flags" => FILTER_FORCE_ARRAY]));
-	assertType('array<FilterVar\Analyser|int>', filter_var($mixed, FILTER_VALIDATE_INT , ["options" => ["default" => new Analyser], "flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
+	assertType('array<array|int|null>', filter_var($mixed, FILTER_VALIDATE_INT , FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY));
+	assertType('array<array|int|null>', filter_var($mixed, FILTER_VALIDATE_INT , FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY | FILTER_FLAG_IPV4));
+	assertType('array<array|int|false>', filter_var($mixed, FILTER_VALIDATE_INT , FILTER_FORCE_ARRAY));
+	assertType('array<array|int|null>', filter_var($mixed, FILTER_VALIDATE_INT , ["flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
+	assertType('array<array|int|false>', filter_var($mixed, FILTER_VALIDATE_INT , ["flags" => FILTER_FORCE_ARRAY | FILTER_FLAG_IPV4]));
+	assertType('array<array|int|false>', filter_var($mixed, FILTER_VALIDATE_INT , ["flags" => $forceArrayFilter]));
+	assertType('array<array|FilterVar\Analyser|int>', filter_var($mixed, FILTER_VALIDATE_INT , ["options" => ["default" => new Analyser], "flags" => FILTER_FORCE_ARRAY]));
+	assertType('array<array|FilterVar\Analyser|int>', filter_var($mixed, FILTER_VALIDATE_INT , ["options" => ["default" => new Analyser], "flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
 	assertType('float|false', filter_var($mixed, FILTER_VALIDATE_FLOAT ));
 	assertType('mixed', filter_var($mixed, FILTER_VALIDATE_FLOAT , $mixed));
 	assertType('mixed', filter_var($mixed, FILTER_VALIDATE_FLOAT , ["flags" => $mixed]));
@@ -291,14 +291,14 @@ function () {
 	assertType('float|null', filter_var($mixed, FILTER_VALIDATE_FLOAT , ["flags" => FILTER_NULL_ON_FAILURE | FILTER_FLAG_IPV4]));
 	assertType('float|null', filter_var($mixed, FILTER_VALIDATE_FLOAT , ["flags" => $nullFilter]));
 	assertType('FilterVar\\Analyser|float', filter_var($mixed, FILTER_VALIDATE_FLOAT , ["options" => ["default" => new Analyser]]));
-	assertType('array<float|null>', filter_var($mixed, FILTER_VALIDATE_FLOAT , FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY));
-	assertType('array<float|null>', filter_var($mixed, FILTER_VALIDATE_FLOAT , FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY | FILTER_FLAG_IPV4));
-	assertType('array<float|false>', filter_var($mixed, FILTER_VALIDATE_FLOAT , FILTER_FORCE_ARRAY));
-	assertType('array<float|null>', filter_var($mixed, FILTER_VALIDATE_FLOAT , ["flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
-	assertType('array<float|false>', filter_var($mixed, FILTER_VALIDATE_FLOAT , ["flags" => FILTER_FORCE_ARRAY | FILTER_FLAG_IPV4]));
-	assertType('array<float|false>', filter_var($mixed, FILTER_VALIDATE_FLOAT , ["flags" => $forceArrayFilter]));
-	assertType('array<FilterVar\Analyser|float>', filter_var($mixed, FILTER_VALIDATE_FLOAT , ["options" => ["default" => new Analyser], "flags" => FILTER_FORCE_ARRAY]));
-	assertType('array<FilterVar\Analyser|float>', filter_var($mixed, FILTER_VALIDATE_FLOAT , ["options" => ["default" => new Analyser], "flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
+	assertType('array<array|float|null>', filter_var($mixed, FILTER_VALIDATE_FLOAT , FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY));
+	assertType('array<array|float|null>', filter_var($mixed, FILTER_VALIDATE_FLOAT , FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY | FILTER_FLAG_IPV4));
+	assertType('array<array|float|false>', filter_var($mixed, FILTER_VALIDATE_FLOAT , FILTER_FORCE_ARRAY));
+	assertType('array<array|float|null>', filter_var($mixed, FILTER_VALIDATE_FLOAT , ["flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
+	assertType('array<array|float|false>', filter_var($mixed, FILTER_VALIDATE_FLOAT , ["flags" => FILTER_FORCE_ARRAY | FILTER_FLAG_IPV4]));
+	assertType('array<array|float|false>', filter_var($mixed, FILTER_VALIDATE_FLOAT , ["flags" => $forceArrayFilter]));
+	assertType('array<array|FilterVar\Analyser|float>', filter_var($mixed, FILTER_VALIDATE_FLOAT , ["options" => ["default" => new Analyser], "flags" => FILTER_FORCE_ARRAY]));
+	assertType('array<array|FilterVar\Analyser|float>', filter_var($mixed, FILTER_VALIDATE_FLOAT , ["options" => ["default" => new Analyser], "flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
 	assertType('bool', filter_var($mixed, FILTER_VALIDATE_BOOLEAN ));
 	assertType('mixed', filter_var($mixed, FILTER_VALIDATE_BOOLEAN , $mixed));
 	assertType('mixed', filter_var($mixed, FILTER_VALIDATE_BOOLEAN , ["flags" => $mixed]));
@@ -308,13 +308,13 @@ function () {
 	assertType('bool|null', filter_var($mixed, FILTER_VALIDATE_BOOLEAN , ["flags" => $nullFilter]));
 	assertType('bool|FilterVar\\Analyser', filter_var($mixed, FILTER_VALIDATE_BOOLEAN , ["options" => ["default" => new Analyser]]));
 	assertType('bool', filter_var($mixed, FILTER_VALIDATE_BOOLEAN , ["options" => ["default" => true]]));
-	assertType('array<bool|null>', filter_var($mixed, FILTER_VALIDATE_BOOLEAN , FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY));
-	assertType('array<bool>', filter_var($mixed, FILTER_VALIDATE_BOOLEAN , FILTER_FORCE_ARRAY));
-	assertType('array<bool|null>', filter_var($mixed, FILTER_VALIDATE_BOOLEAN , ["flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
-	assertType('array<bool>', filter_var($mixed, FILTER_VALIDATE_BOOLEAN , ["flags" => $forceArrayFilter]));
-	assertType('array<bool|FilterVar\Analyser>', filter_var($mixed, FILTER_VALIDATE_BOOLEAN , ["options" => ["default" => new Analyser], "flags" => FILTER_FORCE_ARRAY]));
-	assertType('array<bool>', filter_var($mixed, FILTER_VALIDATE_BOOLEAN , ["options" => ["default" => false], "flags" => FILTER_FORCE_ARRAY]));
-	assertType('array<bool|FilterVar\Analyser>', filter_var($mixed, FILTER_VALIDATE_BOOLEAN , ["options" => ["default" => new Analyser], "flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
+	assertType('array<array|bool|null>', filter_var($mixed, FILTER_VALIDATE_BOOLEAN , FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY));
+	assertType('array<array|bool>', filter_var($mixed, FILTER_VALIDATE_BOOLEAN , FILTER_FORCE_ARRAY));
+	assertType('array<array|bool|null>', filter_var($mixed, FILTER_VALIDATE_BOOLEAN , ["flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
+	assertType('array<array|bool>', filter_var($mixed, FILTER_VALIDATE_BOOLEAN , ["flags" => $forceArrayFilter]));
+	assertType('array<array|bool|FilterVar\Analyser>', filter_var($mixed, FILTER_VALIDATE_BOOLEAN , ["options" => ["default" => new Analyser], "flags" => FILTER_FORCE_ARRAY]));
+	assertType('array<array|bool>', filter_var($mixed, FILTER_VALIDATE_BOOLEAN , ["options" => ["default" => false], "flags" => FILTER_FORCE_ARRAY]));
+	assertType('array<array|bool|FilterVar\Analyser>', filter_var($mixed, FILTER_VALIDATE_BOOLEAN , ["options" => ["default" => new Analyser], "flags" => FILTER_NULL_ON_FAILURE | FILTER_FORCE_ARRAY]));
 	assertType('mixed', filter_var($mixed, $mixed));
 	assertType('string', filter_var($mixed, FILTER_SANITIZE_URL, ["options" => ["default" => "foo"]]));
 	assertType('string|false', filter_var($mixed));