@oxog/vld 2.1.0 → 2.2.5

package/dist/validators/number.js

@@ -1,423 +1 @@
-import { VldBase, VLD_VALIDATOR_TYPES, resolveErrorMessage } from './base.js';
-import { getMessages } from '../locales/runtime.js';
-import { V as VldError } from '../chunks/errors-core-BeiFUtZM.js';
-
-function createNumberError(message) {
-    return new VldError([{ code: 'invalid_number', path: [], message }]);
-}
-/**
- * Immutable number validator with chainable methods
- */
-class VldNumber extends VldBase {
-    /**
-     * Protected constructor to allow extension while maintaining immutability
-     */
-    constructor(config) {
-        super(config?.validatorType || VLD_VALIDATOR_TYPES.NUMBER);
-        this.config = {
-            checks: config?.checks || [],
-            errorMessage: config?.errorMessage,
-            jsonSchema: config?.jsonSchema
-        };
-        this._checks = this.config.checks;
-        this._isSimple = this._checks.length === 0;
-        this._fastCheckMode = this.detectFastCheckMode();
-    }
-    detectFastCheckMode() {
-        const schema = this.config.jsonSchema;
-        if (this._checks.length === 0) {
-            return 'none';
-        }
-        if (this._checks.length === 1 &&
-            schema?.exclusiveMinimum === 0 &&
-            schema.type !== 'integer') {
-            return 'positive';
-        }
-        if (this._checks.length === 2 &&
-            schema?.exclusiveMinimum === 0 &&
-            schema.type === 'integer') {
-            return 'positive-int';
-        }
-        return undefined;
-    }
-    /**
-     * Returns true if this validator has custom checks (min, max, positive, etc.)
-     * Used by VldObject for optimized fast-path dispatch
-     */
-    get hasCustomChecks() {
-        return !this._isSimple;
-    }
-    /**
-     * Returns true if this is a simple number validator with no custom checks
-     * Used by VldObject for optimized fast-path dispatch
-     */
-    get isSimple() {
-        return this._isSimple;
-    }
-    /**
-     * Create a new number validator
-     */
-    static create() {
-        return new VldNumber();
-    }
-    /**
-     * Parse and validate a number value
-     */
-    parse(value) {
-        if (typeof value !== 'number' || isNaN(value)) {
-            throw new Error(this.config.errorMessage || getMessages().invalidNumber);
-        }
-        switch (this._fastCheckMode) {
-            case 'none':
-                return value;
-            case 'positive':
-                if (value > 0)
-                    return value;
-                throw new Error(this.config.errorMessage || getMessages().invalidNumber);
-            case 'positive-int':
-                if (value > 0 && Number.isInteger(value))
-                    return value;
-                throw new Error(this.config.errorMessage || getMessages().invalidNumber);
-        }
-        return this.parseKnownNumber(value);
-    }
-    /**
-     * Parse a value that has already passed the number type guard.
-     * @internal Used by object validators to avoid duplicate hot-path checks.
-     */
-    parseKnownNumber(value) {
-        switch (this._fastCheckMode) {
-            case 'none':
-                return value;
-            case 'positive':
-                if (value > 0)
-                    return value;
-                throw new Error(this.config.errorMessage || getMessages().invalidNumber);
-            case 'positive-int':
-                if (value > 0 && Number.isInteger(value))
-                    return value;
-                throw new Error(this.config.errorMessage || getMessages().invalidNumber);
-        }
-        const checks = this._checks;
-        switch (checks.length) {
-            case 1:
-                if (checks[0](value))
-                    return value;
-                break;
-            case 2:
-                if (checks[0](value) && checks[1](value))
-                    return value;
-                break;
-            case 3:
-                if (checks[0](value) && checks[1](value) && checks[2](value))
-                    return value;
-                break;
-            default:
-                for (let i = 0; i < checks.length; i++) {
-                    if (!checks[i](value)) {
-                        throw new Error(this.config.errorMessage || getMessages().invalidNumber);
-                    }
-                }
-                return value;
-        }
-        throw new Error(this.config.errorMessage || getMessages().invalidNumber);
-    }
-    passesChecks(value) {
-        switch (this._fastCheckMode) {
-            case 'none':
-                return true;
-            case 'positive':
-                return value > 0;
-            case 'positive-int':
-                return value > 0 && Number.isInteger(value);
-        }
-        const checks = this._checks;
-        switch (checks.length) {
-            case 1:
-                return checks[0](value);
-            case 2:
-                return checks[0](value) && checks[1](value);
-            case 3:
-                return checks[0](value) && checks[1](value) && checks[2](value);
-            default:
-                for (let i = 0; i < checks.length; i++) {
-                    if (!checks[i](value)) {
-                        return false;
-                    }
-                }
-                return true;
-        }
-    }
-    /**
-     * Safely parse and validate a number value
-     */
-    safeParse(value) {
-        try {
-            if (typeof value !== 'number' || isNaN(value) || !this.passesChecks(value)) {
-                return { success: false, error: createNumberError(this.config.errorMessage || getMessages().invalidNumber) };
-            }
-            return { success: true, data: value };
-        }
-        catch (error) {
-            return { success: false, error: createNumberError(error.message) };
-        }
-    }
-    /**
-     * Create a new validator with minimum value constraint
-     */
-    min(value, message) {
-        return new VldNumber({
-            checks: [...this.config.checks, (v) => v >= value],
-            errorMessage: resolveErrorMessage(message, getMessages().numberMin(value)),
-            jsonSchema: { ...this.config.jsonSchema, minimum: value }
-        });
-    }
-    /**
-     * Create a new validator with maximum value constraint
-     */
-    max(value, message) {
-        return new VldNumber({
-            checks: [...this.config.checks, (v) => v <= value],
-            errorMessage: resolveErrorMessage(message, getMessages().numberMax(value)),
-            jsonSchema: { ...this.config.jsonSchema, maximum: value }
-        });
-    }
-    /**
-     * Create a new validator that checks for integer values
-     */
-    int(message) {
-        return new VldNumber({
-            checks: [...this.config.checks, (v) => Number.isInteger(v)],
-            errorMessage: resolveErrorMessage(message, getMessages().numberInt),
-            jsonSchema: { ...this.config.jsonSchema, type: 'integer' }
-        });
-    }
-    /**
-     * Create a new validator that checks for positive values
-     */
-    positive(message) {
-        return new VldNumber({
-            checks: [...this.config.checks, (v) => v > 0],
-            errorMessage: resolveErrorMessage(message, getMessages().numberPositive),
-            jsonSchema: { ...this.config.jsonSchema, exclusiveMinimum: 0 }
-        });
-    }
-    /**
-     * Create a new validator that checks for negative values
-     */
-    negative(message) {
-        return new VldNumber({
-            checks: [...this.config.checks, (v) => v < 0],
-            errorMessage: resolveErrorMessage(message, getMessages().numberNegative),
-            jsonSchema: { ...this.config.jsonSchema, exclusiveMaximum: 0 }
-        });
-    }
-    /**
-     * Create a new validator that checks for non-negative values
-     */
-    nonnegative(message) {
-        return new VldNumber({
-            checks: [...this.config.checks, (v) => v >= 0],
-            errorMessage: resolveErrorMessage(message, getMessages().numberNonnegative),
-            jsonSchema: { ...this.config.jsonSchema, minimum: 0 }
-        });
-    }
-    /**
-     * Create a new validator that checks for non-positive values
-     */
-    nonpositive(message) {
-        return new VldNumber({
-            checks: [...this.config.checks, (v) => v <= 0],
-            errorMessage: resolveErrorMessage(message, getMessages().numberNonpositive),
-            jsonSchema: { ...this.config.jsonSchema, maximum: 0 }
-        });
-    }
-    /**
-     * Create a new validator that checks for finite values
-     */
-    finite(message) {
-        return new VldNumber({
-            checks: [...this.config.checks, (v) => Number.isFinite(v)],
-            errorMessage: resolveErrorMessage(message, getMessages().numberFinite),
-            jsonSchema: this.config.jsonSchema
-        });
-    }
-    /**
-     * Create a new validator that checks for safe integer values
-     */
-    safe(message) {
-        return new VldNumber({
-            checks: [...this.config.checks, (v) => Number.isSafeInteger(v)],
-            errorMessage: resolveErrorMessage(message, getMessages().numberSafe),
-            jsonSchema: { ...this.config.jsonSchema, type: 'integer' }
-        });
-    }
-    /**
-     * Create a new validator that checks if value is multiple of another
-     */
-    multipleOf(value, message) {
-        return new VldNumber({
-            checks: [...this.config.checks, (v) => {
-                    // Use epsilon comparison for floating point precision
-                    const remainder = Math.abs(v % value);
-                    return remainder < Number.EPSILON || Math.abs(remainder - Math.abs(value)) < Number.EPSILON;
-                }],
-            errorMessage: resolveErrorMessage(message, getMessages().numberMultipleOf(value)),
-            jsonSchema: { ...this.config.jsonSchema, multipleOf: value }
-        });
-    }
-    /**
-     * Alias for multipleOf
-     */
-    step(value, message) {
-        return this.multipleOf(value, message);
-    }
-    /**
-     * Create a new validator with a range constraint
-     */
-    between(min, max, message) {
-        return new VldNumber({
-            checks: [...this.config.checks, (v) => v >= min && v <= max],
-            errorMessage: resolveErrorMessage(message, `Number must be between ${min} and ${max}`),
-            jsonSchema: { ...this.config.jsonSchema, minimum: min, maximum: max }
-        });
-    }
-    /**
-     * Create a new validator that checks for even numbers
-     * BUG-011 FIX: Require integers for even/odd validation (more mathematically correct)
-     */
-    even(message) {
-        return new VldNumber({
-            checks: [...this.config.checks, (v) => {
-                    // Even/odd only makes sense for integers
-                    if (!Number.isInteger(v)) {
-                        return false;
-                    }
-                    return v % 2 === 0;
-                }],
-            errorMessage: resolveErrorMessage(message, 'Number must be even'),
-            jsonSchema: { ...this.config.jsonSchema, type: 'integer', multipleOf: 2 }
-        });
-    }
-    /**
-     * Create a new validator that checks for odd numbers
-     * BUG-011 FIX: Require integers for even/odd validation (more mathematically correct)
-     */
-    odd(message) {
-        return new VldNumber({
-            checks: [...this.config.checks, (v) => {
-                    // Even/odd only makes sense for integers
-                    if (!Number.isInteger(v)) {
-                        return false;
-                    }
-                    return v % 2 !== 0;
-                }],
-            errorMessage: resolveErrorMessage(message, 'Number must be odd'),
-            jsonSchema: { ...this.config.jsonSchema, type: 'integer' }
-        });
-    }
-    /**
-     * Create a new validator with strict greater than constraint
-     * Zod 4 API parity - strictly greater than (not equal to)
-     */
-    gt(value, message) {
-        return new VldNumber({
-            checks: [...this.config.checks, (v) => v > value],
-            errorMessage: resolveErrorMessage(message, `Number must be greater than ${value}`),
-            jsonSchema: { ...this.config.jsonSchema, exclusiveMinimum: value }
-        });
-    }
-    /**
-     * Create a new validator with strict less than constraint
-     * Zod 4 API parity - strictly less than (not equal to)
-     */
-    lt(value, message) {
-        return new VldNumber({
-            checks: [...this.config.checks, (v) => v < value],
-            errorMessage: resolveErrorMessage(message, `Number must be less than ${value}`),
-            jsonSchema: { ...this.config.jsonSchema, exclusiveMaximum: value }
-        });
-    }
-    /**
-     * Create a new validator with greater than or equal constraint
-     * Zod 4 API parity - alias for min()
-     */
-    gte(value, message) {
-        return this.min(value, message);
-    }
-    /**
-     * Create a new validator with less than or equal constraint
-     * Zod 4 API parity - alias for max()
-     */
-    lte(value, message) {
-        return this.max(value, message);
-    }
-    /**
-     * Create a validator for unsigned 32-bit integers
-     * Range: 0 to 4,294,967,295
-     */
-    uint32(message) {
-        return new VldNumber({
-            checks: [...this.config.checks, (v) => Number.isSafeInteger(v) && v >= 0 && v <= 4294967295],
-            errorMessage: resolveErrorMessage(message, 'Expected an unsigned 32-bit integer'),
-            jsonSchema: { ...this.config.jsonSchema, type: 'integer', minimum: 0, maximum: 4294967295 }
-        });
-    }
-    /**
-     * Create a validator for unsigned 64-bit integers
-     * Range: 0 to 2^53-1 (safe integer limit)
-     */
-    uint64(message) {
-        return new VldNumber({
-            checks: [...this.config.checks, (v) => Number.isSafeInteger(v) && v >= 0],
-            errorMessage: resolveErrorMessage(message, 'Expected an unsigned 64-bit integer'),
-            jsonSchema: { ...this.config.jsonSchema, type: 'integer', minimum: 0 }
-        });
-    }
-    /**
-     * Create a validator for signed 32-bit integers
-     * Range: -2,147,483,648 to 2,147,483,647
-     */
-    int32(message) {
-        return new VldNumber({
-            checks: [...this.config.checks, (v) => Number.isSafeInteger(v) && v >= -2147483648 && v <= 2147483647],
-            errorMessage: resolveErrorMessage(message, 'Expected a signed 32-bit integer'),
-            jsonSchema: { ...this.config.jsonSchema, type: 'integer', minimum: -2147483648, maximum: 2147483647 }
-        });
-    }
-    /**
-     * Create a validator for signed 64-bit integers
-     * Range: -(2^53-1) to 2^53-1 (safe integer limit)
-     */
-    int64(message) {
-        return new VldNumber({
-            checks: [...this.config.checks, (v) => Number.isSafeInteger(v)],
-            errorMessage: resolveErrorMessage(message, 'Expected a signed 64-bit integer'),
-            jsonSchema: { ...this.config.jsonSchema, type: 'integer' }
-        });
-    }
-    /**
-     * Create a validator for 32-bit floats (IEEE 754 single precision)
-     * Range: -3.4e38 to 3.4e38, precision ~7 decimal digits
-     */
-    float32(message) {
-        return new VldNumber({
-            checks: [...this.config.checks, (v) => Number.isFinite(v) && Math.abs(v) <= 3.4e38],
-            errorMessage: resolveErrorMessage(message, 'Expected a 32-bit float'),
-            jsonSchema: { ...this.config.jsonSchema, minimum: -34e37, maximum: 3.4e38 }
-        });
-    }
-    /**
-     * Create a validator for 64-bit floats (IEEE 754 double precision)
-     * Alias for standard number validation
-     */
-    float64(message) {
-        return new VldNumber({
-            checks: [...this.config.checks, (v) => Number.isFinite(v)],
-            errorMessage: resolveErrorMessage(message, 'Expected a 64-bit float'),
-            jsonSchema: this.config.jsonSchema
-        });
-    }
-}
-
-export { VldNumber };
+import{VldBase as e,VLD_VALIDATOR_TYPES as s,resolveErrorMessage as i}from"./base.js";import{getMessages as n}from"../locales/runtime.js";import{V as t,c,g as r}from"../chunks/errors-core-Cqi4-9ew.js";class VldNumber extends e{constructor(e){super(e?.validatorType||s.NUMBER),this.config={checks:e?.checks||[],errorMessage:e?.errorMessage,jsonSchema:e?.jsonSchema,checkMetas:e?.checkMetas},this._checks=this.config.checks,this._isSimple=0===this._checks.length,this._fastCheckMode=this.detectFastCheckMode(),this._checkMetas=this.config.checkMetas}detectFastCheckMode(){const e=this.config.jsonSchema;return 0===this._checks.length?"none":1===this._checks.length&&0===e?.exclusiveMinimum&&"integer"!==e.type?"positive":2===this._checks.length&&0===e?.exclusiveMinimum&&"integer"===e.type?"positive-int":void 0}get hasCustomChecks(){return!this._isSimple}get isSimple(){return this._isSimple}static create(){return new VldNumber}parse(e){if("number"!=typeof e||!Number.isFinite(e))throw new t([c("number",r(e),this.config.errorMessage)]);switch(this._fastCheckMode){case"none":return e;case"positive":if(e>0)return e;throw new t([this._createCheckIssue("gt",0,this.config.errorMessage)]);case"positive-int":if(e>0&&Number.isInteger(e))return e;throw new t([this._createCheckIssue("int",void 0,this.config.errorMessage)])}return this.parseKnownNumber(e)}_createCheckIssue(e,s,i){switch(e){case"min":return{code:"too_small",path:[],origin:"number",minimum:s,inclusive:!0,message:i||`Too small: expected number to be >=${s}`};case"max":return{code:"too_big",path:[],origin:"number",maximum:s,inclusive:!0,message:i||`Too big: expected number to be <=${s}`};case"gt":return{code:"too_small",path:[],origin:"number",minimum:s,inclusive:!1,message:i||`Too small: expected number to be >${s}`};case"lt":return{code:"too_big",path:[],origin:"number",maximum:s,inclusive:!1,message:i||`Too big: expected number to be <${s}`};case"int":return{code:"invalid_type",path:[],expected:"int",received:"number",message:i||"Invalid input: expected int, received number"};default:return{code:"custom",path:[],message:i||"Invalid number"}}}_findFailingCheck(e){const s=this._checks,i=this._checkMetas;for(let n=0;n<s.length;n++)if(!s[n](e))return i?.[n]??{kind:"other",message:this.config.errorMessage};return null}parseKnownNumber(e){switch(this._fastCheckMode){case"none":return e;case"positive":if(e>0)return e;throw new t([this._createCheckIssue("gt",0,this.config.errorMessage)]);case"positive-int":if(e>0&&Number.isInteger(e))return e;throw new t([this._createCheckIssue("int",void 0,this.config.errorMessage)])}const s=this._findFailingCheck(e);if(s)throw new t([this._createCheckIssue(s.kind,s.value,s.message)]);return e}safeParse(e){if("number"!=typeof e||!Number.isFinite(e))return{success:!1,error:new t([c("number",r(e),this.config.errorMessage)])};try{const s=this._findFailingCheck(e);if(s)return{success:!1,error:new t([this._createCheckIssue(s.kind,s.value,s.message)])}}catch(e){return e instanceof t?{success:!1,error:e}:{success:!1,error:new t([{code:"custom",path:[],message:e.message}])}}return{success:!0,data:e}}min(e,s){return new VldNumber({checks:[...this.config.checks,s=>s>=e],errorMessage:i(s,n().numberMin(e)),jsonSchema:{...this.config.jsonSchema,minimum:e},checkMetas:[...this.config.checkMetas??[],{kind:"min",value:e,inclusive:!0,message:i(s,n().numberMin(e))}]})}max(e,s){return new VldNumber({checks:[...this.config.checks,s=>s<=e],errorMessage:i(s,n().numberMax(e)),jsonSchema:{...this.config.jsonSchema,maximum:e},checkMetas:[...this.config.checkMetas??[],{kind:"max",value:e,inclusive:!0,message:i(s,n().numberMax(e))}]})}int(e){return new VldNumber({checks:[...this.config.checks,e=>Number.isInteger(e)],errorMessage:i(e,n().numberInt),jsonSchema:{...this.config.jsonSchema,type:"integer"},checkMetas:[...this.config.checkMetas??[],{kind:"int",message:i(e,n().numberInt)}]})}positive(e){return new VldNumber({checks:[...this.config.checks,e=>e>0],errorMessage:i(e,n().numberPositive),jsonSchema:{...this.config.jsonSchema,exclusiveMinimum:0},checkMetas:[...this.config.checkMetas??[],{kind:"gt",value:0,inclusive:!1,message:i(e,n().numberPositive)}]})}negative(e){return new VldNumber({checks:[...this.config.checks,e=>e<0],errorMessage:i(e,n().numberNegative),jsonSchema:{...this.config.jsonSchema,exclusiveMaximum:0},checkMetas:[...this.config.checkMetas??[],{kind:"lt",value:0,inclusive:!1,message:i(e,n().numberNegative)}]})}nonnegative(e){return new VldNumber({checks:[...this.config.checks,e=>e>=0],errorMessage:i(e,n().numberNonnegative),jsonSchema:{...this.config.jsonSchema,minimum:0},checkMetas:[...this.config.checkMetas??[],{kind:"min",value:0,inclusive:!0,message:i(e,n().numberNonnegative)}]})}nonpositive(e){return new VldNumber({checks:[...this.config.checks,e=>e<=0],errorMessage:i(e,n().numberNonpositive),jsonSchema:{...this.config.jsonSchema,maximum:0},checkMetas:[...this.config.checkMetas??[],{kind:"max",value:0,inclusive:!0,message:i(e,n().numberNonpositive)}]})}finite(e){return new VldNumber({checks:[...this.config.checks,e=>Number.isFinite(e)],errorMessage:i(e,n().numberFinite),jsonSchema:this.config.jsonSchema})}safe(e){return new VldNumber({checks:[...this.config.checks,e=>Number.isSafeInteger(e)],errorMessage:i(e,n().numberSafe),jsonSchema:{...this.config.jsonSchema,type:"integer"}})}multipleOf(e,s){return new VldNumber({checks:[...this.config.checks,s=>{const i=Math.abs(s%e);return i<Number.EPSILON||Math.abs(i-Math.abs(e))<Number.EPSILON}],errorMessage:i(s,n().numberMultipleOf(e)),jsonSchema:{...this.config.jsonSchema,multipleOf:e}})}step(e,s){return this.multipleOf(e,s)}between(e,s,n){return new VldNumber({checks:[...this.config.checks,i=>i>=e&&i<=s],errorMessage:i(n,`Number must be between ${e} and ${s}`),jsonSchema:{...this.config.jsonSchema,minimum:e,maximum:s}})}even(e){return new VldNumber({checks:[...this.config.checks,e=>!!Number.isInteger(e)&&e%2==0],errorMessage:i(e,"Number must be even"),jsonSchema:{...this.config.jsonSchema,type:"integer",multipleOf:2}})}odd(e){return new VldNumber({checks:[...this.config.checks,e=>!!Number.isInteger(e)&&e%2!=0],errorMessage:i(e,"Number must be odd"),jsonSchema:{...this.config.jsonSchema,type:"integer"}})}gt(e,s){return new VldNumber({checks:[...this.config.checks,s=>s>e],errorMessage:i(s,`Number must be greater than ${e}`),jsonSchema:{...this.config.jsonSchema,exclusiveMinimum:e},checkMetas:[...this.config.checkMetas??[],{kind:"gt",value:e,inclusive:!1,message:i(s,`Number must be greater than ${e}`)}]})}lt(e,s){return new VldNumber({checks:[...this.config.checks,s=>s<e],errorMessage:i(s,`Number must be less than ${e}`),jsonSchema:{...this.config.jsonSchema,exclusiveMaximum:e},checkMetas:[...this.config.checkMetas??[],{kind:"lt",value:e,inclusive:!1,message:i(s,`Number must be less than ${e}`)}]})}gte(e,s){return this.min(e,s)}lte(e,s){return this.max(e,s)}uint32(e){return new VldNumber({checks:[...this.config.checks,e=>Number.isSafeInteger(e)&&e>=0&&e<=4294967295],errorMessage:i(e,"Expected an unsigned 32-bit integer"),jsonSchema:{...this.config.jsonSchema,type:"integer",minimum:0,maximum:4294967295}})}uint64(e){return new VldNumber({checks:[...this.config.checks,e=>Number.isSafeInteger(e)&&e>=0],errorMessage:i(e,"Expected an unsigned 64-bit integer"),jsonSchema:{...this.config.jsonSchema,type:"integer",minimum:0}})}int32(e){return new VldNumber({checks:[...this.config.checks,e=>Number.isSafeInteger(e)&&e>=-2147483648&&e<=2147483647],errorMessage:i(e,"Expected a signed 32-bit integer"),jsonSchema:{...this.config.jsonSchema,type:"integer",minimum:-2147483648,maximum:2147483647}})}int64(e){return new VldNumber({checks:[...this.config.checks,e=>Number.isSafeInteger(e)],errorMessage:i(e,"Expected a signed 64-bit integer"),jsonSchema:{...this.config.jsonSchema,type:"integer"}})}float32(e){return new VldNumber({checks:[...this.config.checks,e=>Number.isFinite(e)&&Math.abs(e)<=34e37],errorMessage:i(e,"Expected a 32-bit float"),jsonSchema:{...this.config.jsonSchema,minimum:-34e37,maximum:34e37}})}float64(e){return new VldNumber({checks:[...this.config.checks,e=>Number.isFinite(e)],errorMessage:i(e,"Expected a 64-bit float"),jsonSchema:this.config.jsonSchema})}}export{VldNumber};

package/dist/validators/object.d.ts

@@ -5,7 +5,7 @@ import { VldEnum } from './enum.js';
  */
 interface ObjectValidatorConfig<T extends Record<string, any>> {
     readonly shape: {
-        readonly [K in keyof T]: VldBase<unknown, T[K]>;
+        readonly [K in keyof T]: VldBase<any, T[K]>;
     };
     readonly strict?: boolean;
     readonly passthrough?: boolean;
@@ -57,7 +57,7 @@ export declare class VldObject<T extends Record<string, any>> extends VldBase<un
      * Create a new object validator
      */
     static create<T extends Record<string, any>>(shape: {
-        [K in keyof T]: VldBase<unknown, T[K]>;
+        [K in keyof T]: VldBase<any, T[K]>;
     }): VldObject<T>;
     /**
      * Parse and validate an object value
@@ -81,6 +81,14 @@ export declare class VldObject<T extends Record<string, any>> extends VldBase<un
      * Optimized version using pre-computed keys
      */
     safeParse(value: unknown): ParseResult<T>;
+    encode(value: T): unknown;
+    safeEncode(value: T): ParseResult<unknown>;
+    encodeAsync(value: T): Promise<unknown>;
+    safeEncodeAsync(value: T): Promise<ParseResult<unknown>>;
+    private encodeObjectSync;
+    private encodeObjectAsync;
+    private getEncodedExtraKeys;
+    private encodeExtraKeysSync;
     /**
      * Create a new validator in strict mode (no extra keys allowed)
      */
@@ -89,6 +97,8 @@ export declare class VldObject<T extends Record<string, any>> extends VldBase<un
      * Create a new validator in passthrough mode (extra keys are preserved)
      */
     passthrough(): VldObject<T>;
+    loose(): VldObject<T>;
+    strip(): VldObject<T>;
     /**
      * Create a new validator with all fields optional
      */