valgen 5.3.1 → 5.4.0

package/CHANGELOG.md

@@ -1,3 +1,19 @@
+# v5.4.0
+[2024-05-18]
+
+### Changes
+
+* Added returnIndex to pipe() ([`87458ad`](https://github.com/panates/valgen/commit/87458adb3eb6a4465c8198f942df1fbb333738ff))
+* Updated circleci config ([`101361c`](https://github.com/panates/valgen/commit/101361c20f1b78a75392b9e796bc9075b492cb3e))
+
+# v5.3.2
+[2024-05-18]
+
+### Changes
+
+* Updated dependencies ([`9e618ab`](https://github.com/panates/valgen/commit/9e618ab5062b106a7321ef50beac0cd0ccf7e56c))
+* Fixed coveralls token ([`ede2734`](https://github.com/panates/valgen/commit/ede27343a163ef6649866fedb141598518d6e1c3))
+
 # v5.3.1
 [2024-05-18]
 

package/cjs/rules/logical-rules/range.js

@@ -100,15 +100,25 @@ exports.isLte = isLte;
  * Checks the length is at least "minValue"
  * @validator lengthMin
  */
-const lengthMin = (minValue) => (0, pipe_js_1.allOf)((0, pipe_js_1.pipe)((0, get_length_js_1.getLength)(), isGte(minValue, {
-    onFail: () => `The length of {{label}} must be at least ${minValue}`,
-})));
+const lengthMin = (minValue) => (0, pipe_js_1.allOf)([
+    (0, pipe_js_1.pipe)([
+        (0, get_length_js_1.getLength)(),
+        isGte(minValue, {
+            onFail: () => `The length of {{label}} must be at least ${minValue}`,
+        }),
+    ]),
+]);
 exports.lengthMin = lengthMin;
 /**
  * Checks if the length is at most "maxValue"
  * @validator lengthMax
  */
-const lengthMax = (maxValue) => (0, pipe_js_1.allOf)((0, pipe_js_1.pipe)((0, get_length_js_1.getLength)(), isLte(maxValue, {
-    onFail: () => `The length of {{label}} must be at most ${maxValue}`,
-})));
+const lengthMax = (maxValue) => (0, pipe_js_1.allOf)([
+    (0, pipe_js_1.pipe)([
+        (0, get_length_js_1.getLength)(),
+        isLte(maxValue, {
+            onFail: () => `The length of {{label}} must be at most ${maxValue}`,
+        }),
+    ]),
+]);
 exports.lengthMax = lengthMax;

package/cjs/rules/type-rules/is-array.js

@@ -10,23 +10,24 @@ const index_js_1 = require("../../core/index.js");
 function isArray(itemValidator, options) {
     return (0, index_js_1.validator)('isArray', function (input, context, _this) {
         const coerce = options?.coerce || context.coerce;
-        if (input != null && coerce && !Array.isArray(input))
-            input = [input];
-        if (!Array.isArray(input)) {
+        let output = input;
+        if (output != null && coerce && !Array.isArray(output))
+            output = [output];
+        if (!Array.isArray(output)) {
             context.fail(_this, `"{{value}}" is not an array value`, input);
             return;
         }
         if (!itemValidator)
-            return input;
+            return output;
         // const location = context.location || '';
         const itemContext = context.extend();
         let i;
         let v;
-        const l = input.length;
+        const l = output.length;
         const out = [];
         for (i = 0; i < l; i++) {
-            v = input[i];
-            itemContext.scope = input;
+            v = output[i];
+            itemContext.scope = output;
             // itemContext.location = location + '[' + i + ']';
             itemContext.location = context.location ? context.location + `[${i}]` : `<Array>[${i}]`;
             itemContext.index = i;

package/cjs/rules/type-rules/is-boolean.js

@@ -12,7 +12,8 @@ const FALSE_PATTERN = /^false|f|0|no|n$/i;
 function isBoolean(options) {
     return (0, index_js_1.validator)('isBoolean', function (input, context, _this) {
         const coerce = options?.coerce || context.coerce;
-        if (input != null && typeof input !== 'boolean' && coerce) {
+        let output = input;
+        if (output != null && typeof output !== 'boolean' && coerce) {
             if (typeof input === 'string') {
                 if (TRUE_PATTERN.test(input))
                     return true;
@@ -21,10 +22,10 @@ function isBoolean(options) {
                 throw new TypeError(`Invalid boolean string`);
             }
             if (input === 1 || input === 0)
-                input = !!input;
+                output = !!input;
         }
-        if (typeof input === 'boolean')
-            return input;
+        if (typeof output === 'boolean')
+            return output;
         const t = typeof input === 'string' ? 'String ' : '';
         context.fail(_this, `${t}"{{value}}" is not a valid boolean value`, input);
     }, options);

package/cjs/rules/type-rules/is-integer.js

@@ -10,17 +10,18 @@ const index_js_1 = require("../../core/index.js");
 function isInteger(options) {
     return (0, index_js_1.validator)('isInteger', function (input, context, _this) {
         const coerce = options?.coerce || context.coerce;
-        if (input != null && typeof input !== 'number' && coerce) {
+        let output = input;
+        if (output != null && typeof output !== 'number' && coerce) {
             if (typeof input === 'string')
-                input = parseFloat(input);
-            if (typeof input === 'bigint') {
-                const v = Number(input);
-                if (input === BigInt(v))
-                    input = v;
+                output = parseFloat(input);
+            else if (typeof input === 'bigint') {
+                output = Number(input);
+                if (input === BigInt(output))
+                    input = output;
             }
         }
-        if (typeof input === 'number' && !isNaN(input) && Number.isInteger(input))
-            return input;
+        if (typeof output === 'number' && !isNaN(output) && Number.isInteger(output))
+            return output;
         const t = typeof input === 'bigint' ? 'BigInt ' : typeof input === 'string' ? 'String ' : '';
         context.fail(_this, `${t}"{{value}}" is not a valid integer value`, input);
     }, options);

package/cjs/rules/type-rules/is-number.js

@@ -10,17 +10,18 @@ const index_js_1 = require("../../core/index.js");
 function isNumber(options) {
     return (0, index_js_1.validator)('isNumber', function (input, context, _this) {
         const coerce = options?.coerce || context.coerce;
-        if (input != null && typeof input !== 'number' && coerce) {
+        let output = input;
+        if (output != null && typeof output !== 'number' && coerce) {
             if (typeof input === 'string')
-                input = parseFloat(input);
-            if (typeof input === 'bigint') {
-                const v = Number(input);
-                if (input === BigInt(v))
-                    return v;
+                output = parseFloat(input);
+            else if (typeof input === 'bigint') {
+                output = Number(input);
+                if (input === BigInt(output))
+                    return output;
             }
         }
-        if (typeof input === 'number' && !isNaN(input))
-            return input;
+        if (typeof output === 'number' && !isNaN(output))
+            return output;
         const t = typeof input === 'bigint' ? 'BigInt ' : typeof input === 'string' ? 'String ' : '';
         context.fail(_this, `${t}"{{value}}" is not a valid number value`, input);
     }, options);

package/cjs/rules/type-rules/is-object.js

@@ -35,16 +35,17 @@ function isObject(schema, options) {
             throw new TypeError(`Invalid definition in validation schema (${k})`);
     }
     const _rule = (0, index_js_1.validator)('isObject', function (input, context, _this) {
+        let output = input;
         if (ctor && ctor[constants_js_1.preValidation])
-            input = ctor[constants_js_1.preValidation](input, context, _this);
+            output = ctor[constants_js_1.preValidation](output, context, _this);
         const coerce = options?.coerce || context.coerce;
-        if (typeof input === 'string' && coerce)
-            input = JSON.parse(input);
-        if (!(input && typeof input === 'object')) {
+        if (typeof output === 'string' && coerce)
+            output = JSON.parse(output);
+        if (!(output && typeof output === 'object')) {
             context.fail(_this, `{{label}} must be an object`, input);
             return;
         }
-        const keys = [...Object.keys(input), ...schemaKeys];
+        const keys = [...Object.keys(output), ...schemaKeys];
         const l = keys.length;
         let i = 0;
         let inputKey;
@@ -56,9 +57,9 @@ function isObject(schema, options) {
             Object.setPrototypeOf(out, ctor.prototype);
         if (detectCircular) {
             context.circMap = context.circMap || new Map();
-            if (context.circMap.has(input))
-                return context.circMap.get(input);
-            context.circMap.set(input, out);
+            if (context.circMap.has(output))
+                return context.circMap.get(output);
+            context.circMap.set(output, out);
         }
         if (context.root == null)
             context.root = context.root || ctorName || '';
@@ -68,14 +69,14 @@ function isObject(schema, options) {
         for (i = 0; i < l; i++) {
             inputKey = keys[i];
             schemaKey = caseInSensitive ? inputKey.toLowerCase() : inputKey;
-            v = input[inputKey];
+            v = output[inputKey];
             _propRule = propertyRules[schemaKey] || ((0, index_js_1.isValidator)(additionalFields) ? additionalFields : undefined);
             if (_propRule) {
                 if (processedSchemaKeys[schemaKey])
                     continue;
                 processedSchemaKeys[schemaKey] = true;
                 const subCtx = context.extend();
-                subCtx.scope = input;
+                subCtx.scope = output;
                 subCtx.context = ctorName;
                 subCtx.location = location + (location ? '.' : '') + schemaKey;
                 subCtx.property = schemaKey;

package/cjs/rules/type-rules/is-string.js

@@ -10,19 +10,20 @@ const index_js_1 = require("../../core/index.js");
 function isString(options) {
     return (0, index_js_1.validator)('isString', function (input, context, _this) {
         const coerce = options?.coerce || context.coerce;
-        if (input != null && typeof input !== 'string' && coerce) {
-            if (typeof input === 'object') {
-                if (typeof input.toJSON === 'function')
-                    input = input.toJSON();
+        let output = input;
+        if (output != null && typeof output !== 'string' && coerce) {
+            if (typeof output === 'object') {
+                if (typeof output.toJSON === 'function')
+                    output = output.toJSON();
                 else
-                    input = JSON.stringify(input);
+                    output = JSON.stringify(output);
             }
             else
-                input = String(input);
+                output = String(output);
         }
-        if (typeof input === 'string')
-            return input;
-        context.fail(_this, `{{label}} must be a string`, input);
+        if (typeof output === 'string')
+            return output;
+        context.fail(_this, `"{{value}}" is not a string`, input);
     }, options);
 }
 exports.isString = isString;

package/cjs/rules/type-rules/is-tuple.js

@@ -5,8 +5,9 @@ const index_js_1 = require("../../core/index.js");
 function isTuple(items, options) {
     return (0, index_js_1.validator)('isTuple', function (input, context, _this) {
         const coerce = options?.coerce || context.coerce;
-        if (input != null && coerce && !Array.isArray(input))
-            input = [input];
+        let output = input;
+        if (output != null && coerce && !Array.isArray(output))
+            output = [output];
         if (!Array.isArray(input)) {
             context.fail(_this, `"{{value}}" is not a valid tuple`, input);
             return;
@@ -15,18 +16,18 @@ function isTuple(items, options) {
         let itemRule;
         let i;
         let v;
-        const l = input.length;
+        const l = output.length;
         const out = [];
         const nl = items.length;
         const itemContext = context.extend();
         for (i = 0; i < l && i < nl; i++) {
             itemRule = items[i];
-            itemContext.scope = input;
+            itemContext.scope = output;
             itemContext.label = context.label ? context.label + `[${i}]` : undefined;
             itemContext.index = i;
             itemContext.location = location + '[' + i + ']';
             itemContext.label = (itemContext.label || itemContext.property || 'Value at ') + `[${i}]`;
-            v = itemRule(input[i], itemContext);
+            v = itemRule(output[i], itemContext);
             out.push(v);
         }
         return context.errors.length ? undefined : out;

package/cjs/rules/utility-rules/pipe.js

@@ -6,27 +6,31 @@ const index_js_1 = require("../../core/index.js");
  *
  * @validator pipe
  */
-function pipe(...rules) {
+function pipe(rules, options) {
     const l = rules.length;
+    const returnIndex = options?.returnIndex;
     return (0, index_js_1.validator)('pipe', function (input, context) {
         let i;
         let c;
         let v = input;
+        let returnValue;
         for (i = 0; i < l; i++) {
             c = rules[i];
             v = c(v, context);
+            if (returnIndex == null || i <= returnIndex)
+                returnValue = v;
             if (context.errors.length)
                 return;
         }
-        return v;
-    });
+        return returnValue;
+    }, options);
 }
 exports.pipe = pipe;
 /**
  * Test given value against to all codecs and returns original input
  * @validator allOf
  */
-function allOf(...rules) {
+function allOf(rules) {
     return (0, index_js_1.validator)('allOf', function (input, context) {
         let i;
         let c;

package/esm/rules/logical-rules/range.js

@@ -92,13 +92,23 @@ export function isLte(maxValue, options) {
  * Checks the length is at least "minValue"
  * @validator lengthMin
  */
-export const lengthMin = (minValue) => allOf(pipe(getLength(), isGte(minValue, {
-    onFail: () => `The length of {{label}} must be at least ${minValue}`,
-})));
+export const lengthMin = (minValue) => allOf([
+    pipe([
+        getLength(),
+        isGte(minValue, {
+            onFail: () => `The length of {{label}} must be at least ${minValue}`,
+        }),
+    ]),
+]);
 /**
  * Checks if the length is at most "maxValue"
  * @validator lengthMax
  */
-export const lengthMax = (maxValue) => allOf(pipe(getLength(), isLte(maxValue, {
-    onFail: () => `The length of {{label}} must be at most ${maxValue}`,
-})));
+export const lengthMax = (maxValue) => allOf([
+    pipe([
+        getLength(),
+        isLte(maxValue, {
+            onFail: () => `The length of {{label}} must be at most ${maxValue}`,
+        }),
+    ]),
+]);

package/esm/rules/type-rules/is-array.js

@@ -7,23 +7,24 @@ import { validator } from '../../core/index.js';
 export function isArray(itemValidator, options) {
     return validator('isArray', function (input, context, _this) {
         const coerce = options?.coerce || context.coerce;
-        if (input != null && coerce && !Array.isArray(input))
-            input = [input];
-        if (!Array.isArray(input)) {
+        let output = input;
+        if (output != null && coerce && !Array.isArray(output))
+            output = [output];
+        if (!Array.isArray(output)) {
             context.fail(_this, `"{{value}}" is not an array value`, input);
             return;
         }
         if (!itemValidator)
-            return input;
+            return output;
         // const location = context.location || '';
         const itemContext = context.extend();
         let i;
         let v;
-        const l = input.length;
+        const l = output.length;
         const out = [];
         for (i = 0; i < l; i++) {
-            v = input[i];
-            itemContext.scope = input;
+            v = output[i];
+            itemContext.scope = output;
             // itemContext.location = location + '[' + i + ']';
             itemContext.location = context.location ? context.location + `[${i}]` : `<Array>[${i}]`;
             itemContext.index = i;

package/esm/rules/type-rules/is-boolean.js

@@ -9,7 +9,8 @@ const FALSE_PATTERN = /^false|f|0|no|n$/i;
 export function isBoolean(options) {
     return validator('isBoolean', function (input, context, _this) {
         const coerce = options?.coerce || context.coerce;
-        if (input != null && typeof input !== 'boolean' && coerce) {
+        let output = input;
+        if (output != null && typeof output !== 'boolean' && coerce) {
             if (typeof input === 'string') {
                 if (TRUE_PATTERN.test(input))
                     return true;
@@ -18,10 +19,10 @@ export function isBoolean(options) {
                 throw new TypeError(`Invalid boolean string`);
             }
             if (input === 1 || input === 0)
-                input = !!input;
+                output = !!input;
         }
-        if (typeof input === 'boolean')
-            return input;
+        if (typeof output === 'boolean')
+            return output;
         const t = typeof input === 'string' ? 'String ' : '';
         context.fail(_this, `${t}"{{value}}" is not a valid boolean value`, input);
     }, options);

package/esm/rules/type-rules/is-integer.js

@@ -7,17 +7,18 @@ import { validator } from '../../core/index.js';
 export function isInteger(options) {
     return validator('isInteger', function (input, context, _this) {
         const coerce = options?.coerce || context.coerce;
-        if (input != null && typeof input !== 'number' && coerce) {
+        let output = input;
+        if (output != null && typeof output !== 'number' && coerce) {
             if (typeof input === 'string')
-                input = parseFloat(input);
-            if (typeof input === 'bigint') {
-                const v = Number(input);
-                if (input === BigInt(v))
-                    input = v;
+                output = parseFloat(input);
+            else if (typeof input === 'bigint') {
+                output = Number(input);
+                if (input === BigInt(output))
+                    input = output;
             }
         }
-        if (typeof input === 'number' && !isNaN(input) && Number.isInteger(input))
-            return input;
+        if (typeof output === 'number' && !isNaN(output) && Number.isInteger(output))
+            return output;
         const t = typeof input === 'bigint' ? 'BigInt ' : typeof input === 'string' ? 'String ' : '';
         context.fail(_this, `${t}"{{value}}" is not a valid integer value`, input);
     }, options);

package/esm/rules/type-rules/is-number.js

@@ -7,17 +7,18 @@ import { validator } from '../../core/index.js';
 export function isNumber(options) {
     return validator('isNumber', function (input, context, _this) {
         const coerce = options?.coerce || context.coerce;
-        if (input != null && typeof input !== 'number' && coerce) {
+        let output = input;
+        if (output != null && typeof output !== 'number' && coerce) {
             if (typeof input === 'string')
-                input = parseFloat(input);
-            if (typeof input === 'bigint') {
-                const v = Number(input);
-                if (input === BigInt(v))
-                    return v;
+                output = parseFloat(input);
+            else if (typeof input === 'bigint') {
+                output = Number(input);
+                if (input === BigInt(output))
+                    return output;
             }
         }
-        if (typeof input === 'number' && !isNaN(input))
-            return input;
+        if (typeof output === 'number' && !isNaN(output))
+            return output;
         const t = typeof input === 'bigint' ? 'BigInt ' : typeof input === 'string' ? 'String ' : '';
         context.fail(_this, `${t}"{{value}}" is not a valid number value`, input);
     }, options);

package/esm/rules/type-rules/is-object.js

@@ -32,16 +32,17 @@ export function isObject(schema, options) {
             throw new TypeError(`Invalid definition in validation schema (${k})`);
     }
     const _rule = validator('isObject', function (input, context, _this) {
+        let output = input;
         if (ctor && ctor[preValidation])
-            input = ctor[preValidation](input, context, _this);
+            output = ctor[preValidation](output, context, _this);
         const coerce = options?.coerce || context.coerce;
-        if (typeof input === 'string' && coerce)
-            input = JSON.parse(input);
-        if (!(input && typeof input === 'object')) {
+        if (typeof output === 'string' && coerce)
+            output = JSON.parse(output);
+        if (!(output && typeof output === 'object')) {
             context.fail(_this, `{{label}} must be an object`, input);
             return;
         }
-        const keys = [...Object.keys(input), ...schemaKeys];
+        const keys = [...Object.keys(output), ...schemaKeys];
         const l = keys.length;
         let i = 0;
         let inputKey;
@@ -53,9 +54,9 @@ export function isObject(schema, options) {
             Object.setPrototypeOf(out, ctor.prototype);
         if (detectCircular) {
             context.circMap = context.circMap || new Map();
-            if (context.circMap.has(input))
-                return context.circMap.get(input);
-            context.circMap.set(input, out);
+            if (context.circMap.has(output))
+                return context.circMap.get(output);
+            context.circMap.set(output, out);
         }
         if (context.root == null)
             context.root = context.root || ctorName || '';
@@ -65,14 +66,14 @@ export function isObject(schema, options) {
         for (i = 0; i < l; i++) {
             inputKey = keys[i];
             schemaKey = caseInSensitive ? inputKey.toLowerCase() : inputKey;
-            v = input[inputKey];
+            v = output[inputKey];
             _propRule = propertyRules[schemaKey] || (isValidator(additionalFields) ? additionalFields : undefined);
             if (_propRule) {
                 if (processedSchemaKeys[schemaKey])
                     continue;
                 processedSchemaKeys[schemaKey] = true;
                 const subCtx = context.extend();
-                subCtx.scope = input;
+                subCtx.scope = output;
                 subCtx.context = ctorName;
                 subCtx.location = location + (location ? '.' : '') + schemaKey;
                 subCtx.property = schemaKey;

package/esm/rules/type-rules/is-string.js

@@ -7,19 +7,20 @@ import { validator } from '../../core/index.js';
 export function isString(options) {
     return validator('isString', function (input, context, _this) {
         const coerce = options?.coerce || context.coerce;
-        if (input != null && typeof input !== 'string' && coerce) {
-            if (typeof input === 'object') {
-                if (typeof input.toJSON === 'function')
-                    input = input.toJSON();
+        let output = input;
+        if (output != null && typeof output !== 'string' && coerce) {
+            if (typeof output === 'object') {
+                if (typeof output.toJSON === 'function')
+                    output = output.toJSON();
                 else
-                    input = JSON.stringify(input);
+                    output = JSON.stringify(output);
             }
             else
-                input = String(input);
+                output = String(output);
         }
-        if (typeof input === 'string')
-            return input;
-        context.fail(_this, `{{label}} must be a string`, input);
+        if (typeof output === 'string')
+            return output;
+        context.fail(_this, `"{{value}}" is not a string`, input);
     }, options);
 }
 export function stringReplace(searchValue, replacer) {

package/esm/rules/type-rules/is-tuple.js

@@ -2,8 +2,9 @@ import { validator } from '../../core/index.js';
 export function isTuple(items, options) {
     return validator('isTuple', function (input, context, _this) {
         const coerce = options?.coerce || context.coerce;
-        if (input != null && coerce && !Array.isArray(input))
-            input = [input];
+        let output = input;
+        if (output != null && coerce && !Array.isArray(output))
+            output = [output];
         if (!Array.isArray(input)) {
             context.fail(_this, `"{{value}}" is not a valid tuple`, input);
             return;
@@ -12,18 +13,18 @@ export function isTuple(items, options) {
         let itemRule;
         let i;
         let v;
-        const l = input.length;
+        const l = output.length;
         const out = [];
         const nl = items.length;
         const itemContext = context.extend();
         for (i = 0; i < l && i < nl; i++) {
             itemRule = items[i];
-            itemContext.scope = input;
+            itemContext.scope = output;
             itemContext.label = context.label ? context.label + `[${i}]` : undefined;
             itemContext.index = i;
             itemContext.location = location + '[' + i + ']';
             itemContext.label = (itemContext.label || itemContext.property || 'Value at ') + `[${i}]`;
-            v = itemRule(input[i], itemContext);
+            v = itemRule(output[i], itemContext);
             out.push(v);
         }
         return context.errors.length ? undefined : out;

package/esm/rules/utility-rules/pipe.js

@@ -3,26 +3,30 @@ import { validator } from '../../core/index.js';
  *
  * @validator pipe
  */
-export function pipe(...rules) {
+export function pipe(rules, options) {
     const l = rules.length;
+    const returnIndex = options?.returnIndex;
     return validator('pipe', function (input, context) {
         let i;
         let c;
         let v = input;
+        let returnValue;
         for (i = 0; i < l; i++) {
             c = rules[i];
             v = c(v, context);
+            if (returnIndex == null || i <= returnIndex)
+                returnValue = v;
             if (context.errors.length)
                 return;
         }
-        return v;
-    });
+        return returnValue;
+    }, options);
 }
 /**
  * Test given value against to all codecs and returns original input
  * @validator allOf
  */
-export function allOf(...rules) {
+export function allOf(rules) {
     return validator('allOf', function (input, context) {
         let i;
         let c;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "valgen",
   "description": "Fast runtime type validator, converter and io (encoding/decoding) library",
-  "version": "5.3.1",
+  "version": "5.4.0",
   "author": "Panates",
   "contributors": [
     "Eray Hanoglu <e.hanoglu@panates.com>"
@@ -12,10 +12,10 @@
     "url": "https://github.com/panates/valgen.git"
   },
   "dependencies": {
-    "@types/validator": "^13.11.9",
+    "@types/validator": "^13.11.10",
     "date-fns": "^3.6.0",
     "ts-gems": "^3.4.0",
-    "validator": "^13.11.0"
+    "validator": "^13.12.0"
   },
   "type": "module",
   "types": "typings/index.d.ts",

package/typings/rules/utility-rules/pipe.d.ts

@@ -1,11 +1,14 @@
-import { Validator } from '../../core/index.js';
+import { ValidationOptions, Validator } from '../../core/index.js';
+export interface PipeOptions extends ValidationOptions {
+    returnIndex?: number;
+}
 /**
  *
  * @validator pipe
  */
-export declare function pipe<T>(...rules: Validator[]): Validator<T>;
+export declare function pipe<T>(rules: Validator[], options?: PipeOptions): Validator<T>;
 /**
  * Test given value against to all codecs and returns original input
  * @validator allOf
  */
-export declare function allOf<T = any>(...rules: Validator[]): Validator<T>;
+export declare function allOf<T = any>(rules: Validator[]): Validator<T>;