diff --git a/src/Definition/Exception/Request/InvalidParameterValueException.php b/src/Definition/Exception/Request/InvalidParameterValueException.php
new file mode 100644
index 0000000..d35d048
--- /dev/null
+++ b/src/Definition/Exception/Request/InvalidParameterValueException.php
@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Undabot\JsonApi\Definition\Exception\Request;
+
+use Throwable;
+use Undabot\JsonApi\Implementation\Model\Source\Source;
+
+class InvalidParameterValueException extends RequestException
+{
+    public function __construct(
+        private Source $source,
+        string $message,
+        $code = 0,
+        Throwable $previous = null
+    ) {
+        parent::__construct($message, $code, $previous);
+    }
+
+    public function source(): Source
+    {
+        return $this->source;
+    }
+}
diff --git a/src/Definition/Exception/Request/MaxPageSizeExceededException.php b/src/Definition/Exception/Request/MaxPageSizeExceededException.php
new file mode 100644
index 0000000..0297f74
--- /dev/null
+++ b/src/Definition/Exception/Request/MaxPageSizeExceededException.php
@@ -0,0 +1,23 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Undabot\JsonApi\Definition\Exception\Request;
+
+use Throwable;
+
+class MaxPageSizeExceededException extends RequestException
+{
+    public function __construct(
+        int $requestedPageSize,
+        int $maxPageSize,
+        $code = 0,
+        Throwable $previous = null
+    ) {
+        parent::__construct(
+            sprintf('You requested a size of %d, but %d is the maximum.', $requestedPageSize, $maxPageSize),
+            $code,
+            $previous,
+        );
+    }
+}
diff --git a/src/Definition/Exception/Request/RangePaginationNotSupportedException.php b/src/Definition/Exception/Request/RangePaginationNotSupportedException.php
new file mode 100644
index 0000000..398e26e
--- /dev/null
+++ b/src/Definition/Exception/Request/RangePaginationNotSupportedException.php
@@ -0,0 +1,21 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Undabot\JsonApi\Definition\Exception\Request;
+
+use Throwable;
+
+class RangePaginationNotSupportedException extends RequestException
+{
+    public function __construct(
+        $code = 0,
+        Throwable $previous = null
+    ) {
+        parent::__construct(
+            'Range pagination not supported',
+            $code,
+            $previous,
+        );
+    }
+}
diff --git a/src/Definition/Model/Request/Pagination/PaginationInterface.php b/src/Definition/Model/Request/Pagination/PaginationInterface.php
index 43c2477..eb77927 100644
--- a/src/Definition/Model/Request/Pagination/PaginationInterface.php
+++ b/src/Definition/Model/Request/Pagination/PaginationInterface.php
@@ -9,4 +9,8 @@ interface PaginationInterface
     public function getSize(): int;
 
     public function getOffset(): int;
+
+    public function getAfter(): ?string;
+
+    public function getBefore(): ?string;
 }
diff --git a/src/Implementation/Factory/PaginationFactory.php b/src/Implementation/Factory/PaginationFactory.php
index f3530fe..f3eeae0 100644
--- a/src/Implementation/Factory/PaginationFactory.php
+++ b/src/Implementation/Factory/PaginationFactory.php
@@ -5,10 +5,13 @@
 namespace Undabot\JsonApi\Implementation\Factory;
 
 use Assert\Assertion;
-use InvalidArgumentException;
+use Assert\AssertionFailedException;
+use Undabot\JsonApi\Definition\Exception\Request\InvalidParameterValueException;
 use Undabot\JsonApi\Definition\Model\Request\Pagination\PaginationInterface;
+use Undabot\JsonApi\Implementation\Model\Request\Pagination\CursorBasedPagination;
 use Undabot\JsonApi\Implementation\Model\Request\Pagination\OffsetBasedPagination;
 use Undabot\JsonApi\Implementation\Model\Request\Pagination\PageBasedPagination;
+use Undabot\JsonApi\Implementation\Model\Source\Source;
 
 class PaginationFactory
 {
@@ -29,16 +32,18 @@ public function fromArray(array $paginationParams): PaginationInterface
             return $this->makeOffsetBasedPagination($paginationParams);
         }
 
+        if (true === \array_key_exists(CursorBasedPagination::PARAM_PAGE_SIZE, $paginationParams)
+            || true === \array_key_exists(CursorBasedPagination::PARAM_PAGE_AFTER, $paginationParams)
+            || true === \array_key_exists(CursorBasedPagination::PARAM_PAGE_BEFORE, $paginationParams)) {
+            return $this->makeCursorBasedPagination($paginationParams);
+        }
+
         $message = sprintf('Couldn\'t create pagination from given params: %s', json_encode($paginationParams));
 
-        throw new InvalidArgumentException($message);
+        throw new InvalidParameterValueException(new Source(null), $message);
     }
 
-    /**
-     * @param array<string, int> $paginationParams
-     *
-     * @throws \Assert\AssertionFailedException
-     */
+    /** @param array<string, int> $paginationParams */
     private function makePageBasedPagination(array $paginationParams): PageBasedPagination
     {
         Assertion::keyExists($paginationParams, PageBasedPagination::PARAM_PAGE_SIZE);
@@ -53,29 +58,15 @@ private function makePageBasedPagination(array $paginationParams): PageBasedPagi
             ]
         );
 
-        foreach ($paginationParams as $paginationParam) {
-            Assertion::integerish(
-                $paginationParam,
-                sprintf('Params must be integer(ish): %s', $paginationParam)
-            );
-            Assertion::greaterThan(
-                $paginationParam,
-                0,
-                sprintf('Params can\'t be zero: %s', $paginationParam)
-            );
-        }
+        $this->validatePaginationParams($paginationParams);
 
         return new PageBasedPagination(
             (int) $paginationParams[PageBasedPagination::PARAM_PAGE_NUMBER],
-            (int) $paginationParams[PageBasedPagination::PARAM_PAGE_SIZE]
+            (int) $paginationParams[PageBasedPagination::PARAM_PAGE_SIZE],
         );
     }
 
-    /**
-     * @param array<string, int> $paginationParams
-     *
-     * @throws \Assert\AssertionFailedException
-     */
+    /** @param array<string, int> $paginationParams */
     private function makeOffsetBasedPagination(array $paginationParams): OffsetBasedPagination
     {
         Assertion::keyExists($paginationParams, OffsetBasedPagination::PARAM_PAGE_OFFSET);
@@ -90,26 +81,50 @@ private function makeOffsetBasedPagination(array $paginationParams): OffsetBased
             ]
         );
 
-        $limit = $paginationParams[OffsetBasedPagination::PARAM_PAGE_LIMIT];
-        Assertion::integerish(
-            $limit,
-            sprintf('Param must be integer(ish): %s', $limit)
-        );
-        Assertion::greaterThan(
-            $limit,
-            0,
-            sprintf('Param can\'t be zero: %s', $limit)
-        );
-
-        $offset = $paginationParams[OffsetBasedPagination::PARAM_PAGE_OFFSET];
-        Assertion::integerish(
-            $offset,
-            sprintf('Param must be integer(ish): %s', $offset)
-        );
+        $this->validatePaginationParams($paginationParams);
 
         return new OffsetBasedPagination(
             (int) $paginationParams[OffsetBasedPagination::PARAM_PAGE_OFFSET],
-            (int) $paginationParams[OffsetBasedPagination::PARAM_PAGE_LIMIT]
+            (int) $paginationParams[OffsetBasedPagination::PARAM_PAGE_LIMIT],
+        );
+    }
+
+    /** @param array<string, int> $paginationParams */
+    private function makeCursorBasedPagination(array $paginationParams): CursorBasedPagination
+    {
+        $size = $paginationParams[CursorBasedPagination::PARAM_PAGE_SIZE] ?? null;
+        if (null !== $size) {
+            $this->validatePaginationParams([CursorBasedPagination::PARAM_PAGE_SIZE => $paginationParams[CursorBasedPagination::PARAM_PAGE_SIZE]]);
+            $size = (int) $size;
+        }
+
+        return new CursorBasedPagination(
+            $paginationParams[CursorBasedPagination::PARAM_PAGE_AFTER] ?? null,
+            $paginationParams[CursorBasedPagination::PARAM_PAGE_BEFORE] ?? null,
+            $size,
         );
     }
+
+
+    /**
+     * @param array<string, int> $paginationParams
+     *
+     * @throws InvalidParameterValueException
+     * */
+    private function validatePaginationParams(array $paginationParams): void
+    {
+        foreach ($paginationParams as $paginationParam) {
+            try {
+                Assertion::integerish($paginationParam);
+                Assertion::greaterThan($paginationParam, 0);
+            } catch (AssertionFailedException $exception) {
+                throw new InvalidParameterValueException(
+                    new Source(null, "page[$paginationParam]"),
+                    "page[$paginationParam] must be a positive integer",
+                    0,
+                    $exception,
+                );
+            }
+        }
+    }
 }
diff --git a/src/Implementation/Model/Request/Pagination/CursorBasedPagination.php b/src/Implementation/Model/Request/Pagination/CursorBasedPagination.php
new file mode 100644
index 0000000..a6ac937
--- /dev/null
+++ b/src/Implementation/Model/Request/Pagination/CursorBasedPagination.php
@@ -0,0 +1,43 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Undabot\JsonApi\Implementation\Model\Request\Pagination;
+
+use Undabot\JsonApi\Definition\Exception\Request\InvalidParameterValueException;
+use Undabot\JsonApi\Definition\Model\Request\Pagination\PaginationInterface;
+use Undabot\JsonApi\Implementation\Model\Source\Source;
+
+class CursorBasedPagination implements PaginationInterface
+{
+    public const PARAM_PAGE_AFTER = 'after';
+    public const PARAM_PAGE_BEFORE = 'before';
+    public const PARAM_PAGE_SIZE = 'size';
+
+    public function __construct(private ?string $after, private ?string $before, private ?int $size)
+    {
+        if (null === $this->after && null === $this->before && null === $this->size) {
+            throw new InvalidParameterValueException(new Source(null), 'At least one of the params must be not null.');
+        }
+    }
+
+    public function getSize(): int
+    {
+        return $this->size ?? 0;
+    }
+
+    public function getAfter(): ?string
+    {
+        return $this->after;
+    }
+
+    public function getBefore(): ?string
+    {
+        return $this->before;
+    }
+
+    public function getOffset(): int
+    {
+        throw new \LogicException('Cursor based pagination does not have offset');
+    }
+}
diff --git a/src/Implementation/Model/Request/Pagination/OffsetBasedPagination.php b/src/Implementation/Model/Request/Pagination/OffsetBasedPagination.php
index c53f22b..bf77cc0 100644
--- a/src/Implementation/Model/Request/Pagination/OffsetBasedPagination.php
+++ b/src/Implementation/Model/Request/Pagination/OffsetBasedPagination.php
@@ -11,16 +11,8 @@ class OffsetBasedPagination implements PaginationInterface
     public const PARAM_PAGE_OFFSET = 'offset';
     public const PARAM_PAGE_LIMIT = 'limit';
 
-    /** @var int */
-    private $offset;
-
-    /** @var int */
-    private $limit;
-
-    public function __construct(int $offset, int $limit)
+    public function __construct(private int $offset, private int $limit)
     {
-        $this->offset = $offset;
-        $this->limit = $limit;
     }
 
     public function getSize(): int
@@ -32,4 +24,14 @@ public function getOffset(): int
     {
         return $this->offset;
     }
+
+    public function getAfter(): ?string
+    {
+        return null;
+    }
+
+    public function getBefore(): ?string
+    {
+        return null;
+    }
 }
diff --git a/src/Implementation/Model/Request/Pagination/PageBasedPagination.php b/src/Implementation/Model/Request/Pagination/PageBasedPagination.php
index 8af6a3e..88dc070 100644
--- a/src/Implementation/Model/Request/Pagination/PageBasedPagination.php
+++ b/src/Implementation/Model/Request/Pagination/PageBasedPagination.php
@@ -11,16 +11,8 @@ class PageBasedPagination implements PaginationInterface
     public const PARAM_PAGE_NUMBER = 'number';
     public const PARAM_PAGE_SIZE = 'size';
 
-    /** @var int */
-    private $pageNumber;
-
-    /** @var int */
-    private $size;
-
-    public function __construct(int $pageNumber, int $size)
+    public function __construct(private int $pageNumber, private int $size)
     {
-        $this->pageNumber = $pageNumber;
-        $this->size = $size;
     }
 
     public function getPageNumber(): int
@@ -37,4 +29,14 @@ public function getOffset(): int
     {
         return ($this->getPageNumber() - 1) * $this->getSize();
     }
+
+    public function getAfter(): ?string
+    {
+        return null;
+    }
+
+    public function getBefore(): ?string
+    {
+        return null;
+    }
 }
diff --git a/tests/Unit/Factory/CursorBasedPaginationFactoryTest.php b/tests/Unit/Factory/CursorBasedPaginationFactoryTest.php
new file mode 100644
index 0000000..d675239
--- /dev/null
+++ b/tests/Unit/Factory/CursorBasedPaginationFactoryTest.php
@@ -0,0 +1,159 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Undabot\JsonApi\Tests\Unit\Factory;
+
+use PHPUnit\Framework\TestCase;
+use Undabot\JsonApi\Definition\Exception\Request\InvalidParameterValueException;
+use Undabot\JsonApi\Implementation\Factory\PaginationFactory;
+use Undabot\JsonApi\Implementation\Model\Request\Pagination\CursorBasedPagination;
+
+/**
+ * @internal
+ * @covers \Undabot\JsonApi\Implementation\Model\Request\Pagination\CursorBasedPagination
+ *
+ * @small
+ */
+final class CursorBasedPaginationFactoryTest extends TestCase
+{
+    private PaginationFactory $paginationFactory;
+
+    protected function setUp(): void
+    {
+        $this->paginationFactory = new PaginationFactory();
+    }
+
+    /** @dataProvider validCursorBasedPaginationParamsProvider */
+    public function testPaginationFactoryCanCreateCursorBasedPaginationFromValidParams($params): void
+    {
+        $pagination = $this->paginationFactory->fromArray($params);
+
+        static::assertInstanceOf(CursorBasedPagination::class, $pagination);
+    }
+
+    /** @dataProvider invalidPaginationParamsProvider */
+    public function testPaginationFactoryWillThrowExceptionForInvalidParams(array $invalidParams): void
+    {
+        $this->expectException(InvalidParameterValueException::class);
+        $this->paginationFactory->fromArray($invalidParams);
+    }
+
+    public function invalidPaginationParamsProvider(): \Generator
+    {
+        yield 'No pagination' => [
+            [],
+        ];
+
+        yield 'Incomplete page based pagination key provided' => [
+            ['number' => 2],
+        ];
+
+        yield 'Incomplete offset based pagination key provided' => [
+            ['offset' => 2],
+        ];
+
+        yield 'After and before provided with no values' => [
+            [
+                'after' => null,
+                'before' => null,
+            ],
+        ];
+
+        yield 'Invalid size number format provided' => [
+            [
+                'size' => 10.1,
+                'after' => 'aaa',
+            ],
+        ];
+    }
+
+    public function validCursorBasedPaginationParamsProvider(): \Generator
+    {
+        yield 'Valid before and size' => [
+            [
+                'before' => 'aaa',
+                'size' => 2,
+            ],
+        ];
+
+        yield 'Valid after and size' => [
+            [
+                'after' => 'aaa',
+                'size' => 2,
+            ],
+        ];
+
+        yield 'Valid before and size as string' => [
+            [
+                'before' => 'aaa',
+                'size' => '2',
+            ],
+        ];
+
+        yield 'Valid after and size as string' => [
+            [
+                'after' => 'aaa',
+                'size' => '2',
+            ],
+        ];
+
+        yield 'Valid after and size as rounded float' => [
+            [
+                'after' => 'aaa',
+                'size' => 2.0,
+            ],
+        ];
+
+        yield 'Only after' => [
+            [
+                'after' => 'aaa',
+            ],
+        ];
+
+        yield 'Only before' => [
+            [
+                'before' => 'aaa',
+            ],
+        ];
+
+        yield 'After and before with same values' => [
+            [
+                'after' => 'aaa',
+                'before' => 'aaa',
+            ],
+        ];
+
+        yield 'After and before with different values' => [
+            [
+                'after' => 'aaa',
+                'before' => 'bbb',
+            ],
+        ];
+    }
+
+    public function testGetPageSizeWillReturnCorrectNumberGivenPageSizeIsProvided(): void
+    {
+        $params = [
+            'before' => 'aaa',
+            'size' => 10,
+        ];
+
+        /** @var CursorBasedPagination $pagination */
+        $pagination = $this->paginationFactory->fromArray($params);
+
+        static::assertSame(10, $pagination->getSize());
+    }
+
+    public function testGetPageSizeWillReturnZeroGivenPageSizeIsNotProvided(): void
+    {
+        $params = [
+            'after' => 'aaa',
+        ];
+
+        /** @var CursorBasedPagination $pagination */
+        $pagination = $this->paginationFactory->fromArray($params);
+
+        static::assertSame(0, $pagination->getSize());
+    }
+}
diff --git a/tests/Unit/Factory/OffsetBasedPaginationFactoryTest.php b/tests/Unit/Factory/OffsetBasedPaginationFactoryTest.php
index aee7964..772faf9 100644
--- a/tests/Unit/Factory/OffsetBasedPaginationFactoryTest.php
+++ b/tests/Unit/Factory/OffsetBasedPaginationFactoryTest.php
@@ -4,8 +4,8 @@
 
 namespace Undabot\JsonApi\Tests\Unit\Factory;
 
-use InvalidArgumentException;
 use PHPUnit\Framework\TestCase;
+use Undabot\JsonApi\Definition\Exception\Request\InvalidParameterValueException;
 use Undabot\JsonApi\Implementation\Factory\PaginationFactory;
 use Undabot\JsonApi\Implementation\Model\Request\Pagination\OffsetBasedPagination;
 
@@ -35,81 +35,87 @@ public function testItCanCreateOffsetBasedPaginationFromValidParams($params): vo
     /** @dataProvider invalidPaginationParamsProvider */
     public function testItWillThrowExceptionForInvalidParams(array $invalidParams): void
     {
-        $this->expectException(InvalidArgumentException::class);
+        $this->expectException(InvalidParameterValueException::class);
         $this->paginationFactory->fromArray($invalidParams);
     }
 
-    public function invalidPaginationParamsProvider()
+    public function invalidPaginationParamsProvider(): \Generator
     {
-        return [
-            [
-                [],
-            ],
-            [
-                ['limit' => 10],
-            ],
-            [
-                ['offset' => 2],
-            ],
+        yield 'No pagination' => [
+            [],
+        ];
+
+        yield 'Missing offset' => [
+            ['limit' => 10],
+        ];
+
+        yield 'Missing limit' => [
+            ['offset' => 2],
+        ];
+
+        yield 'Limit and offset are both 0 as string' => [
             [
-                [
-                    'limit' => '0',
-                    'offset' => '0',
-                ],
+                'limit' => '0',
+                'offset' => '0',
             ],
+        ];
+
+        yield 'Limit and offset are both 0 as integer' => [
             [
-                [
-                    'limit' => 0,
-                    'offset' => 0,
-                ],
+                'limit' => 0,
+                'offset' => 0,
             ],
+        ];
+
+        yield 'Limit and offset are both null' => [
             [
-                [
-                    'limit' => null,
-                    'offset' => null,
-                ],
+                'limit' => null,
+                'offset' => null,
             ],
+        ];
+
+        yield 'Limit and offset are both floats' => [
             [
-                [
-                    'limit' => 10.1,
-                    'offset' => 2.1,
-                ],
+                'limit' => 10.1,
+                'offset' => 2.1,
             ],
         ];
     }
 
-    public function validOffsetBasedPaginationParamsProvider()
+    public function validOffsetBasedPaginationParamsProvider(): \Generator
     {
-        return [
+        yield 'Valid params as integer' => [
             [
-                [
-                    'limit' => 10,
-                    'offset' => 2,
-                ],
+                'limit' => 10,
+                'offset' => 2,
             ],
+        ];
+
+        yield 'Valid params as string' => [
             [
-                [
-                    'limit' => '10',
-                    'offset' => '2',
-                ],
+                'limit' => '10',
+                'offset' => '2',
             ],
+        ];
+
+        yield 'Valid params where offset is string and limit is number' => [
             [
-                [
-                    'limit' => 10,
-                    'offset' => '2',
-                ],
+                'limit' => 10,
+                'offset' => '2',
             ],
+        ];
+
+        yield 'Valid params where offset is number and limit is string' => [
             [
-                [
-                    'limit' => '10',
-                    'offset' => 2,
-                ],
+                'limit' => '10',
+                'offset' => 2,
             ],
+        ];
+
+        yield 'Valid params as rounded floats' => [
             [
-                [
-                    'limit' => 10.0,
-                    'offset' => 2.0,
-                ],
+                'limit' => 10.0,
+                'offset' => 2.0,
             ],
         ];
     }
diff --git a/tests/Unit/Factory/PageBasedPaginationFactoryTest.php b/tests/Unit/Factory/PageBasedPaginationFactoryTest.php
index c4f5909..282f42f 100644
--- a/tests/Unit/Factory/PageBasedPaginationFactoryTest.php
+++ b/tests/Unit/Factory/PageBasedPaginationFactoryTest.php
@@ -4,8 +4,8 @@
 
 namespace Undabot\JsonApi\Tests\Unit\Factory;
 
-use InvalidArgumentException;
 use PHPUnit\Framework\TestCase;
+use Undabot\JsonApi\Definition\Exception\Request\InvalidParameterValueException;
 use Undabot\JsonApi\Implementation\Factory\PaginationFactory;
 use Undabot\JsonApi\Implementation\Model\Request\Pagination\PageBasedPagination;
 
@@ -35,81 +35,83 @@ public function testPaginationFactoryCanCreatePageBasedPaginationFromValidParams
     /** @dataProvider invalidPaginationParamsProvider */
     public function testPaginationFactoryWillThrowExceptionForInvalidParams(array $invalidParams): void
     {
-        $this->expectException(InvalidArgumentException::class);
+        $this->expectException(InvalidParameterValueException::class);
         $this->paginationFactory->fromArray($invalidParams);
     }
 
-    public function invalidPaginationParamsProvider()
+    public function invalidPaginationParamsProvider(): \Generator
     {
-        return [
-            [
-                [],
-            ],
-            [
-                ['size' => 10],
-            ],
-            [
-                ['number' => 2],
-            ],
+        yield 'No pagination' => [
+            [],
+        ];
+
+        yield 'Number provided without size' => [
+            ['number' => 2],
+        ];
+
+        yield 'Number and size with value of 0 as string' => [
             [
-                [
-                    'size' => '0',
-                    'number' => '0',
-                ],
+                'size' => '0',
+                'number' => '0',
             ],
+        ];
+
+        yield 'Number and size with value of 0 as integer' => [
             [
-                [
-                    'size' => 0,
-                    'number' => 0,
-                ],
+                'size' => 0,
+                'number' => 0,
             ],
+        ];
+
+        yield 'Number and size with value of null' => [
             [
-                [
-                    'size' => null,
-                    'number' => null,
-                ],
+                'size' => null,
+                'number' => null,
             ],
+        ];
+
+        yield 'Number and size as a float' => [
             [
-                [
-                    'size' => 10.1,
-                    'number' => 2.1,
-                ],
+                'size' => 10.1,
+                'number' => 2.1,
             ],
         ];
     }
 
-    public function validPageBasedPaginationParamsProvider()
+    public function validPageBasedPaginationParamsProvider(): \Generator
     {
-        return [
+        yield 'Number and size as integer' => [
             [
-                [
-                    'size' => 10,
-                    'number' => 2,
-                ],
+                'size' => 10,
+                'number' => 2,
             ],
+        ];
+
+        yield 'Number and size as string' => [
             [
-                [
-                    'size' => '10',
-                    'number' => '2',
-                ],
+                'size' => '10',
+                'number' => '2',
             ],
+        ];
+
+        yield 'Number as string and size as integer' => [
             [
-                [
-                    'size' => 10,
-                    'number' => '2',
-                ],
+                'size' => 10,
+                'number' => '2',
             ],
+        ];
+
+        yield 'Size as string and number as integer' => [
             [
-                [
-                    'size' => '10',
-                    'number' => 2,
-                ],
+                'size' => '10',
+                'number' => 2,
             ],
+        ];
+
+        yield 'Number and size as rounded float' => [
             [
-                [
-                    'size' => 10.0,
-                    'number' => 2.0,
-                ],
+                'size' => 10.0,
+                'number' => 2.0,
             ],
         ];
     }