@oxog/vld 2.1.0 → 2.2.7

package/dist/validators/custom.d.ts

@@ -1,4 +1,4 @@
-import { VldBase, ParseResult } from './base.js';
+import { VldBase, ParseResult, type ErrorParam } from './base.js';
 /**
  * Type-safe custom validator options
  */
@@ -16,12 +16,24 @@ export interface CustomValidatorOptions<TOutput> {
      * Optional safeParse implementation
      * If not provided, will use try-catch around parse()
      */
-    safeParse?: (value: unknown) => ParseResult<TOutput>;
+    safeParse?: (value: unknown) => ParseResult<TOutput> | {
+        success: true;
+        data: TOutput;
+    } | {
+        success: false;
+        error: Error;
+    };
     /**
      * Optional async safeParse implementation
      * If not provided, will use try-catch around parseAsync()
      */
-    safeParseAsync?: (value: unknown) => Promise<ParseResult<TOutput>>;
+    safeParseAsync?: (value: unknown) => Promise<ParseResult<TOutput> | {
+        success: true;
+        data: TOutput;
+    } | {
+        success: false;
+        error: Error;
+    }>;
 }
 /**
  * Immutable custom validator for user-defined validation logic
@@ -50,11 +62,9 @@ export declare class VldCustom<TOutput = unknown> extends VldBase<unknown, TOutp
 }
 /**
  * Helper function to create custom validators
- * Usage: v.custom<number>({
- *   parse: (value) => {
- *     if (typeof value !== 'string') throw new Error('Expected string');
- *     return parseInt(value, 10);
- *   }
- * })
+ * Supports:
+ * - v.custom() -> accepts any
+ * - v.custom((val) => boolean, "error message")
+ * - v.custom({ parse: (val) => ... })
  */
-export declare function custom<TOutput = unknown>(options: CustomValidatorOptions<TOutput>): VldCustom<TOutput>;
+export declare function custom<TOutput = unknown>(optionsOrPredicate?: CustomValidatorOptions<TOutput> | ((data: unknown) => boolean | Promise<boolean>), errorParam?: ErrorParam): VldCustom<TOutput>;

package/dist/validators/custom.js

@@ -1,67 +1 @@
-import { VldBase, VLD_VALIDATOR_TYPES } from './base.js';
-
-/**
- * Immutable custom validator for user-defined validation logic
- * Provides type safety while allowing complete control over validation
- */
-class VldCustom extends VldBase {
-    constructor(options) {
-        super(VLD_VALIDATOR_TYPES.CUSTOM);
-        this._parseFn = options.parse;
-        this._parseAsyncFn = options.parseAsync || ((value) => Promise.resolve(this._parseFn(value)));
-        this._safeParseFn = options.safeParse || ((value) => {
-            try {
-                return { success: true, data: this._parseFn(value) };
-            }
-            catch (error) {
-                return { success: false, error: error };
-            }
-        });
-        this._safeParseAsyncFn = options.safeParseAsync || (async (value) => {
-            try {
-                return { success: true, data: await this._parseAsyncFn(value) };
-            }
-            catch (error) {
-                return { success: false, error: error };
-            }
-        });
-    }
-    /**
-     * Create a new custom validator
-     */
-    static create(options) {
-        return new VldCustom(options);
-    }
-    /**
-     * Parse and validate using the custom parse function
-     */
-    parse(value) {
-        return this._parseFn(value);
-    }
-    /**
-     * Safely parse using the custom safeParse function or default implementation
-     */
-    safeParse(value) {
-        return this._safeParseFn(value);
-    }
-    async parseAsync(value) {
-        return this._parseAsyncFn(value);
-    }
-    async safeParseAsync(value) {
-        return this._safeParseAsyncFn(value);
-    }
-}
-/**
- * Helper function to create custom validators
- * Usage: v.custom<number>({
- *   parse: (value) => {
- *     if (typeof value !== 'string') throw new Error('Expected string');
- *     return parseInt(value, 10);
- *   }
- * })
- */
-function custom(options) {
-    return VldCustom.create(options);
-}
-
-export { VldCustom, custom };
+import{ensureVldError as s,resolveErrorMessage as r,VldBase as e,VLD_VALIDATOR_TYPES as a}from"./base.js";class VldCustom extends e{constructor(r){super(a.CUSTOM),this._parseFn=r.parse,this._parseAsyncFn=r.parseAsync||(s=>Promise.resolve(this._parseFn(s))),this._safeParseFn=r.safeParse?e=>{const a=r.safeParse(e);return a.success?{success:!0,data:a.data}:{success:!1,error:s(a.error)}}:r=>{try{return{success:!0,data:this._parseFn(r)}}catch(r){return{success:!1,error:s(r)}}},this._safeParseAsyncFn=r.safeParseAsync?async e=>{const a=await r.safeParseAsync(e);return a.success?{success:!0,data:a.data}:{success:!1,error:s(a.error)}}:async r=>{try{return{success:!0,data:await this._parseAsyncFn(r)}}catch(r){return{success:!1,error:s(r)}}}}static create(s){return new VldCustom(s)}parse(s){return this._parseFn(s)}safeParse(s){return this._safeParseFn(s)}async parseAsync(s){return this._parseAsyncFn(s)}async safeParseAsync(s){return this._safeParseAsyncFn(s)}}function t(e,a){if("function"==typeof e){const t=e;return VldCustom.create({parse:e=>{if(!t(e))throw s(r(a,"Custom validation failed"));return e}})}return e?VldCustom.create(e):VldCustom.create({parse:s=>s})}export{VldCustom,t as custom};

package/dist/validators/date.d.ts

@@ -34,6 +34,8 @@ export declare class VldDate extends VldBase<Date, Date> {
      */
     protected constructor(config?: Partial<DateValidatorConfig>);
     get jsonSchema(): DateJSONSchemaHints | undefined;
+    get minDate(): Date | null;
+    get maxDate(): Date | null;
     /**
      * Create a new date validator
      */

package/dist/validators/date.js

@@ -1,274 +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 createDateError(message) {
-    return new VldError([{ code: 'invalid_date', path: [], message }]);
-}
-/**
- * Immutable date validator with chainable methods
- */
-class VldDate extends VldBase {
-    /**
-     * Protected constructor to allow extension while maintaining immutability
-     */
-    constructor(config) {
-        super(config?.validatorType || VLD_VALIDATOR_TYPES.DATE);
-        this.config = {
-            checks: config?.checks || [],
-            errorMessage: config?.errorMessage,
-            jsonSchema: config?.jsonSchema
-        };
-        this._checks = this.config.checks;
-        this._isSimple = this._checks.length === 0;
-    }
-    get jsonSchema() {
-        return this.config.jsonSchema;
-    }
-    /**
-     * Create a new date validator
-     */
-    static create() {
-        return new VldDate();
-    }
-    /**
-     * Parse and validate a date value
-     */
-    parse(value) {
-        let date;
-        if (value instanceof Date) {
-            date = value;
-        }
-        else if (typeof value === 'string' || typeof value === 'number') {
-            date = new Date(value);
-        }
-        else {
-            throw new Error(this.config.errorMessage || getMessages().invalidDate);
-        }
-        // Check if the date is valid
-        if (isNaN(date.getTime())) {
-            throw new Error(this.config.errorMessage || getMessages().invalidDate);
-        }
-        return this.parseValidDate(date);
-    }
-    /**
-     * Parse a Date instance that has already passed the Date validity check.
-     * @internal Used by object validators to avoid duplicate hot-path checks.
-     */
-    parseKnownDate(value) {
-        if (isNaN(value.getTime())) {
-            throw new Error(this.config.errorMessage || getMessages().invalidDate);
-        }
-        return this.parseValidDate(value);
-    }
-    parseValidDate(date) {
-        if (this._isSimple) {
-            return date;
-        }
-        // Apply all checks
-        for (const check of this._checks) {
-            if (!check.fn(date)) {
-                throw new Error(check.message);
-            }
-        }
-        return date;
-    }
-    /**
-     * Safely parse and validate a date value
-     */
-    safeParse(value) {
-        if (value instanceof Date) {
-            try {
-                return { success: true, data: this.parseKnownDate(value) };
-            }
-            catch (error) {
-                return { success: false, error: createDateError(error.message) };
-            }
-        }
-        try {
-            return { success: true, data: this.parse(value) };
-        }
-        catch (error) {
-            return { success: false, error: createDateError(error.message) };
-        }
-    }
-    /**
-     * Create a new validator with minimum date constraint
-     * BUG-NEW-009 FIX: Validate that min date is valid before creating validator
-     */
-    min(date, message) {
-        const minDate = date instanceof Date ? date : new Date(date);
-        // Validate that minDate is valid
-        if (isNaN(minDate.getTime())) {
-            throw new Error(`Invalid date provided to min(): ${date}`);
-        }
-        return new VldDate({
-            ...this.config,
-            checks: [...this.config.checks, {
-                    fn: (v) => v >= minDate,
-                    message: message || getMessages().dateMin(minDate)
-                }],
-            jsonSchema: { ...this.config.jsonSchema, formatMinimum: minDate.toISOString() }
-        });
-    }
-    /**
-     * Create a new validator with maximum date constraint
-     * BUG-NEW-009 FIX: Validate that max date is valid before creating validator
-     */
-    max(date, message) {
-        const maxDate = date instanceof Date ? date : new Date(date);
-        // Validate that maxDate is valid
-        if (isNaN(maxDate.getTime())) {
-            throw new Error(`Invalid date provided to max(): ${date}`);
-        }
-        return new VldDate({
-            ...this.config,
-            checks: [...this.config.checks, {
-                    fn: (v) => v <= maxDate,
-                    message: message || getMessages().dateMax(maxDate)
-                }],
-            jsonSchema: { ...this.config.jsonSchema, formatMaximum: maxDate.toISOString() }
-        });
-    }
-    /**
-     * Create a new validator with a range constraint
-     * BUG-NEW-019 FIX: Validate that min/max dates are valid before creating validator
-     */
-    between(min, max, message) {
-        const minDate = min instanceof Date ? min : new Date(min);
-        const maxDate = max instanceof Date ? max : new Date(max);
-        // Validate that both dates are valid
-        if (isNaN(minDate.getTime())) {
-            throw new Error(`Invalid min date provided to between(): ${min}`);
-        }
-        if (isNaN(maxDate.getTime())) {
-            throw new Error(`Invalid max date provided to between(): ${max}`);
-        }
-        return new VldDate({
-            ...this.config,
-            checks: [...this.config.checks, {
-                    fn: (v) => v >= minDate && v <= maxDate,
-                    message: message || `Date must be between ${minDate.toISOString()} and ${maxDate.toISOString()}`
-                }],
-            jsonSchema: {
-                ...this.config.jsonSchema,
-                formatMinimum: minDate.toISOString(),
-                formatMaximum: maxDate.toISOString()
-            }
-        });
-    }
-    /**
-     * Create a new validator that checks if date is in the past
-     * BUG-NEW-006 FIX: Capture reference date at validator creation time for deterministic behavior
-     */
-    past(message) {
-        const referenceDate = new Date(); // Capture NOW at validator creation time
-        return new VldDate({
-            ...this.config,
-            checks: [...this.config.checks, {
-                    fn: (v) => v < referenceDate,
-                    message: message || 'Date must be in the past'
-                }],
-            jsonSchema: { ...this.config.jsonSchema, formatExclusiveMaximum: referenceDate.toISOString() }
-        });
-    }
-    /**
-     * Create a new validator that checks if date is in the future
-     * BUG-NEW-006 FIX: Capture reference date at validator creation time for deterministic behavior
-     */
-    future(message) {
-        const referenceDate = new Date(); // Capture NOW at validator creation time
-        return new VldDate({
-            ...this.config,
-            checks: [...this.config.checks, {
-                    fn: (v) => v > referenceDate,
-                    message: message || 'Date must be in the future'
-                }],
-            jsonSchema: { ...this.config.jsonSchema, formatExclusiveMinimum: referenceDate.toISOString() }
-        });
-    }
-    /**
-     * Create a new validator that checks if date is today
-     * BUG-NEW-008 FIX: Capture reference date at validator creation time for deterministic behavior
-     */
-    today(message) {
-        // Capture the reference date (today) at validator creation time
-        const referenceDate = new Date();
-        const refYear = referenceDate.getFullYear();
-        const refMonth = referenceDate.getMonth();
-        const refDate = referenceDate.getDate();
-        return new VldDate({
-            ...this.config,
-            checks: [...this.config.checks, {
-                    fn: (v) => {
-                        return v.getFullYear() === refYear &&
-                            v.getMonth() === refMonth &&
-                            v.getDate() === refDate;
-                    },
-                    message: message || 'Date must be today'
-                }]
-        });
-    }
-    /**
-     * Create a new validator that checks if date is a weekday
-     */
-    weekday(message) {
-        return new VldDate({
-            ...this.config,
-            checks: [...this.config.checks, {
-                    fn: (v) => {
-                        const day = v.getDay();
-                        return day >= 1 && day <= 5;
-                    },
-                    message: message || 'Date must be a weekday'
-                }]
-        });
-    }
-    /**
-     * Create a new validator that checks if date is a weekend
-     */
-    weekend(message) {
-        return new VldDate({
-            ...this.config,
-            checks: [...this.config.checks, {
-                    fn: (v) => {
-                        const day = v.getDay();
-                        return day === 0 || day === 6;
-                    },
-                    message: message || 'Date must be a weekend'
-                }]
-        });
-    }
-    /**
-     * Create a new validator with strict greater than constraint
-     * Zod 4 API parity - strictly greater than (not equal to)
-     */
-    gt(value, message) {
-        const compareDate = value instanceof Date ? value : new Date(value);
-        return new VldDate({
-            ...this.config,
-            checks: [...this.config.checks, {
-                    fn: (v) => v.getTime() > compareDate.getTime(),
-                    message: message || `Date must be greater than ${compareDate.toISOString()}`
-                }],
-            jsonSchema: { ...this.config.jsonSchema, formatExclusiveMinimum: compareDate.toISOString() }
-        });
-    }
-    /**
-     * Create a new validator with strict less than constraint
-     * Zod 4 API parity - strictly less than (not equal to)
-     */
-    lt(value, message) {
-        const compareDate = value instanceof Date ? value : new Date(value);
-        return new VldDate({
-            ...this.config,
-            checks: [...this.config.checks, {
-                    fn: (v) => v.getTime() < compareDate.getTime(),
-                    message: message || `Date must be less than ${compareDate.toISOString()}`
-                }],
-            jsonSchema: { ...this.config.jsonSchema, formatExclusiveMaximum: compareDate.toISOString() }
-        });
-    }
-}
-
-export { VldDate };
+import{VldBase as e,VLD_VALIDATOR_TYPES as t}from"./base.js";import{getMessages as n}from"../locales/runtime.js";import{V as s}from"../chunks/errors-core-CerMg2rq.js";function i(e){return new s([{code:"invalid_date",path:[],message:e}])}class VldDate extends e{constructor(e){super(e?.validatorType||t.DATE),this.config={checks:e?.checks||[],errorMessage:e?.errorMessage,jsonSchema:e?.jsonSchema},this._checks=this.config.checks,this._isSimple=0===this._checks.length}get jsonSchema(){return this.config.jsonSchema}get minDate(){const e=this.config.jsonSchema?.formatMinimum??this.config.jsonSchema?.minimum;return e?new Date(e):null}get maxDate(){const e=this.config.jsonSchema?.formatMaximum??this.config.jsonSchema?.maximum;return e?new Date(e):null}static create(){return new VldDate}parse(e){let t;if(e instanceof Date)t=e;else{if("string"!=typeof e&&"number"!=typeof e)throw new Error(this.config.errorMessage||n().invalidDate);t=new Date(e)}if(isNaN(t.getTime()))throw new Error(this.config.errorMessage||n().invalidDate);return this.parseValidDate(t)}parseKnownDate(e){if(isNaN(e.getTime()))throw new Error(this.config.errorMessage||n().invalidDate);return this.parseValidDate(e)}parseValidDate(e){if(this._isSimple)return e;for(const t of this._checks)if(!t.fn(e))throw new Error(t.message);return e}safeParse(e){if(e instanceof Date)try{return{success:!0,data:this.parseKnownDate(e)}}catch(e){return{success:!1,error:i(e.message)}}try{return{success:!0,data:this.parse(e)}}catch(e){return{success:!1,error:i(e.message)}}}min(e,t){const s=e instanceof Date?e:new Date(e);if(isNaN(s.getTime()))throw new Error(`Invalid date provided to min(): ${e}`);return new VldDate({...this.config,checks:[...this.config.checks,{fn:e=>e>=s,message:t||n().dateMin(s)}],jsonSchema:{...this.config.jsonSchema,formatMinimum:s.toISOString()}})}max(e,t){const s=e instanceof Date?e:new Date(e);if(isNaN(s.getTime()))throw new Error(`Invalid date provided to max(): ${e}`);return new VldDate({...this.config,checks:[...this.config.checks,{fn:e=>e<=s,message:t||n().dateMax(s)}],jsonSchema:{...this.config.jsonSchema,formatMaximum:s.toISOString()}})}between(e,t,n){const s=e instanceof Date?e:new Date(e),i=t instanceof Date?t:new Date(t);if(isNaN(s.getTime()))throw new Error(`Invalid min date provided to between(): ${e}`);if(isNaN(i.getTime()))throw new Error(`Invalid max date provided to between(): ${t}`);return new VldDate({...this.config,checks:[...this.config.checks,{fn:e=>e>=s&&e<=i,message:n||`Date must be between ${s.toISOString()} and ${i.toISOString()}`}],jsonSchema:{...this.config.jsonSchema,formatMinimum:s.toISOString(),formatMaximum:i.toISOString()}})}past(e){const t=new Date;return new VldDate({...this.config,checks:[...this.config.checks,{fn:e=>e<t,message:e||"Date must be in the past"}],jsonSchema:{...this.config.jsonSchema,formatExclusiveMaximum:t.toISOString()}})}future(e){const t=new Date;return new VldDate({...this.config,checks:[...this.config.checks,{fn:e=>e>t,message:e||"Date must be in the future"}],jsonSchema:{...this.config.jsonSchema,formatExclusiveMinimum:t.toISOString()}})}today(e){const t=new Date,n=t.getFullYear(),s=t.getMonth(),i=t.getDate();return new VldDate({...this.config,checks:[...this.config.checks,{fn:e=>e.getFullYear()===n&&e.getMonth()===s&&e.getDate()===i,message:e||"Date must be today"}]})}weekday(e){return new VldDate({...this.config,checks:[...this.config.checks,{fn:e=>{const t=e.getDay();return t>=1&&t<=5},message:e||"Date must be a weekday"}]})}weekend(e){return new VldDate({...this.config,checks:[...this.config.checks,{fn:e=>{const t=e.getDay();return 0===t||6===t},message:e||"Date must be a weekend"}]})}gt(e,t){const n=e instanceof Date?e:new Date(e);return new VldDate({...this.config,checks:[...this.config.checks,{fn:e=>e.getTime()>n.getTime(),message:t||`Date must be greater than ${n.toISOString()}`}],jsonSchema:{...this.config.jsonSchema,formatExclusiveMinimum:n.toISOString()}})}lt(e,t){const n=e instanceof Date?e:new Date(e);return new VldDate({...this.config,checks:[...this.config.checks,{fn:e=>e.getTime()<n.getTime(),message:t||`Date must be less than ${n.toISOString()}`}],jsonSchema:{...this.config.jsonSchema,formatExclusiveMaximum:n.toISOString()}})}}export{VldDate};

package/dist/validators/discriminated-union.d.ts

@@ -9,14 +9,16 @@ import type { ParseResult } from './base.js';
  * Discriminated union validator - validates union based on discriminator key
  * Much faster than regular union when you have a discriminator field
  */
-export declare class VldDiscriminatedUnion<K extends string, Options extends VldBase<any, any>[]> extends VldBase<unknown, Options[number] extends VldBase<any, infer T> ? T : never> {
+export declare class VldDiscriminatedUnion<K extends string, Options extends readonly VldBase<any, any>[]> extends VldBase<unknown, Options[number] extends VldBase<any, infer T> ? T : never> {
     private readonly _discriminator;
     private readonly _options;
     private readonly _discriminatorMap;
     private readonly _stringDiscriminatorMap;
     private readonly _validValues;
     constructor(_discriminator: K, _options: Options);
-    static create<K extends string, Options extends VldBase<any, any>[]>(discriminator: K, options: Options): VldDiscriminatedUnion<K, Options>;
+    get options(): Options;
+    get discriminator(): K;
+    static create<K extends string, Options extends readonly VldBase<any, any>[]>(discriminator: K, options: Options): VldDiscriminatedUnion<K, Options>;
     parse(value: unknown): Options[number] extends VldBase<any, infer T> ? T : never;
     safeParse(value: unknown): ParseResult<Options[number] extends VldBase<any, infer T> ? T : never>;
     /**

package/dist/validators/discriminated-union.js

@@ -1,123 +1 @@
-import { VldBase, VLD_VALIDATOR_TYPES } from './base.js';
-import { VldObject } from './object.js';
-import { VldLiteral } from './literal.js';
-import { VldEnum } from './enum.js';
-
-/**
- * VldDiscriminatedUnion - Fast union validation using discriminator field
- * Part of Zod 4 API parity implementation
- * Provides O(1) lookup performance by using a discriminator key
- */
-/**
- * Extract literal values from a schema
- */
-function extractLiteralValues(schema) {
-    if (schema instanceof VldLiteral) {
-        return [schema.literal];
-    }
-    if (schema instanceof VldEnum) {
-        return [...schema.values];
-    }
-    throw new Error('Discriminator must be a literal or enum schema');
-}
-/**
- * Discriminated union validator - validates union based on discriminator key
- * Much faster than regular union when you have a discriminator field
- */
-class VldDiscriminatedUnion extends VldBase {
-    constructor(_discriminator, _options) {
-        super(VLD_VALIDATOR_TYPES.DISCRIMINATED_UNION);
-        this._discriminator = _discriminator;
-        this._options = _options;
-        // Build discriminator map for O(1) lookup
-        this._discriminatorMap = new Map();
-        this._stringDiscriminatorMap = Object.create(null);
-        for (const option of _options) {
-            if (!(option instanceof VldObject)) {
-                throw new Error('All options in a discriminated union must be objects');
-            }
-            const discriminatorSchema = option.config?.shape?.[this._discriminator];
-            if (!discriminatorSchema) {
-                throw new Error(`Missing discriminator key "${this._discriminator}" in one of the options`);
-            }
-            const values = extractLiteralValues(discriminatorSchema);
-            for (const value of values) {
-                if (this._discriminatorMap.has(value)) {
-                    throw new Error(`Duplicate discriminator value "${String(value)}" found in discriminated union`);
-                }
-                this._discriminatorMap.set(value, option);
-                if (typeof value === 'string') {
-                    this._stringDiscriminatorMap[value] = option;
-                }
-            }
-        }
-        this._validValues = Array.from(this._discriminatorMap.keys());
-    }
-    static create(discriminator, options) {
-        return new VldDiscriminatedUnion(discriminator, options);
-    }
-    parse(value) {
-        if (typeof value !== 'object' || value === null) {
-            throw new Error(`Expected object, received ${value === null ? 'null' : typeof value}`);
-        }
-        const discriminatorValue = value[this._discriminator];
-        const matchedSchema = typeof discriminatorValue === 'string'
-            ? this._stringDiscriminatorMap[discriminatorValue]
-            : this._discriminatorMap.get(discriminatorValue);
-        if (!matchedSchema) {
-            throw new Error(`Invalid discriminator value for "${this._discriminator}". ` +
-                `Expected one of: ${JSON.stringify(this._validValues)}, ` +
-                `received: ${JSON.stringify(discriminatorValue)}`);
-        }
-        return matchedSchema.parseTrustedKnownObject(value, this._discriminator);
-    }
-    safeParse(value) {
-        // Check if input is an object
-        if (typeof value !== 'object' || value === null) {
-            return {
-                success: false,
-                error: new Error(`Expected object, received ${value === null ? 'null' : typeof value}`)
-            };
-        }
-        // Get discriminator value
-        const discriminatorValue = value[this._discriminator];
-        // Look up matching schema
-        const matchedSchema = typeof discriminatorValue === 'string'
-            ? this._stringDiscriminatorMap[discriminatorValue]
-            : this._discriminatorMap.get(discriminatorValue);
-        if (!matchedSchema) {
-            return {
-                success: false,
-                error: new Error(`Invalid discriminator value for "${this._discriminator}". ` +
-                    `Expected one of: ${JSON.stringify(this._validValues)}, ` +
-                    `received: ${JSON.stringify(discriminatorValue)}`)
-            };
-        }
-        try {
-            return {
-                success: true,
-                data: matchedSchema.parseTrustedKnownObject(value, this._discriminator)
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error
-            };
-        }
-    }
-    /**
-     * Get the discriminator key
-     */
-    getDiscriminator() {
-        return this._discriminator;
-    }
-    /**
-     * Get all options
-     */
-    getOptions() {
-        return this._options;
-    }
-}
-
-export { VldDiscriminatedUnion };
+import{VldBase as i,VLD_VALIDATOR_TYPES as r,ensureVldError as t}from"./base.js";import{VldObject as s}from"./object.js";import{VldLiteral as n}from"./literal.js";import{VldEnum as e}from"./enum.js";function o(i){if(i instanceof n)return[...i.values];if(i instanceof e)return[...i.values];throw new Error("Discriminator must be a literal or enum schema")}class VldDiscriminatedUnion extends i{constructor(i,t){super(r.DISCRIMINATED_UNION),this._discriminator=i,this._options=t,this._discriminatorMap=new Map,this._stringDiscriminatorMap=Object.create(null);for(const i of t){if(!(i instanceof s))throw new Error("All options in a discriminated union must be objects");const r=i.config?.shape?.[this._discriminator];if(!r)throw new Error(`Missing discriminator key "${this._discriminator}" in one of the options`);const t=o(r);for(const r of t){if(this._discriminatorMap.has(r))throw new Error(`Duplicate discriminator value "${String(r)}" found in discriminated union`);this._discriminatorMap.set(r,i),"string"==typeof r&&(this._stringDiscriminatorMap[r]=i)}}this._validValues=Array.from(this._discriminatorMap.keys())}get options(){return this._options}get discriminator(){return this._discriminator}static create(i,r){return new VldDiscriminatedUnion(i,r)}parse(i){if("object"!=typeof i||null===i)throw new Error("Expected object, received "+(null===i?"null":typeof i));const r=i[this._discriminator],t="string"==typeof r?this._stringDiscriminatorMap[r]:this._discriminatorMap.get(r);if(!t)throw new Error(`Invalid discriminator value for "${this._discriminator}". Expected one of: ${JSON.stringify(this._validValues)}, received: ${JSON.stringify(r)}`);return t.parseTrustedKnownObject(i,this._discriminator)}safeParse(i){if("object"!=typeof i||null===i)return{success:!1,error:t("Expected object, received "+(null===i?"null":typeof i))};const r=i[this._discriminator],s="string"==typeof r?this._stringDiscriminatorMap[r]:this._discriminatorMap.get(r);if(!s)return{success:!1,error:t(`Invalid discriminator value for "${this._discriminator}". Expected one of: ${JSON.stringify(this._validValues)}, received: ${JSON.stringify(r)}`)};try{return{success:!0,data:s.parseTrustedKnownObject(i,this._discriminator)}}catch(i){return{success:!1,error:t(i)}}}getDiscriminator(){return this._discriminator}getOptions(){return this._options}}export{VldDiscriminatedUnion};

package/dist/validators/enum.d.ts

@@ -16,6 +16,10 @@ export declare class VldEnum<T extends readonly [EnumValue, ...EnumValue[]]> ext
      * Get the enum values
      */
     get values(): T;
+    get options(): T;
+    get enum(): {
+        [K in T[number]]: K;
+    };
     /**
      * Create a new enum validator
      */
@@ -32,11 +36,13 @@ export declare class VldEnum<T extends readonly [EnumValue, ...EnumValue[]]> ext
      * Exclude specific values from the enum
      * Creates a new enum validator without the specified values
      */
-    exclude<const E extends readonly EnumValue[]>(...excludeValues: E): VldEnum<T[number] extends E[number] ? never : T[number] extends Exclude<T[number], E[number]> ? T : Exclude<T, E>>;
+    exclude<const E extends readonly EnumValue[]>(values: E): VldEnum<any>;
+    exclude<const E extends readonly EnumValue[]>(...values: E): VldEnum<any>;
     /**
      * Extract specific values from the enum
      * Creates a new enum validator with only the specified values
      */
-    extract<const E extends readonly EnumValue[]>(...extractValues: E): VldEnum<[E[number], ...E[number][]]>;
+    extract<const E extends readonly EnumValue[]>(values: E): VldEnum<any>;
+    extract<const E extends readonly EnumValue[]>(...values: E): VldEnum<any>;
 }
 export {};