diff --git a/src/PseudoTypes/IntegerRange.php b/src/PseudoTypes/IntegerRange.php
new file mode 100644
index 0000000..c5a3bc5
--- /dev/null
+++ b/src/PseudoTypes/IntegerRange.php
@@ -0,0 +1,61 @@
+<?php
+
+declare(strict_types=1);
+
+/**
+ * This file is part of phpDocumentor.
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ *
+ * @link      http://phpdoc.org
+ */
+
+namespace phpDocumentor\Reflection\PseudoTypes;
+
+use phpDocumentor\Reflection\PseudoType;
+use phpDocumentor\Reflection\Type;
+use phpDocumentor\Reflection\Types\Integer;
+
+/**
+ * Value Object representing the type 'int'.
+ *
+ * @psalm-immutable
+ */
+final class IntegerRange extends Integer implements PseudoType
+{
+    /** @var string */
+    private $minValue;
+
+    /** @var string */
+    private $maxValue;
+
+    public function __construct(string $minValue, string $maxValue)
+    {
+        $this->minValue = $minValue;
+        $this->maxValue = $maxValue;
+    }
+
+    public function underlyingType(): Type
+    {
+        return new Integer();
+    }
+
+    public function getMinValue(): string
+    {
+        return $this->minValue;
+    }
+
+    public function getMaxValue(): string
+    {
+        return $this->maxValue;
+    }
+
+    /**
+     * Returns a rendered output of the Type as it would be used in a DocBlock.
+     */
+    public function __toString(): string
+    {
+        return 'int<' . $this->minValue . ', ' . $this->maxValue . '>';
+    }
+}
diff --git a/src/PseudoTypes/NegativeInteger.php b/src/PseudoTypes/NegativeInteger.php
new file mode 100644
index 0000000..c51d3fe
--- /dev/null
+++ b/src/PseudoTypes/NegativeInteger.php
@@ -0,0 +1,39 @@
+<?php
+
+declare(strict_types=1);
+
+/**
+ * This file is part of phpDocumentor.
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ *
+ * @link      http://phpdoc.org
+ */
+
+namespace phpDocumentor\Reflection\PseudoTypes;
+
+use phpDocumentor\Reflection\PseudoType;
+use phpDocumentor\Reflection\Type;
+use phpDocumentor\Reflection\Types\Integer;
+
+/**
+ * Value Object representing the type 'int'.
+ *
+ * @psalm-immutable
+ */
+final class NegativeInteger extends Integer implements PseudoType
+{
+    public function underlyingType(): Type
+    {
+        return new Integer();
+    }
+
+    /**
+     * Returns a rendered output of the Type as it would be used in a DocBlock.
+     */
+    public function __toString(): string
+    {
+        return 'negative-int';
+    }
+}
diff --git a/src/PseudoTypes/Numeric_.php b/src/PseudoTypes/Numeric_.php
new file mode 100644
index 0000000..46620cd
--- /dev/null
+++ b/src/PseudoTypes/Numeric_.php
@@ -0,0 +1,47 @@
+<?php
+
+declare(strict_types=1);
+
+/**
+ * This file is part of phpDocumentor.
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ *
+ * @link      http://phpdoc.org
+ */
+
+namespace phpDocumentor\Reflection\PseudoTypes;
+
+use phpDocumentor\Reflection\PseudoType;
+use phpDocumentor\Reflection\Type;
+use phpDocumentor\Reflection\Types\AggregatedType;
+use phpDocumentor\Reflection\Types\Compound;
+use phpDocumentor\Reflection\Types\Float_;
+use phpDocumentor\Reflection\Types\Integer;
+
+/**
+ * Value Object representing the 'numeric' pseudo-type, which is either a numeric-string, integer or float.
+ *
+ * @psalm-immutable
+ */
+final class Numeric_ extends AggregatedType implements PseudoType
+{
+    public function __construct()
+    {
+        AggregatedType::__construct([new NumericString(), new Integer(), new Float_()], '|');
+    }
+
+    public function underlyingType(): Type
+    {
+        return new Compound([new NumericString(), new Integer(), new Float_()]);
+    }
+
+    /**
+     * Returns a rendered output of the Type as it would be used in a DocBlock.
+     */
+    public function __toString(): string
+    {
+        return 'numeric';
+    }
+}
diff --git a/src/PseudoTypes/PositiveInteger.php b/src/PseudoTypes/PositiveInteger.php
index 63b5094..c52184d 100644
--- a/src/PseudoTypes/PositiveInteger.php
+++ b/src/PseudoTypes/PositiveInteger.php
@@ -18,7 +18,7 @@
 use phpDocumentor\Reflection\Types\Integer;
 
 /**
- * Value Object representing the type 'string'.
+ * Value Object representing the type 'int'.
  *
  * @psalm-immutable
  */
diff --git a/src/TypeResolver.php b/src/TypeResolver.php
index 415b374..d4c960f 100644
--- a/src/TypeResolver.php
+++ b/src/TypeResolver.php
@@ -15,6 +15,7 @@
 
 use ArrayIterator;
 use InvalidArgumentException;
+use phpDocumentor\Reflection\PseudoTypes\IntegerRange;
 use phpDocumentor\Reflection\PseudoTypes\List_;
 use phpDocumentor\Reflection\Types\Array_;
 use phpDocumentor\Reflection\Types\ArrayKey;
@@ -40,6 +41,7 @@
 use function count;
 use function end;
 use function in_array;
+use function is_numeric;
 use function key;
 use function preg_split;
 use function strpos;
@@ -82,10 +84,12 @@ final class TypeResolver
         'non-empty-lowercase-string' => PseudoTypes\NonEmptyLowercaseString::class,
         'non-empty-string' => PseudoTypes\NonEmptyString::class,
         'numeric-string' => PseudoTypes\NumericString::class,
+        'numeric' => PseudoTypes\Numeric_::class,
         'trait-string' => PseudoTypes\TraitString::class,
         'int' => Types\Integer::class,
         'integer' => Types\Integer::class,
         'positive-int' => PseudoTypes\PositiveInteger::class,
+        'negative-int' => PseudoTypes\NegativeInteger::class,
         'bool' => Types\Boolean::class,
         'boolean' => Types\Boolean::class,
         'real' => Types\Float_::class,
@@ -257,6 +261,8 @@ private function parseTypes(ArrayIterator $tokens, Context $context, int $parser
                 if ($classType !== null) {
                     if ((string) $classType === 'class-string') {
                         $types[] = $this->resolveClassString($tokens, $context);
+                    } elseif ((string) $classType === 'int') {
+                        $types[] = $this->resolveIntRange($tokens);
                     } elseif ((string) $classType === 'interface-string') {
                         $types[] = $this->resolveInterfaceString($tokens, $context);
                     } else {
@@ -479,6 +485,75 @@ private function resolveClassString(ArrayIterator $tokens, Context $context): Ty
         return new ClassString($classType->getFqsen());
     }
 
+    /**
+     * Resolves integer ranges
+     *
+     * @param ArrayIterator<int, (string|null)> $tokens
+     */
+    private function resolveIntRange(ArrayIterator $tokens): Type
+    {
+        $tokens->next();
+
+        $token = '';
+        $minValue = null;
+        $maxValue = null;
+        $commaFound = false;
+        $tokenCounter = 0;
+        while ($tokens->valid()) {
+            $tokenCounter++;
+            $token = $tokens->current();
+            if ($token === null) {
+                throw new RuntimeException(
+                    'Unexpected nullable character'
+                );
+            }
+
+            $token = trim($token);
+
+            if ($token === '>') {
+                break;
+            }
+
+            if ($token === ',') {
+                $commaFound = true;
+            }
+
+            if ($commaFound === false && $minValue === null) {
+                if (is_numeric($token) || $token === 'max' || $token === 'min') {
+                    $minValue = $token;
+                }
+            }
+
+            if ($commaFound === true && $maxValue === null) {
+                if (is_numeric($token) || $token === 'max' || $token === 'min') {
+                    $maxValue = $token;
+                }
+            }
+
+            $tokens->next();
+        }
+
+        if ($token !== '>') {
+            if (empty($token)) {
+                throw new RuntimeException(
+                    'interface-string: ">" is missing'
+                );
+            }
+
+            throw new RuntimeException(
+                'Unexpected character "' . $token . '", ">" is missing'
+            );
+        }
+
+        if (!$minValue || !$maxValue || $tokenCounter > 4) {
+            throw new RuntimeException(
+                'int<min,max> has not the correct format'
+            );
+        }
+
+        return new IntegerRange($minValue, $maxValue);
+    }
+
     /**
      * Resolves class string
      *
diff --git a/tests/unit/CollectionResolverTest.php b/tests/unit/CollectionResolverTest.php
index fcfd782..379aafe 100644
--- a/tests/unit/CollectionResolverTest.php
+++ b/tests/unit/CollectionResolverTest.php
@@ -231,10 +231,16 @@ public function testBadArrayCollectionKey(): void
     public function testGoodArrayCollectionKey(): void
     {
         $fixture = new TypeResolver();
-        $fixture->resolve('array<array-key,string>', new Context(''));
+        $resolvedType = $fixture->resolve('array<array-key,string>', new Context(''));
+
+        $this->assertInstanceOf(Array_::class, $resolvedType);
+        $this->assertSame('array<array-key,string>', (string) $resolvedType);
 
         $fixture = new TypeResolver();
-        $fixture->resolve('array<class-string,string>', new Context(''));
+        $resolvedType = $fixture->resolve('array<class-string,string>', new Context(''));
+
+        $this->assertInstanceOf(Array_::class, $resolvedType);
+        $this->assertSame('array<class-string,string>', (string) $resolvedType);
     }
 
     /**
diff --git a/tests/unit/IntegerRangeResolverTest.php b/tests/unit/IntegerRangeResolverTest.php
new file mode 100644
index 0000000..c6dc757
--- /dev/null
+++ b/tests/unit/IntegerRangeResolverTest.php
@@ -0,0 +1,165 @@
+<?php
+
+declare(strict_types=1);
+
+/**
+ * This file is part of phpDocumentor.
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ *
+ * @link      http://phpdoc.org
+ */
+
+namespace phpDocumentor\Reflection;
+
+use phpDocumentor\Reflection\PseudoTypes\IntegerRange;
+use phpDocumentor\Reflection\Types\Context;
+use PHPUnit\Framework\TestCase;
+
+/**
+ * @covers ::<private>
+ * @coversDefaultClass \phpDocumentor\Reflection\TypeResolver
+ */
+class IntegerRangeResolverTest extends TestCase
+{
+    /**
+     * @uses \phpDocumentor\Reflection\Types\Context
+     * @uses \phpDocumentor\Reflection\Types\Compound
+     * @uses \phpDocumentor\Reflection\Types\Collection
+     * @uses \phpDocumentor\Reflection\Types\String_
+     *
+     * @covers ::__construct
+     * @covers ::resolve
+     */
+    public function testResolvingIntRange(): void
+    {
+        $fixture = new TypeResolver();
+
+        $resolvedType = $fixture->resolve('int<-5, 5>', new Context(''));
+
+        $this->assertInstanceOf(IntegerRange::class, $resolvedType);
+        $this->assertSame('int<-5, 5>', (string) $resolvedType);
+
+        $minValue = $resolvedType->getMinValue();
+        $maxValue = $resolvedType->getMaxValue();
+
+        $this->assertSame('-5', $minValue);
+        $this->assertSame('5', $maxValue);
+    }
+
+    /**
+     * @uses \phpDocumentor\Reflection\Types\Context
+     * @uses \phpDocumentor\Reflection\Types\Compound
+     * @uses \phpDocumentor\Reflection\Types\Collection
+     * @uses \phpDocumentor\Reflection\Types\String_
+     *
+     * @covers ::__construct
+     * @covers ::resolve
+     */
+    public function testResolvingIntRangeWithKeywords(): void
+    {
+        $fixture = new TypeResolver();
+
+        $resolvedType = $fixture->resolve('int<min,max>', new Context(''));
+
+        $this->assertInstanceOf(IntegerRange::class, $resolvedType);
+        $this->assertSame('int<min, max>', (string) $resolvedType);
+
+        $minValue = $resolvedType->getMinValue();
+        $maxValue = $resolvedType->getMaxValue();
+
+        $this->assertSame('min', $minValue);
+        $this->assertSame('max', $maxValue);
+    }
+
+    /**
+     * @uses \phpDocumentor\Reflection\Types\Context
+     * @uses \phpDocumentor\Reflection\Types\Compound
+     * @uses \phpDocumentor\Reflection\Types\Collection
+     * @uses \phpDocumentor\Reflection\Types\String_
+     *
+     * @covers ::__construct
+     * @covers ::resolve
+     */
+    public function testResolvingIntRangeErrorMisingMaxValue(): void
+    {
+        $this->expectException('RuntimeException');
+        $this->expectExceptionMessage('int<min,max> has not the correct format');
+
+        $fixture = new TypeResolver();
+        $resolvedType = $fixture->resolve('int<min,>', new Context(''));
+    }
+
+    /**
+     * @uses \phpDocumentor\Reflection\Types\Context
+     * @uses \phpDocumentor\Reflection\Types\Compound
+     * @uses \phpDocumentor\Reflection\Types\Collection
+     * @uses \phpDocumentor\Reflection\Types\String_
+     *
+     * @covers ::__construct
+     * @covers ::resolve
+     */
+    public function testResolvingIntRangeErrorMisingMinValue(): void
+    {
+        $this->expectException('RuntimeException');
+        $this->expectExceptionMessage('int<min,max> has not the correct format');
+
+        $fixture = new TypeResolver();
+        $resolvedType = $fixture->resolve('int<,max>', new Context(''));
+    }
+
+    /**
+     * @uses \phpDocumentor\Reflection\Types\Context
+     * @uses \phpDocumentor\Reflection\Types\Compound
+     * @uses \phpDocumentor\Reflection\Types\Collection
+     * @uses \phpDocumentor\Reflection\Types\String_
+     *
+     * @covers ::__construct
+     * @covers ::resolve
+     */
+    public function testResolvingIntRangeErrorMisingComma(): void
+    {
+        $this->expectException('RuntimeException');
+        $this->expectExceptionMessage('int<min,max> has not the correct format');
+
+        $fixture = new TypeResolver();
+        $resolvedType = $fixture->resolve('int<min|max>', new Context(''));
+    }
+
+    /**
+     * @uses \phpDocumentor\Reflection\Types\Context
+     * @uses \phpDocumentor\Reflection\Types\Compound
+     * @uses \phpDocumentor\Reflection\Types\Collection
+     * @uses \phpDocumentor\Reflection\Types\String_
+     *
+     * @covers ::__construct
+     * @covers ::resolve
+     */
+    public function testResolvingIntRangeErrorMissingEnd(): void
+    {
+        $this->expectException('RuntimeException');
+        $this->expectExceptionMessage('Unexpected character "max", ">" is missing');
+
+        $fixture = new TypeResolver();
+        $resolvedType = $fixture->resolve('int<min,max', new Context(''));
+    }
+
+    /**
+     * @uses \phpDocumentor\Reflection\Types\Context
+     * @uses \phpDocumentor\Reflection\Types\Compound
+     * @uses \phpDocumentor\Reflection\Types\Collection
+     * @uses \phpDocumentor\Reflection\Types\String_
+     *
+     * @covers ::__construct
+     * @covers ::resolve
+     */
+    public function testResolvingIntRangeErrorFormat(): void
+    {
+        $this->expectException('RuntimeException');
+        $this->expectExceptionMessage('int<min,max> has not the correct format');
+
+        $fixture = new TypeResolver();
+        $resolvedType = $fixture->resolve('int<min,max,>', new Context(''));
+    }
+}
diff --git a/tests/unit/NumericResolverTest.php b/tests/unit/NumericResolverTest.php
new file mode 100644
index 0000000..d21532c
--- /dev/null
+++ b/tests/unit/NumericResolverTest.php
@@ -0,0 +1,48 @@
+<?php
+
+declare(strict_types=1);
+
+/**
+ * This file is part of phpDocumentor.
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ *
+ * @link      http://phpdoc.org
+ */
+
+namespace phpDocumentor\Reflection;
+
+use phpDocumentor\Reflection\PseudoTypes\Numeric_;
+use phpDocumentor\Reflection\PseudoTypes\NumericString;
+use phpDocumentor\Reflection\Types\Context;
+use phpDocumentor\Reflection\Types\String_;
+use PHPUnit\Framework\TestCase;
+
+/**
+ * @covers ::<private>
+ * @coversDefaultClass \phpDocumentor\Reflection\TypeResolver
+ */
+class NumericResolverTest extends TestCase
+{
+    /**
+     * @uses \phpDocumentor\Reflection\Types\Context
+     * @uses \phpDocumentor\Reflection\Types\Compound
+     * @uses \phpDocumentor\Reflection\Types\Collection
+     * @uses \phpDocumentor\Reflection\Types\String_
+     *
+     * @covers ::__construct
+     * @covers ::resolve
+     */
+    public function testResolvingIntRange(): void
+    {
+        $fixture = new TypeResolver();
+
+        $resolvedType = $fixture->resolve('numeric', new Context(''));
+
+        $this->assertInstanceOf(Numeric_::class, $resolvedType);
+        $this->assertSame('numeric', (string) $resolvedType);
+        $this->assertSame(false, $resolvedType->underlyingType()->contains(new String_()));
+        $this->assertSame(true, $resolvedType->underlyingType()->contains(new NumericString()));
+    }
+}
diff --git a/tests/unit/PseudoTypes/IntRangeTest.php b/tests/unit/PseudoTypes/IntRangeTest.php
new file mode 100644
index 0000000..ca9bb06
--- /dev/null
+++ b/tests/unit/PseudoTypes/IntRangeTest.php
@@ -0,0 +1,43 @@
+<?php
+
+declare(strict_types=1);
+
+/**
+ * This file is part of phpDocumentor.
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ *
+ * @link      http://phpdoc.org
+ */
+
+namespace phpDocumentor\Reflection\PseudoTypes;
+
+use PHPUnit\Framework\TestCase;
+
+/**
+ * @coversDefaultClass \phpDocumentor\Reflection\PseudoTypes\List_
+ */
+class IntRangeTest extends TestCase
+{
+    /**
+     * @dataProvider provideArrays
+     * @covers ::__toString
+     */
+    public function testArrayStringifyCorrectly(IntegerRange $array, string $expectedString): void
+    {
+        $this->assertSame($expectedString, (string) $array);
+    }
+
+    /**
+     * @return mixed[]
+     */
+    public function provideArrays(): array
+    {
+        return [
+            'simple int range' => [new IntegerRange('-5', '5'), 'int<-5, 5>'],
+            'mixed int range' => [new IntegerRange('min', '5'), 'int<min, 5>'],
+            'keyword int range' => [new IntegerRange('min', 'max'), 'int<min, max>'],
+        ];
+    }
+}
diff --git a/tests/unit/TypeResolverTest.php b/tests/unit/TypeResolverTest.php
index 7a8f062..a18cb30 100644
--- a/tests/unit/TypeResolverTest.php
+++ b/tests/unit/TypeResolverTest.php
@@ -729,10 +729,12 @@ public function provideKeywords(): array
             ['non-empty-lowercase-string', PseudoTypes\NonEmptyLowercaseString::class],
             ['non-empty-string', PseudoTypes\NonEmptyString::class],
             ['numeric-string', PseudoTypes\NumericString::class],
+            ['numeric', PseudoTypes\Numeric_::class],
             ['trait-string', PseudoTypes\TraitString::class],
             ['int', Types\Integer::class],
             ['integer', Types\Integer::class],
             ['positive-int', PseudoTypes\PositiveInteger::class],
+            ['negative-int', PseudoTypes\NegativeInteger::class],
             ['float', Types\Float_::class],
             ['double', Types\Float_::class],
             ['bool', Types\Boolean::class],