@oxog/vld 2.1.0 → 2.2.7

package/dist/validators/lazy.js

@@ -1,50 +1 @@
-import { VldBase, VLD_VALIDATOR_TYPES } from './base.js';
-
-/**
- * VldLazy - Lazy evaluation for recursive schemas
- * Part of Zod 4 API parity implementation
- * Allows schemas that reference themselves (e.g., tree structures, nested categories)
- */
-/**
- * Lazy validator - defers schema evaluation until runtime
- * Essential for recursive and self-referencing types
- *
- * Caches the resolved schema after first use. This keeps recursive schemas stable
- * and avoids re-running the schema getter on hot parse paths.
- */
-class VldLazy extends VldBase {
-    constructor(_schemaGetter) {
-        super(VLD_VALIDATOR_TYPES.LAZY);
-        this._schemaGetter = _schemaGetter;
-        this._cachedSchema = null;
-    }
-    static create(schemaGetter) {
-        return new VldLazy(schemaGetter);
-    }
-    /**
-     * Get the actual schema, caching it after first retrieval
-     */
-    _getSchema() {
-        if (this._cachedSchema) {
-            return this._cachedSchema;
-        }
-        const schema = this._schemaGetter();
-        this._cachedSchema = schema;
-        return schema;
-    }
-    /**
-     * Get the inner schema (unwrap)
-     * Returns a strong reference that will keep the schema alive
-     */
-    unwrap() {
-        return this._getSchema();
-    }
-    parse(value) {
-        return this._getSchema().parse(value);
-    }
-    safeParse(value) {
-        return this._getSchema().safeParse(value);
-    }
-}
-
-export { VldLazy };
+import{VldBase as e,VLD_VALIDATOR_TYPES as t}from"./base.js";class VldLazy extends e{constructor(e){super(t.LAZY),this._schemaGetter=e,this._cachedSchema=null}static create(e){return new VldLazy(e)}_getSchema(){if(this._cachedSchema)return this._cachedSchema;const e=this._schemaGetter();return this._cachedSchema=e,e}unwrap(){return this._getSchema()}parse(e){return this._getSchema().parse(e)}safeParse(e){return this._getSchema().safeParse(e)}}export{VldLazy};

package/dist/validators/literal.d.ts

@@ -2,8 +2,9 @@ import { VldBase, ParseResult } from './base.js';
 /**
  * Immutable literal validator for exact value matching
  */
-export declare class VldLiteral<T extends string | number | boolean | null | undefined> extends VldBase<T, T> {
-    private readonly _literal;
+export type LiteralValue = string | number | bigint | boolean | null | undefined;
+export declare class VldLiteral<T extends LiteralValue> extends VldBase<T, T> {
+    private readonly _values;
     private readonly errorMessage?;
     /**
      * Private constructor to enforce immutability
@@ -13,15 +14,19 @@ export declare class VldLiteral<T extends string | number | boolean | null | und
      * Get the literal value
      */
     get literal(): T;
+    get value(): T;
+    get values(): readonly T[];
     get isSimple(): boolean;
+    private get expectedDisplay();
     /**
      * Create a new literal validator
      */
-    static create<T extends string | number | boolean | null | undefined>(literal: T): VldLiteral<T>;
+    static create<T extends LiteralValue>(literal: T | readonly T[]): VldLiteral<T>;
     /**
      * Parse and validate a literal value
      */
     parse(value: unknown): T;
+    private _createLiteralError;
     /**
      * Safely parse and validate a literal value
      */

package/dist/validators/literal.js

@@ -1,60 +1 @@
-import { VldBase, VLD_VALIDATOR_TYPES } from './base.js';
-import { getMessages } from '../locales/runtime.js';
-import { V as VldError } from '../chunks/errors-core-BeiFUtZM.js';
-
-function createLiteralError(message) {
-    return new VldError([{ code: 'invalid_literal', path: [], message }]);
-}
-/**
- * Immutable literal validator for exact value matching
- */
-class VldLiteral extends VldBase {
-    /**
-     * Private constructor to enforce immutability
-     */
-    constructor(_literal, errorMessage) {
-        super(VLD_VALIDATOR_TYPES.LITERAL);
-        this._literal = _literal;
-        this.errorMessage = errorMessage;
-    }
-    /**
-     * Get the literal value
-     */
-    get literal() {
-        return this._literal;
-    }
-    get isSimple() {
-        return true;
-    }
-    /**
-     * Create a new literal validator
-     */
-    static create(literal) {
-        return new VldLiteral(literal);
-    }
-    /**
-     * Parse and validate a literal value
-     */
-    parse(value) {
-        if (value !== this._literal) {
-            throw new Error(this.errorMessage ||
-                getMessages().literalExpected(JSON.stringify(this._literal), JSON.stringify(value)));
-        }
-        return this._literal;
-    }
-    /**
-     * Safely parse and validate a literal value
-     */
-    safeParse(value) {
-        if (value === this._literal) {
-            return { success: true, data: this._literal };
-        }
-        return {
-            success: false,
-            error: createLiteralError(this.errorMessage ||
-                getMessages().literalExpected(JSON.stringify(this._literal), JSON.stringify(value)))
-        };
-    }
-}
-
-export { VldLiteral };
+import{VldBase as e,VLD_VALIDATOR_TYPES as r}from"./base.js";import{getMessages as t}from"../locales/runtime.js";import{V as s}from"../chunks/errors-core-CerMg2rq.js";function a(e){const r=JSON.stringify(e,(e,r)=>"bigint"==typeof r?r.toString():r);return void 0===r?String(e):r}class VldLiteral extends e{constructor(e,t){super(r.LITERAL),this._values=e,this.errorMessage=t}get literal(){return this._values[0]}get value(){return this._values[0]}get values(){return this._values}get isSimple(){return 1===this._values.length}get expectedDisplay(){return a(1===this._values.length?this._values[0]:this._values)}static create(e){const r=Array.isArray(e)?e:[e];if(0===r.length)throw new Error("Cannot create literal schema with no valid values");return new VldLiteral(r)}parse(e){if(!this._values.includes(e))throw this._createLiteralError(e);return e}_createLiteralError(e){const r={code:"invalid_value",path:[],values:[...this._values],message:this.errorMessage||t().literalExpected(this.expectedDisplay,a(e))};return new s([r])}safeParse(e){return this._values.includes(e)?{success:!0,data:e}:{success:!1,error:this._createLiteralError(e)}}}export{VldLiteral};

package/dist/validators/map.d.ts

@@ -6,6 +6,7 @@ export declare class VldMap<K, V> extends VldBase<unknown, Map<K, V>> {
     private readonly keyValidator;
     private readonly valueValidator;
     private readonly errorMessage?;
+    private readonly _checks;
     /**
      * Private constructor to enforce immutability
      */
@@ -16,6 +17,8 @@ export declare class VldMap<K, V> extends VldBase<unknown, Map<K, V>> {
     private readonly _simpleValueValue;
     get keySchema(): VldBase<unknown, K>;
     get valueSchema(): VldBase<unknown, V>;
+    get keyType(): VldBase<unknown, K>;
+    get valueType(): VldBase<unknown, V>;
     /**
      * Create a new Map validator
      */
@@ -36,4 +39,8 @@ export declare class VldMap<K, V> extends VldBase<unknown, Map<K, V>> {
      * Safely parse and validate a Map value
      */
     safeParse(value: unknown): ParseResult<Map<K, V>>;
+    min(size: number, message?: string): VldMap<K, V>;
+    max(size: number, message?: string): VldMap<K, V>;
+    size(size: number, message?: string): VldMap<K, V>;
+    nonempty(message?: string): VldMap<K, V>;
 }

package/dist/validators/map.js

@@ -1,214 +1 @@
-import { VldBase, VLD_VALIDATOR_TYPES } from './base.js';
-import { getMessages } from '../locales/runtime.js';
-import { V as VldError } from '../chunks/errors-core-BeiFUtZM.js';
-
-function createMapError(message) {
-    return new VldError([{ code: 'invalid_type', path: [], message }]);
-}
-/**
- * Immutable Map validator
- */
-class VldMap extends VldBase {
-    /**
-     * Private constructor to enforce immutability
-     */
-    constructor(keyValidator, valueValidator, errorMessage) {
-        super(VLD_VALIDATOR_TYPES.MAP);
-        this.keyValidator = keyValidator;
-        this.valueValidator = valueValidator;
-        this.errorMessage = errorMessage;
-        this._simpleKeyMode = this.getSimpleItemMode(keyValidator);
-        this._simpleValueMode = this.getSimpleItemMode(valueValidator);
-        this._simpleKeyValue = this._simpleKeyMode === 'literal' ? keyValidator.literal : undefined;
-        this._simpleValueValue = this._simpleValueMode === 'literal' ? valueValidator.literal : undefined;
-    }
-    get keySchema() {
-        return this.keyValidator;
-    }
-    get valueSchema() {
-        return this.valueValidator;
-    }
-    /**
-     * Create a new Map validator
-     */
-    static create(keyValidator, valueValidator) {
-        return new VldMap(keyValidator, valueValidator);
-    }
-    getSimpleItemMode(validator) {
-        if (validator.isSimple !== true) {
-            return undefined;
-        }
-        switch (validator.validatorType) {
-            case VLD_VALIDATOR_TYPES.STRING:
-                return 'string';
-            case VLD_VALIDATOR_TYPES.NUMBER:
-                return 'number';
-            case VLD_VALIDATOR_TYPES.BOOLEAN:
-                return 'boolean';
-            case VLD_VALIDATOR_TYPES.BIGINT:
-                return 'bigint';
-            case VLD_VALIDATOR_TYPES.SYMBOL:
-                return 'symbol';
-            case VLD_VALIDATOR_TYPES.NULL:
-                return 'null';
-            case VLD_VALIDATOR_TYPES.UNDEFINED:
-            case VLD_VALIDATOR_TYPES.VOID:
-                return 'undefinedValue';
-            case VLD_VALIDATOR_TYPES.LITERAL:
-                return 'literal';
-            case VLD_VALIDATOR_TYPES.ANY:
-            case VLD_VALIDATOR_TYPES.UNKNOWN:
-                return 'passthrough';
-            default:
-                return undefined;
-        }
-    }
-    getSimpleItemError(mode, expected, received) {
-        switch (mode) {
-            case 'string':
-                return getMessages().invalidString;
-            case 'number':
-                return getMessages().invalidNumber;
-            case 'boolean':
-                return getMessages().invalidBoolean;
-            case 'bigint':
-                return getMessages().invalidBigint;
-            case 'symbol':
-                return getMessages().invalidSymbol;
-            case 'null':
-                return `Expected null, received ${typeof received}`;
-            case 'undefinedValue':
-                return getMessages().expectedUndefined;
-            case 'literal':
-                return getMessages().literalExpected(JSON.stringify(expected), JSON.stringify(received));
-            default:
-                return getMessages().invalidMap;
-        }
-    }
-    parseSimpleItem(mode, expected, value) {
-        switch (mode) {
-            case 'string':
-                if (typeof value !== 'string') {
-                    throw new Error(this.getSimpleItemError(mode, expected, value));
-                }
-                return value;
-            case 'number':
-                if (typeof value !== 'number' || isNaN(value)) {
-                    throw new Error(this.getSimpleItemError(mode, expected, value));
-                }
-                return value;
-            case 'boolean':
-                if (typeof value !== 'boolean') {
-                    throw new Error(this.getSimpleItemError(mode, expected, value));
-                }
-                return value;
-            case 'bigint':
-                if (typeof value !== 'bigint') {
-                    throw new Error(this.getSimpleItemError(mode, expected, value));
-                }
-                return value;
-            case 'symbol':
-                if (typeof value !== 'symbol') {
-                    throw new Error(this.getSimpleItemError(mode, expected, value));
-                }
-                return value;
-            case 'null':
-                if (value !== null) {
-                    throw new Error(this.getSimpleItemError(mode, expected, value));
-                }
-                return null;
-            case 'undefinedValue':
-                if (value !== undefined) {
-                    throw new Error(this.getSimpleItemError(mode, expected, value));
-                }
-                return undefined;
-            case 'literal':
-                if (value !== expected) {
-                    throw new Error(this.getSimpleItemError(mode, expected, value));
-                }
-                return expected;
-            case 'passthrough':
-                return value;
-        }
-    }
-    /**
-     * Parse and validate a Map value
-     */
-    parse(value) {
-        if (!(value instanceof Map)) {
-            throw new Error(this.errorMessage || getMessages().invalidMap);
-        }
-        return this.parseKnownMap(value);
-    }
-    /**
-     * Parse a value that has already passed the Map instance guard.
-     * @internal Used by object validators to avoid duplicate hot-path checks.
-     */
-    parseKnownMap(value) {
-        const result = new Map();
-        const simpleKeyMode = this._simpleKeyMode;
-        const simpleValueMode = this._simpleValueMode;
-        if (simpleKeyMode === 'string' && simpleValueMode === 'number') {
-            for (const [key, val] of value) {
-                if (typeof key !== 'string') {
-                    throw new Error(this.getSimpleItemError(simpleKeyMode, this._simpleKeyValue, key));
-                }
-                if (typeof val !== 'number' || isNaN(val)) {
-                    throw new Error(this.getSimpleItemError(simpleValueMode, this._simpleValueValue, val));
-                }
-                result.set(key, val);
-            }
-            return result;
-        }
-        if (simpleKeyMode === 'string' && simpleValueMode === 'string') {
-            for (const [key, val] of value) {
-                if (typeof key !== 'string') {
-                    throw new Error(this.getSimpleItemError(simpleKeyMode, this._simpleKeyValue, key));
-                }
-                if (typeof val !== 'string') {
-                    throw new Error(this.getSimpleItemError(simpleValueMode, this._simpleValueValue, val));
-                }
-                result.set(key, val);
-            }
-            return result;
-        }
-        if (simpleKeyMode !== undefined && simpleValueMode !== undefined) {
-            const keyMode = simpleKeyMode;
-            const valueMode = simpleValueMode;
-            for (const [key, val] of value) {
-                const validKey = this.parseSimpleItem(keyMode, this._simpleKeyValue, key);
-                const validValue = this.parseSimpleItem(valueMode, this._simpleValueValue, val);
-                result.set(validKey, validValue);
-            }
-            return result;
-        }
-        for (const [key, val] of value) {
-            try {
-                const validKey = simpleKeyMode === undefined
-                    ? this.keyValidator.parse(key)
-                    : this.parseSimpleItem(simpleKeyMode, this._simpleKeyValue, key);
-                const validValue = simpleValueMode === undefined
-                    ? this.valueValidator.parse(val)
-                    : this.parseSimpleItem(simpleValueMode, this._simpleValueValue, val);
-                result.set(validKey, validValue);
-            }
-            catch (error) {
-                throw new Error(error.message);
-            }
-        }
-        return result;
-    }
-    /**
-     * Safely parse and validate a Map value
-     */
-    safeParse(value) {
-        try {
-            return { success: true, data: this.parse(value) };
-        }
-        catch (error) {
-            return { success: false, error: createMapError(error.message) };
-        }
-    }
-}
-
-export { VldMap };
+import{VldBase as e,VLD_VALIDATOR_TYPES as r}from"./base.js";import{getMessages as t}from"../locales/runtime.js";import{V as s}from"../chunks/errors-core-CerMg2rq.js";class VldMap extends e{constructor(e,t,s,i=[]){super(r.MAP),this.keyValidator=e,this.valueValidator=t,this.errorMessage=s,this._checks=i,this._simpleKeyMode=this.getSimpleItemMode(e),this._simpleValueMode=this.getSimpleItemMode(t),this._simpleKeyValue="literal"===this._simpleKeyMode?e.literal:void 0,this._simpleValueValue="literal"===this._simpleValueMode?t.literal:void 0}get keySchema(){return this.keyValidator}get valueSchema(){return this.valueValidator}get keyType(){return this.keyValidator}get valueType(){return this.valueValidator}static create(e,r){return new VldMap(e,r)}getSimpleItemMode(e){if(!0===e.isSimple)switch(e.validatorType){case r.STRING:return"string";case r.NUMBER:return"number";case r.BOOLEAN:return"boolean";case r.BIGINT:return"bigint";case r.SYMBOL:return"symbol";case r.NULL:return"null";case r.UNDEFINED:case r.VOID:return"undefinedValue";case r.LITERAL:return"literal";case r.ANY:case r.UNKNOWN:return"passthrough";default:return}}getSimpleItemError(e,r,s){switch(e){case"string":return t().invalidString;case"number":return t().invalidNumber;case"boolean":return t().invalidBoolean;case"bigint":return t().invalidBigint;case"symbol":return t().invalidSymbol;case"null":return"Expected null, received "+typeof s;case"undefinedValue":return t().expectedUndefined;case"literal":return t().literalExpected(JSON.stringify(r),JSON.stringify(s));default:return t().invalidMap}}parseSimpleItem(e,r,t){switch(e){case"string":if("string"!=typeof t)throw new Error(this.getSimpleItemError(e,r,t));return t;case"number":if("number"!=typeof t||isNaN(t))throw new Error(this.getSimpleItemError(e,r,t));return t;case"boolean":if("boolean"!=typeof t)throw new Error(this.getSimpleItemError(e,r,t));return t;case"bigint":if("bigint"!=typeof t)throw new Error(this.getSimpleItemError(e,r,t));return t;case"symbol":if("symbol"!=typeof t)throw new Error(this.getSimpleItemError(e,r,t));return t;case"null":if(null!==t)throw new Error(this.getSimpleItemError(e,r,t));return null;case"undefinedValue":if(void 0!==t)throw new Error(this.getSimpleItemError(e,r,t));return;case"literal":if(t!==r)throw new Error(this.getSimpleItemError(e,r,t));return r;case"passthrough":return t}}parse(e){if(!(e instanceof Map))throw new Error(this.errorMessage||t().invalidMap);return this.parseKnownMap(e)}parseKnownMap(e){const r=new Map,t=this._simpleKeyMode,s=this._simpleValueMode;if("string"===t&&"number"===s)for(const[i,a]of e){if("string"!=typeof i)throw new Error(this.getSimpleItemError(t,this._simpleKeyValue,i));if("number"!=typeof a||isNaN(a))throw new Error(this.getSimpleItemError(s,this._simpleValueValue,a));r.set(i,a)}else if("string"===t&&"string"===s)for(const[i,a]of e){if("string"!=typeof i)throw new Error(this.getSimpleItemError(t,this._simpleKeyValue,i));if("string"!=typeof a)throw new Error(this.getSimpleItemError(s,this._simpleValueValue,a));r.set(i,a)}else if(void 0!==t&&void 0!==s){const i=t,a=s;for(const[t,s]of e){const e=this.parseSimpleItem(i,this._simpleKeyValue,t),n=this.parseSimpleItem(a,this._simpleValueValue,s);r.set(e,n)}}else for(const[i,a]of e)try{const e=void 0===t?this.keyValidator.parse(i):this.parseSimpleItem(t,this._simpleKeyValue,i),n=void 0===s?this.valueValidator.parse(a):this.parseSimpleItem(s,this._simpleValueValue,a);r.set(e,n)}catch(e){throw new Error(e.message)}for(const e of this._checks)if(!e.fn(r))throw new Error(e.message);return r}safeParse(e){try{return{success:!0,data:this.parse(e)}}catch(e){return{success:!1,error:(r=e.message,new s([{code:"invalid_type",path:[],message:r}]))}}var r}min(e,r){return new VldMap(this.keyValidator,this.valueValidator,this.errorMessage,[...this._checks,{fn:r=>r.size>=e,message:r||`Map must contain at least ${e} entries`}])}max(e,r){return new VldMap(this.keyValidator,this.valueValidator,this.errorMessage,[...this._checks,{fn:r=>r.size<=e,message:r||`Map must contain at most ${e} entries`}])}size(e,r){return new VldMap(this.keyValidator,this.valueValidator,this.errorMessage,[...this._checks,{fn:r=>r.size===e,message:r||`Map must contain exactly ${e} entries`}])}nonempty(e){return this.min(1,e||"Map cannot be empty")}}export{VldMap};

package/dist/validators/nan.js

@@ -1,38 +1 @@
-import { VldBase, VLD_VALIDATOR_TYPES } from './base.js';
-import { V as VldError } from '../chunks/errors-core-BeiFUtZM.js';
-
-/**
- * VldNan - Validates that a value is NaN (Not a Number)
- * Part of Zod 4 API parity implementation
- */
-function createNanError(message) {
-    return new VldError([{ code: 'invalid_number', path: [], message }]);
-}
-/**
- * NaN validator - validates that a value is NaN
- * Note: Uses Number.isNaN() which is more strict than global isNaN()
- */
-class VldNan extends VldBase {
-    constructor() {
-        super(VLD_VALIDATOR_TYPES.NAN);
-    }
-    static create() {
-        return new VldNan();
-    }
-    parse(value) {
-        if (typeof value !== 'number' || !Number.isNaN(value)) {
-            throw new Error(`Expected NaN, received ${typeof value === 'number' ? 'a valid number' : typeof value}`);
-        }
-        return value;
-    }
-    safeParse(value) {
-        try {
-            return { success: true, data: this.parse(value) };
-        }
-        catch (error) {
-            return { success: false, error: createNanError(error.message) };
-        }
-    }
-}
-
-export { VldNan };
+import{VldBase as e,VLD_VALIDATOR_TYPES as r}from"./base.js";import{V as s}from"../chunks/errors-core-CerMg2rq.js";class VldNan extends e{constructor(){super(r.NAN)}static create(){return new VldNan}parse(e){if("number"!=typeof e||!Number.isNaN(e))throw new Error("Expected NaN, received "+("number"==typeof e?"a valid number":typeof e));return e}safeParse(e){try{return{success:!0,data:this.parse(e)}}catch(e){return{success:!1,error:(r=e.message,new s([{code:"invalid_number",path:[],message:r}]))}}var r}}export{VldNan};

package/dist/validators/never.js

@@ -1,32 +1 @@
-import { VldBase } from './base.js';
-import { getMessages } from '../locales/runtime.js';
-import { V as VldError } from '../chunks/errors-core-BeiFUtZM.js';
-
-/**
- * Validator that never succeeds
- */
-class VldNever extends VldBase {
-    /**
-     * Create a new never validator
-     */
-    static create() {
-        return new VldNever();
-    }
-    /**
-     * Parse never value (always fails)
-     */
-    parse(_value) {
-        throw new Error(getMessages().neverType);
-    }
-    /**
-     * Safely parse never value (always fails)
-     */
-    safeParse(_value) {
-        return {
-            success: false,
-            error: new VldError([{ code: 'invalid_type', path: [], message: getMessages().neverType }])
-        };
-    }
-}
-
-export { VldNever };
+import{VldBase as e}from"./base.js";import{getMessages as r}from"../locales/runtime.js";import{V as s}from"../chunks/errors-core-CerMg2rq.js";class VldNever extends e{static create(){return new VldNever}parse(e){throw new Error(r().neverType)}safeParse(e){return{success:!1,error:new s([{code:"invalid_type",path:[],message:r().neverType}])}}}export{VldNever};

package/dist/validators/null.js

@@ -1,40 +1 @@
-import { VldBase, VLD_VALIDATOR_TYPES } from './base.js';
-import { V as VldError } from '../chunks/errors-core-BeiFUtZM.js';
-
-/**
- * VldNull - Validates that a value is exactly null
- * Part of Zod 4 API parity implementation
- */
-function createNullError(message) {
-    return new VldError([{ code: 'invalid_type', path: [], message }]);
-}
-/**
- * Null validator - validates that a value is exactly null
- */
-class VldNull extends VldBase {
-    constructor() {
-        super(VLD_VALIDATOR_TYPES.NULL);
-    }
-    static create() {
-        return new VldNull();
-    }
-    get isSimple() {
-        return true;
-    }
-    parse(value) {
-        if (value !== null) {
-            throw new Error(`Expected null, received ${typeof value}`);
-        }
-        return null;
-    }
-    safeParse(value) {
-        try {
-            return { success: true, data: this.parse(value) };
-        }
-        catch (error) {
-            return { success: false, error: createNullError(error.message) };
-        }
-    }
-}
-
-export { VldNull };
+import{VldBase as e,VLD_VALIDATOR_TYPES as r}from"./base.js";import{V as s}from"../chunks/errors-core-CerMg2rq.js";class VldNull extends e{constructor(){super(r.NULL)}static create(){return new VldNull}get isSimple(){return!0}parse(e){if(null!==e)throw new Error("Expected null, received "+typeof e);return null}safeParse(e){try{return{success:!0,data:this.parse(e)}}catch(e){return{success:!1,error:(r=e.message,new s([{code:"invalid_type",path:[],message:r}]))}}var r}}export{VldNull};

package/dist/validators/number.d.ts

@@ -3,6 +3,15 @@ import { VldBase, ParseResult, ValidatorType, type ErrorParam } from './base.js'
  * Type for number validation check functions
  */
 type NumberCheck = (value: number) => boolean;
+/**
+ * Metadata for a single number constraint, enabling Zod 4-compatible issues.
+ */
+interface NumberCheckMeta {
+    readonly kind: 'min' | 'max' | 'int' | 'gt' | 'lt' | 'multiple_of' | 'finite' | 'safe' | 'other';
+    readonly value?: number;
+    readonly inclusive?: boolean;
+    readonly message: string | undefined;
+}
 interface NumberJSONSchemaHints {
     type?: 'number' | 'integer';
     minimum?: number;
@@ -19,6 +28,7 @@ interface NumberValidatorConfig {
     readonly errorMessage: string | undefined;
     readonly validatorType?: ValidatorType;
     readonly jsonSchema: NumberJSONSchemaHints | undefined;
+    readonly checkMetas: ReadonlyArray<NumberCheckMeta> | undefined;
 }
 /**
  * Immutable number validator with chainable methods
@@ -28,6 +38,7 @@ export declare class VldNumber extends VldBase<number, number> {
     private readonly _checks;
     private readonly _isSimple;
     private readonly _fastCheckMode;
+    private readonly _checkMetas;
     /**
      * Protected constructor to allow extension while maintaining immutability
      */
@@ -43,20 +54,33 @@ export declare class VldNumber extends VldBase<number, number> {
      * Used by VldObject for optimized fast-path dispatch
      */
     get isSimple(): boolean;
+    get minValue(): number | null;
+    get maxValue(): number | null;
+    get isInt(): boolean;
+    get isFinite(): boolean;
+    get format(): string | null;
     /**
      * Create a new number validator
      */
     static create(): VldNumber;
     /**
      * Parse and validate a number value
+     * Zod 4 behavior: Infinity and NaN are rejected by default (they are not valid numbers).
      */
     parse(value: unknown): number;
+    /**
+     * Build the Zod 4-compatible VldIssue for a failed number check.
+     */
+    private _createCheckIssue;
+    /**
+     * Run all checks against a known number and return the index of the first failing check, or -1.
+     */
+    private _findFailingCheck;
     /**
      * Parse a value that has already passed the number type guard.
      * @internal Used by object validators to avoid duplicate hot-path checks.
      */
     parseKnownNumber(value: number): number;
-    private passesChecks;
     /**
      * Safely parse and validate a number value
      */