@oxog/vld 2.0.3 → 2.1.0

package/dist/index.js

@@ -1,195 +1,63 @@
-import { g as VldPreprocess, r as VldExactOptional, e as VldNullish, d as VldNullable, f as VldOptional, V as VldBigInt, b as VldDate, a as VldBoolean, c as VldNumber, h as VldString } from './chunks/bigint-CRS0QVsy.js';
-export { i as VldBase, s as VldMeta, t as getLocale, u as getMessages, v as setLocale } from './chunks/bigint-CRS0QVsy.js';
-import { f as VldJson, g as VldLazy, V as VldNever, l as VldNan, r as VldUndefined, m as VldNull, t as VldVoid, a as VldAny, d as VldEnum, h as VldLiteral, u as VldXor, c as VldDiscriminatedUnion, e as VldIntersection, s as VldUnion, k as VldMap, n as VldSet, j as VldRecord, q as VldTuple, i as VldObject, b as VldArray, o as VldStringBool, p as VldSymbol } from './chunks/json-Cp4WO0M9.js';
-import { V as VldUnknown } from './chunks/unknown-Dhzri_T-.js';
-import { promise, templateLiteral, httpUrl, guid, xid, stringFormat, iso, hash, e164, cidrv6, cidrv4, mac, ipv6, ipv4, ulid, cuid2, cuid, nanoid, jwt, hex, base64url, base64, emoji, hostname, uuidv4, uuid, email, functionValidator, file, custom } from './validators/index.js';
-import { V as VldCodec, a as VldUint8Array, b as VldHex, c as VldBase64 } from './chunks/index-DO8CFMxD.js';
-export { d as base64Json, e as base64ToBytes, f as base64ToUint8Array, g as base64UrlToBytes, h as base64urlToBytes, i as bytesToUtf8, j as epochMillisToDate, k as epochSecondsToDate, l as hexLowerToBytes, m as hexToBytes, n as hexToUint8Array, o as isoDatetimeToDate, p as jsonCodec, q as jwtPayload, r as numberToBigInt, s as stringToBigInt, t as stringToBoolean, u as stringToHttpURL, v as stringToInt, w as stringToNumber, x as stringToURL, y as stringToUint8Array, z as uint8ArrayToBase64, A as uint8ArrayToBase64Url, B as uint8ArrayToHex, C as uint8ArrayToString, D as uriComponent, E as utf8ToBytes } from './chunks/index-DO8CFMxD.js';
-import { V as VldCoerceDate, a as VldCoerceBoolean, b as VldCoerceNumber, c as VldCoerceString } from './chunks/date-50JV_Mfj.js';
-import { VldCoerceBigInt } from './coercion/index.js';
-export { VldError, flattenError, prettifyError, prettifyErrorColored, prettifyErrorPlain, treeifyError } from './errors.js';
-export { Err, Ok, ResultUtils, all, failure, flatMap, fromNullable, isErr, isOk, isResult, map, mapErr, match, success, tryCatch, tryCatchAsync, unwrap, unwrapOr } from './compat/result.js';
+import { VLD_VALIDATOR_TYPES, VldPreprocess, VldBase, VldExactOptional, VldNullish, VldNullable, VldOptional, resolveErrorMessage } from './validators/base.js';
+export { VldMeta, VldBrand as ZodBranded, VldCatch as ZodCatch, VldDefault as ZodDefault, VldMeta as ZodMeta, VldRefine as ZodNonOptional, VldPipe as ZodPipe, VldPrefault as ZodPrefault, VldReadonly as ZodReadonly, VldTransform as ZodTransform } from './validators/base.js';
+import { globalRegistry } from './registry.js';
+export { registry } from './registry.js';
+import { V as VldString } from './chunks/string-BJRQod3t.js';
+import { VldNumber } from './validators/number.js';
+import { VldBoolean } from './validators/boolean.js';
+import { VldDate } from './validators/date.js';
+import { VldStringBool } from './validators/string-bool.js';
+import { VldArray } from './validators/array.js';
+import { VldObject } from './validators/object.js';
+import { VldUnion } from './validators/union.js';
+import { VldLiteral } from './validators/literal.js';
+import { VldBigInt } from './validators/bigint.js';
+import { VldSymbol } from './validators/symbol.js';
+import { VldTuple } from './validators/tuple.js';
+import { VldRecord } from './validators/record.js';
+import { VldSet } from './validators/set.js';
+import { VldMap } from './validators/map.js';
+import { VldEnum } from './validators/enum.js';
+import { VldIntersection } from './validators/intersection.js';
+import { VldAny } from './validators/any.js';
+import { VldUnknown } from './validators/unknown.js';
+import { VldVoid } from './validators/void.js';
+import { VldNever } from './validators/never.js';
+import { VldNull } from './validators/null.js';
+import { VldUndefined } from './validators/undefined.js';
+import { VldNan } from './validators/nan.js';
+import { VldLazy } from './validators/lazy.js';
+import { VldDiscriminatedUnion } from './validators/discriminated-union.js';
+import { VldXor } from './validators/xor.js';
+import { VldJson } from './validators/json.js';
+import { templateLiteral as templateLiteral$1 } from './validators/template-literal.js';
+export { VldTemplateLiteral as ZodTemplateLiteral } from './validators/template-literal.js';
+import { custom as custom$1 } from './validators/custom.js';
+export { VldCustom as ZodCustom, VldCustom as ZodSuccess } from './validators/custom.js';
+import { VldFile, file as file$1 } from './validators/file.js';
+import { functionValidator } from './validators/function.js';
+export { VldFunction as ZodFunction } from './validators/function.js';
+import { VldCodec } from './validators/codec.js';
+import { VldBase64 } from './validators/base64.js';
+import { VldHex } from './validators/hex.js';
+import { VldUint8Array } from './validators/uint8array.js';
+import { promise as promise$1 } from './validators/promise.js';
+export { VldPromise as ZodPromise } from './validators/promise.js';
+import { map as map$1 } from './compat/result.js';
+export { Err, Ok, ResultUtils, all, failure, flatMap, fromNullable, isErr, isOk, isResult, mapErr, match, success, tryCatch, tryCatchAsync, unwrap, unwrapOr } from './compat/result.js';
+import { l as localeNamespace } from './chunks/index-BvH403Yy.js';
+export { s as setLocaleAsync } from './chunks/index-BvH403Yy.js';
+import { VldCoerceBigInt, VldCoerceDate, VldCoerceBoolean, VldCoerceNumber, VldCoerceString } from './coercion/index.js';
+import { flattenError, prettifyError, treeifyError } from './errors.js';
+export { prettifyErrorColored, prettifyErrorPlain } from './errors.js';
+import { uuid as uuid$1, httpUrl as httpUrl$1, email as email$1, regexes as REGEXES, ksuid as ksuid$1, guid as guid$1, xid as xid$1, stringFormat as stringFormat$1, iso as iso$1, hash as hash$1, e164 as e164$1, cidrv6 as cidrv6$1, cidrv4 as cidrv4$1, mac as mac$1, ipv6 as ipv6$1, ipv4 as ipv4$1, ulid as ulid$1, cuid2 as cuid2$1, cuid as cuid$1, nanoid as nanoid$1, jwt as jwt$1, hex as hex$1, base64url as base64url$1, base64 as base64$1, emoji as emoji$1, hostname as hostname$1, uuidv7 as uuidv7$1, uuidv6 as uuidv6$1, uuidv4 as uuidv4$1 } from './validators/string-formats.js';
+export { VldStringFormat as ZodBase64, VldStringFormat as ZodBase64URL, VldStringFormat as ZodCIDRv4, VldStringFormat as ZodCIDRv6, VldStringFormat as ZodCUID, VldStringFormat as ZodCUID2, VldStringFormat as ZodCustomStringFormat, VldStringFormat as ZodE164, VldStringFormat as ZodEmail, VldStringFormat as ZodEmoji, VldStringFormat as ZodGUID, VldStringFormat as ZodIPv4, VldStringFormat as ZodIPv6, VldStringFormat as ZodISODate, VldStringFormat as ZodISODateTime, VldStringFormat as ZodISODuration, VldStringFormat as ZodISOTime, VldStringFormat as ZodJWT, VldStringFormat as ZodKSUID, VldStringFormat as ZodMAC, VldStringFormat as ZodNanoID, VldStringFormat as ZodStringFormat, VldStringFormat as ZodULID, VldStringFormat as ZodURL, VldStringFormat as ZodUUID, VldStringFormat as ZodXID } from './validators/string-formats.js';
+export { b as base64Json, a as base64ToBytes, c as base64ToUint8Array, d as base64UrlToBytes, e as base64urlToBytes, f as bytesToUtf8, g as epochMillisToDate, h as epochSecondsToDate, i as hexLowerToBytes, j as hexToBytes, k as hexToUint8Array, l as invertCodec, m as isoDatetimeToDate, n as jsonCodec, o as jwtPayload, p as numberToBigInt, s as stringToBigInt, q as stringToBoolean, r as stringToHttpURL, t as stringToInt, u as stringToNumber, v as stringToURL, w as stringToUint8Array, x as uint8ArrayToBase64, y as uint8ArrayToBase64Url, z as uint8ArrayToHex, A as uint8ArrayToString, B as uriComponent, C as utf8ToBytes } from './chunks/index-0R2ntSud.js';
 export { createEmitter, createEventBus, withEmitter } from './compat/emitter.js';
 export { createVldKernel, definePlugin, getVldKernel, resetVldKernel, usePlugin } from './kernel.js';
 export { blue, bold, createTheme, cyan, dim, gray, green, grey, italic, magenta, default as pigment, red, strip, supportsColor, underline, vldTheme, white, yellow } from './pigment.js';
-
-/**
- * VLD Logger
- *
- * This module provides a debug logging system for VLD,
- * compatible with @oxog/log when available.
- */
-/**
- * Log level priorities (lower = more verbose)
- */
-const LOG_LEVEL_PRIORITY = {
-    debug: 0,
-    info: 1,
-    warn: 2,
-    error: 3,
-    silent: 4
-};
-/**
- * ANSI color codes for terminal output
- */
-const COLORS = {
-    reset: '\x1b[0m',
-    dim: '\x1b[2m',
-    red: '\x1b[31m',
-    yellow: '\x1b[33m',
-    blue: '\x1b[34m',
-    cyan: '\x1b[36m',
-    gray: '\x1b[90m'
-};
-/**
- * Level colors
- */
-const LEVEL_COLORS = {
-    debug: COLORS.gray,
-    info: COLORS.blue,
-    warn: COLORS.yellow,
-    error: COLORS.red
-};
-/**
- * Level labels
- */
-const LEVEL_LABELS = {
-    debug: 'DEBUG',
-    info: 'INFO ',
-    warn: 'WARN ',
-    error: 'ERROR'
-};
-/**
- * Default log handler
- */
-function createDefaultHandler(options) {
-    const colored = options.colored ?? true;
-    const timestamps = options.timestamps ?? true;
-    return (entry) => {
-        const parts = [];
-        // Timestamp
-        if (timestamps) {
-            const time = entry.timestamp.toISOString().slice(11, 23);
-            parts.push(colored ? `${COLORS.dim}${time}${COLORS.reset}` : time);
-        }
-        // Level
-        const levelLabel = LEVEL_LABELS[entry.level];
-        const levelColor = LEVEL_COLORS[entry.level];
-        parts.push(colored ? `${levelColor}${levelLabel}${COLORS.reset}` : levelLabel);
-        // Name
-        parts.push(colored ? `${COLORS.cyan}[${entry.name}]${COLORS.reset}` : `[${entry.name}]`);
-        // Message
-        parts.push(entry.message);
-        // Output
-        const output = parts.join(' ');
-        // Use appropriate console method
-        switch (entry.level) {
-            case 'debug':
-                console.debug(output, entry.data !== undefined ? entry.data : '');
-                break;
-            case 'info':
-                console.info(output, entry.data !== undefined ? entry.data : '');
-                break;
-            case 'warn':
-                console.warn(output, entry.data !== undefined ? entry.data : '');
-                break;
-            case 'error':
-                console.error(output, entry.data !== undefined ? entry.data : '');
-                break;
-        }
-    };
-}
-/**
- * Create a logger instance
- */
-function createLogger(options = {}) {
-    const name = options.name ?? 'vld';
-    let level = options.level ?? 'warn';
-    const handler = options.handler ?? createDefaultHandler(options);
-    const log = (logLevel, message, data) => {
-        if (LOG_LEVEL_PRIORITY[logLevel] < LOG_LEVEL_PRIORITY[level]) {
-            return;
-        }
-        const entry = {
-            level: logLevel,
-            message,
-            data,
-            timestamp: new Date(),
-            name
-        };
-        handler(entry);
-    };
-    const logger = {
-        debug: (message, data) => log('debug', message, data),
-        info: (message, data) => log('info', message, data),
-        warn: (message, data) => log('warn', message, data),
-        error: (message, data) => log('error', message, data),
-        isLevelEnabled: (checkLevel) => LOG_LEVEL_PRIORITY[checkLevel] >= LOG_LEVEL_PRIORITY[level],
-        setLevel: (newLevel) => {
-            level = newLevel;
-        },
-        getLevel: () => level,
-        child: (childName) => createLogger({
-            ...options,
-            name: `${name}:${childName}`
-        })
-    };
-    return logger;
-}
-// ============================================
-// Global Logger Management
-// ============================================
-let globalLogger = null;
-/**
- * Initialize the global VLD logger
- */
-function initLogger(options) {
-    globalLogger = createLogger({
-        name: 'vld',
-        ...options
-    });
-    return globalLogger;
-}
-/**
- * Get the global VLD logger
- * Returns null if not initialized
- */
-function getLogger() {
-    return globalLogger;
-}
-/**
- * Set log level for the global logger
- */
-function setLogLevel(level) {
-    if (globalLogger) {
-        globalLogger.setLevel(level);
-    }
-}
-/**
- * Enable debug mode for VLD
- */
-function enableDebug() {
-    if (!globalLogger) {
-        initLogger({ level: 'debug' });
-    }
-    else {
-        globalLogger.setLevel('debug');
-    }
-}
-/**
- * Disable all VLD logging
- */
-function disableLogging() {
-    if (globalLogger) {
-        globalLogger.setLevel('silent');
-    }
-}
-/**
- * Create a no-op logger for testing
- */
-function createNoOpLogger() {
-    return createLogger({ level: 'silent' });
-}
+import { V as VldError } from './chunks/errors-core-BeiFUtZM.js';
+export { getLocale, getMessages, getSupportedLocales, isLocaleLoaded, isLocaleSupported, registerLocale, setLocale } from './locales/runtime.js';
 
 /**
  * JSON Schema support for VLD validators
@@ -202,7 +70,22 @@ function createNoOpLogger() {
  * @returns JSON Schema definition
  */
 function toJSONSchema(schema, options = {}) {
-    return schemaToJSONSchema(schema, options);
+    const normalizedOptions = normalizeOptions(options);
+    const result = normalizeForTarget(schemaToJSONSchema(schema, normalizedOptions), normalizedOptions);
+    const target = normalizedOptions.target || 'draft-07';
+    if (target === 'draft-04') {
+        result.$schema ?? (result.$schema = 'http://json-schema.org/draft-04/schema#');
+    }
+    else if (target === 'draft-07') {
+        result.$schema ?? (result.$schema = 'http://json-schema.org/draft-07/schema#');
+    }
+    else if (target === 'draft-2019-09') {
+        result.$schema ?? (result.$schema = 'https://json-schema.org/draft/2019-09/schema');
+    }
+    else if (target === 'draft-2020-12') {
+        result.$schema ?? (result.$schema = 'https://json-schema.org/draft/2020-12/schema');
+    }
+    return result;
 }
 /**
  * Convert a JSON Schema to a VLD schema
@@ -212,98 +95,184 @@ function toJSONSchema(schema, options = {}) {
 function fromJSONSchema(json) {
     return jsonSchemaToVLD(json);
 }
+function normalizeOptions(options) {
+    const target = options.target;
+    if (target === 'draft-4') {
+        return { ...options, target: 'draft-04' };
+    }
+    if (target === 'draft-7') {
+        return { ...options, target: 'draft-07' };
+    }
+    return options;
+}
+function normalizeForTarget(definition, options) {
+    const target = options.target || 'draft-07';
+    const result = { ...definition };
+    if (Array.isArray(result.items)) {
+        const tupleItems = result.items.map((item) => normalizeForTarget(item, options));
+        if (target === 'draft-2020-12' || target === 'draft-2019-09') {
+            result.prefixItems = tupleItems;
+            result.items = false;
+        }
+        else {
+            result.items = tupleItems;
+        }
+    }
+    else if (result.items && typeof result.items === 'object') {
+        result.items = normalizeForTarget(result.items, options);
+    }
+    if (result.prefixItems) {
+        result.prefixItems = result.prefixItems.map((item) => normalizeForTarget(item, options));
+    }
+    if (result.properties) {
+        result.properties = Object.fromEntries(Object.entries(result.properties).map(([key, value]) => [key, normalizeForTarget(value, options)]));
+    }
+    if (result.additionalProperties && typeof result.additionalProperties === 'object') {
+        result.additionalProperties = normalizeForTarget(result.additionalProperties, options);
+    }
+    for (const key of ['anyOf', 'allOf', 'oneOf']) {
+        if (result[key]) {
+            result[key] = result[key].map((item) => normalizeForTarget(item, options));
+        }
+    }
+    if (result.not && typeof result.not === 'object') {
+        result.not = normalizeForTarget(result.not, options);
+    }
+    if (target === 'openapi-3.0') {
+        normalizeOpenAPI30(result);
+    }
+    return result;
+}
+function normalizeOpenAPI30(definition) {
+    if (Array.isArray(definition.type) && definition.type.includes('null')) {
+        const nonNullTypes = definition.type.filter((type) => type !== 'null');
+        definition.nullable = true;
+        if (nonNullTypes.length === 1) {
+            const nonNullType = nonNullTypes[0];
+            if (nonNullType !== undefined) {
+                definition.type = nonNullType;
+            }
+            else {
+                delete definition.type;
+            }
+        }
+        else if (nonNullTypes.length > 1) {
+            definition.type = nonNullTypes;
+        }
+        else {
+            delete definition.type;
+        }
+    }
+    if (typeof definition.exclusiveMinimum === 'number') {
+        definition.minimum ?? (definition.minimum = definition.exclusiveMinimum);
+        definition.exclusiveMinimum = true;
+    }
+    if (typeof definition.exclusiveMaximum === 'number') {
+        definition.maximum ?? (definition.maximum = definition.exclusiveMaximum);
+        definition.exclusiveMaximum = true;
+    }
+}
 /**
  * Internal function to convert VLD schema to JSON Schema
  */
 function schemaToJSONSchema(schema, options) {
+    const target = options.target || 'draft-07';
+    const schemaAny = schema;
+    const validatorType = schema.validatorType;
     // Handle primitives
-    if (schema.constructor.name === 'VldString') {
-        return buildStringSchema();
+    if (schema.constructor.name === 'VldString' || validatorType === VLD_VALIDATOR_TYPES.STRING) {
+        return withMetadata(schema, buildStringSchema(target, schema), options);
     }
-    if (schema.constructor.name === 'VldNumber') {
-        return buildNumberSchema(schema);
+    if (schema.constructor.name === 'VldNumber' || validatorType === VLD_VALIDATOR_TYPES.NUMBER) {
+        return withMetadata(schema, buildNumberSchema(schema), options);
     }
-    if (schema.constructor.name === 'VldBoolean') {
-        return { type: 'boolean' };
+    if (schema.constructor.name === 'VldBoolean' || validatorType === VLD_VALIDATOR_TYPES.BOOLEAN) {
+        return withMetadata(schema, { type: 'boolean' }, options);
     }
-    if (schema.constructor.name === 'VldBigInt') {
-        return { type: 'integer' };
+    if (schema.constructor.name === 'VldBigInt' || validatorType === VLD_VALIDATOR_TYPES.BIGINT) {
+        return withMetadata(schema, buildBigIntSchema(schema), options);
     }
-    if (schema.constructor.name === 'VldDate') {
-        return { type: 'string', format: 'date-time' };
+    if (schema.constructor.name === 'VldDate' || validatorType === VLD_VALIDATOR_TYPES.DATE) {
+        return withMetadata(schema, buildDateSchema(schema), options);
     }
-    if (schema.constructor.name === 'VldArray') {
-        return buildArraySchema(schema, options);
+    if (schema.constructor.name === 'VldArray' || validatorType === VLD_VALIDATOR_TYPES.ARRAY) {
+        return withMetadata(schema, buildArraySchema(schema, options), options);
     }
-    if (schema.constructor.name === 'VldObject') {
-        return buildObjectSchema(schema, options);
+    if (schema.constructor.name === 'VldObject' || validatorType === VLD_VALIDATOR_TYPES.OBJECT) {
+        return withMetadata(schema, buildObjectSchema(schema, options), options);
     }
     // Handle union types
     if (schema.constructor.name === 'VldUnion') {
-        return buildUnionSchema(schema, options);
+        return withMetadata(schema, buildUnionSchema(schema, options), options);
     }
     // Handle literal types
     if (schema.constructor.name === 'VldLiteral') {
-        return buildLiteralSchema(schema);
+        return withMetadata(schema, buildLiteralSchema(schema), options);
     }
     if (schema.constructor.name === 'VldEnum') {
-        return buildEnumSchema(schema);
+        return withMetadata(schema, buildEnumSchema(schema), options);
+    }
+    if (schema.constructor.name === 'VldSet' || validatorType === VLD_VALIDATOR_TYPES.SET) {
+        return withMetadata(schema, buildSetSchema(schema, options), options);
     }
-    if (schema.constructor.name === 'VldRecord') {
-        return buildRecordSchema(schema, options);
+    if (schema.constructor.name === 'VldMap' || validatorType === VLD_VALIDATOR_TYPES.MAP) {
+        return withMetadata(schema, buildMapSchema(schema, options), options);
     }
-    if (schema.constructor.name === 'VldTuple') {
-        return buildTupleSchema(schema, options);
+    if (schema.constructor.name === 'VldRecord' || validatorType === VLD_VALIDATOR_TYPES.RECORD) {
+        return withMetadata(schema, buildRecordSchema(schema, options), options);
+    }
+    if (schema.constructor.name === 'VldTuple' || validatorType === VLD_VALIDATOR_TYPES.TUPLE) {
+        return withMetadata(schema, buildTupleSchema(schema, options), options);
     }
     if (schema.constructor.name === 'VldIntersection') {
-        return buildIntersectionSchema(schema, options);
+        return withMetadata(schema, buildIntersectionSchema(schema, options), options);
     }
     if (schema.constructor.name === 'VldOptional') {
-        return buildOptionalSchema(schema, options);
+        return withMetadata(schema, buildOptionalSchema(schema, options), options);
     }
     if (schema.constructor.name === 'VldNullable') {
-        return buildNullableSchema(schema, options);
+        return withMetadata(schema, buildNullableSchema(schema, options), options);
     }
     if (schema.constructor.name === 'VldNullish') {
-        return buildNullishSchema(schema, options);
+        return withMetadata(schema, buildNullishSchema(schema, options), options);
     }
     if (schema.constructor.name === 'VldExactOptional') {
-        return buildExactOptionalSchema(schema, options);
+        return withMetadata(schema, buildExactOptionalSchema(schema, options), options);
     }
     if (schema.constructor.name === 'VldLazy') {
-        return { type: 'object' }; // Placeholder for recursive schemas
+        return withMetadata(schema, { type: 'object' }, options); // Placeholder for recursive schemas
     }
     if (schema.constructor.name === 'VldJson') {
-        return {}; // Any JSON
+        return withMetadata(schema, {}, options); // Any JSON
     }
     if (schema.constructor.name === 'VldAny') {
-        return {}; // JSON Schema true
+        return withMetadata(schema, {}, options); // JSON Schema true
     }
     if (schema.constructor.name === 'VldUnknown') {
-        return {}; // JSON Schema true
+        return withMetadata(schema, {}, options); // JSON Schema true
     }
     if (schema.constructor.name === 'VldNever') {
-        return { not: {} }; // JSON Schema false
+        return withMetadata(schema, { not: {} }, options); // JSON Schema false
     }
     if (schema.constructor.name === 'VldNull') {
-        return { type: 'null' };
+        return withMetadata(schema, { type: 'null' }, options);
     }
     if (schema.constructor.name === 'VldUndefined') {
-        return { not: {} }; // Undefined can't be represented in JSON Schema
+        return withMetadata(schema, { not: {} }, options); // Undefined can't be represented in JSON Schema
     }
     if (schema.constructor.name === 'VldNan') {
-        return { type: 'number', not: {} }; // NaN is a number type constraint
+        return withMetadata(schema, { type: 'number', not: {} }, options); // NaN is a number type constraint
     }
     if (schema.constructor.name === 'VldVoid') {
-        return { not: {} }; // Void/undefined can't be represented
+        return withMetadata(schema, { not: {} }, options); // Void/undefined can't be represented
     }
     // Handle branded types - unwrap and continue
     if (schema.constructor.name === 'VldBrand') {
-        return schemaToJSONSchema(schema.baseValidator, options);
+        return withMetadata(schema, schemaToJSONSchema(schemaAny.baseValidator, options), options);
     }
     // Handle readonly types
     if (schema.constructor.name === 'VldReadonly') {
-        return schemaToJSONSchema(schema.baseValidator, options);
+        return withMetadata(schema, schemaToJSONSchema(schemaAny.baseValidator, options), options);
     }
     // Handle transform types
     if (schema.constructor.name === 'VldTransform') {
@@ -311,64 +280,115 @@ function schemaToJSONSchema(schema, options) {
     }
     // Handle meta types - unwrap metadata
     if (schema.constructor.name === 'VldMeta') {
-        const metaSchema = schema;
-        const result = schemaToJSONSchema(metaSchema.baseValidator, options);
-        if (options.includeMetadata !== false && metaSchema.metadata) {
-            const meta = metaSchema.metadata;
-            if (meta.title)
-                result.title = meta.title;
-            if (meta.description)
-                result.description = meta.description;
-            if (meta.examples && options.includeExamples)
-                result.examples = meta.examples;
-            if (meta.default !== undefined)
-                result.default = meta.default;
-            if (meta.deprecated)
-                result.deprecated = true;
-            if (meta.readOnly)
-                result.readOnly = true;
-            if (meta.writeOnly)
-                result.writeOnly = true;
-        }
-        return result;
+        const result = schemaToJSONSchema(schemaAny.baseValidator, options);
+        return withMetadata(schema, result, options);
     }
     // Handle refine/superRefine types
     if (schema.constructor.name === 'VldRefine' || schema.constructor.name === 'VldSuperRefine') {
-        return schemaToJSONSchema(schema._inner || schema._baseValidator, options);
+        return withMetadata(schema, schemaToJSONSchema(unwrapInner(schemaAny), options), options);
     }
     // Handle pipe types
     if (schema.constructor.name === 'VldPipe') {
-        return schemaToJSONSchema(schema._next || schema.second, options);
+        return withMetadata(schema, schemaToJSONSchema(schemaAny._next || schemaAny.second, options), options);
     }
     // Handle default/catch types
     if (schema.constructor.name === 'VldDefault' || schema.constructor.name === 'VldCatch') {
-        return schemaToJSONSchema(schema._inner || schema._baseValidator, options);
+        return withMetadata(schema, schemaToJSONSchema(unwrapInner(schemaAny), options), options);
     }
     // Handle preprocess types
     if (schema.constructor.name === 'VldPreprocess') {
-        return schemaToJSONSchema(schema._schema, options);
+        return withMetadata(schema, schemaToJSONSchema(schemaAny._schema, options), options);
     }
     // Handle string format validators
     if (schema.constructor.name === 'VldStringFormat') {
         const formatSchema = schema;
-        return { type: 'string', format: formatSchema._format };
+        return withMetadata(schema, { type: 'string', format: formatSchema._format }, options);
     }
     // Fallback for unknown types
-    return {};
+    return withMetadata(schema, {}, options);
+}
+function unwrapInner(schema) {
+    if (typeof schema.unwrap === 'function') {
+        return schema.unwrap();
+    }
+    return schema._inner || schema._baseValidator || schema.baseValidator || schema.valueValidator;
+}
+function getMetadata(schema) {
+    const registered = globalRegistry.get(schema);
+    const schemaAny = schema;
+    const local = typeof schemaAny.getMeta === 'function' ? schemaAny.getMeta() : undefined;
+    return registered || local ? { ...(local || {}), ...(registered || {}) } : undefined;
+}
+function withMetadata(schema, definition, options) {
+    if (options.includeMetadata === false) {
+        return definition;
+    }
+    const metadata = getMetadata(schema);
+    if (!metadata) {
+        return definition;
+    }
+    const result = { ...definition };
+    if (metadata.id)
+        result.$id = metadata.id;
+    if (metadata.title)
+        result.title = metadata.title;
+    if (metadata.description)
+        result.description = metadata.description;
+    if (metadata.examples && options.includeExamples !== false)
+        result.examples = metadata.examples;
+    if (metadata.default !== undefined)
+        result.default = metadata.default;
+    if (metadata.deprecated)
+        result.deprecated = true;
+    if (metadata.readOnly)
+        result.readOnly = true;
+    if (metadata.writeOnly)
+        result.writeOnly = true;
+    return result;
 }
 /**
  * Build string JSON Schema
  */
-function buildStringSchema(_target) {
-    return { type: 'string' };
+function buildStringSchema(_target, schema) {
+    const hints = schema?.config?.jsonSchema || {};
+    const result = { type: 'string' };
+    if (hints.exactLength !== undefined) {
+        result.minLength = hints.exactLength;
+        result.maxLength = hints.exactLength;
+    }
+    else {
+        if (hints.minLength !== undefined)
+            result.minLength = hints.minLength;
+        if (hints.maxLength !== undefined)
+            result.maxLength = hints.maxLength;
+    }
+    if (hints.format)
+        result.format = hints.format;
+    if (hints.pattern)
+        result.pattern = hints.pattern;
+    return result;
 }
 /**
  * Build number JSON Schema from VLD number schema
  */
 function buildNumberSchema(schema, _target) {
     const config = schema.config || {};
+    const hints = config.jsonSchema || {};
     const checks = config.checks || [];
-    const result = { type: 'number' };
+    const result = { type: hints.type || 'number' };
+    if (hints.minimum !== undefined)
+        result.minimum = hints.minimum;
+    if (hints.maximum !== undefined)
+        result.maximum = hints.maximum;
+    if (hints.exclusiveMinimum !== undefined)
+        result.exclusiveMinimum = hints.exclusiveMinimum;
+    if (hints.exclusiveMaximum !== undefined)
+        result.exclusiveMaximum = hints.exclusiveMaximum;
+    if (hints.multipleOf !== undefined)
+        result.multipleOf = hints.multipleOf;
+    if (Object.keys(hints).length > 0) {
+        return result;
+    }
     for (const check of checks) {
         // Try to extract constraints from closures
         const checkStr = check.toString();
@@ -388,32 +408,85 @@ function buildNumberSchema(schema, _target) {
     }
     return result;
 }
+function bigintToSafeNumber(value) {
+    const asNumber = Number(value);
+    if (!Number.isSafeInteger(asNumber)) {
+        return undefined;
+    }
+    return BigInt(asNumber) === value ? asNumber : undefined;
+}
+function applyBigIntBound(result, numericKey, extensionKey, value) {
+    if (value === undefined) {
+        return;
+    }
+    result[extensionKey] = value.toString();
+    const safeNumber = bigintToSafeNumber(value);
+    if (safeNumber !== undefined) {
+        result[numericKey] = safeNumber;
+    }
+}
+function buildBigIntSchema(schema) {
+    const hints = schema.jsonSchema || schema.config?.jsonSchema || {};
+    const result = { type: 'integer' };
+    applyBigIntBound(result, 'minimum', 'x-vld-minimum', hints.minimum);
+    applyBigIntBound(result, 'maximum', 'x-vld-maximum', hints.maximum);
+    applyBigIntBound(result, 'exclusiveMinimum', 'x-vld-exclusiveMinimum', hints.exclusiveMinimum);
+    applyBigIntBound(result, 'exclusiveMaximum', 'x-vld-exclusiveMaximum', hints.exclusiveMaximum);
+    return result;
+}
+function buildDateSchema(schema) {
+    const hints = schema.jsonSchema || schema.config?.jsonSchema || {};
+    const result = {
+        type: 'string',
+        format: 'date-time'
+    };
+    if (hints.formatMinimum)
+        result.formatMinimum = hints.formatMinimum;
+    if (hints.formatMaximum)
+        result.formatMaximum = hints.formatMaximum;
+    if (hints.formatExclusiveMinimum)
+        result.formatExclusiveMinimum = hints.formatExclusiveMinimum;
+    if (hints.formatExclusiveMaximum)
+        result.formatExclusiveMaximum = hints.formatExclusiveMaximum;
+    return result;
+}
 /**
  * Build array JSON Schema
  */
 function buildArraySchema(schema, options) {
-    const inner = schema._item || schema._inner;
+    const inner = schema._item || schema._inner || schema.config?.itemValidator;
+    const result = { type: 'array' };
     if (inner) {
-        return {
-            type: 'array',
-            items: toJSONSchema(inner, options)
-        };
+        result.items = schemaToJSONSchema(inner, options);
+    }
+    if (schema.config?.exactLength !== undefined) {
+        result.minItems = schema.config.exactLength;
+        result.maxItems = schema.config.exactLength;
+    }
+    else {
+        if (schema.config?.minLength !== undefined)
+            result.minItems = schema.config.minLength;
+        if (schema.config?.maxLength !== undefined)
+            result.maxItems = schema.config.maxLength;
     }
-    return { type: 'array' };
+    if (schema.config?.unique)
+        result.uniqueItems = true;
+    return result;
 }
 /**
  * Build object JSON Schema
  */
 function buildObjectSchema(schema, options) {
-    const shape = schema._shape || schema.shape;
+    const shape = schema._shape || schema.shape || schema.config?.shape;
     if (!shape)
         return { type: 'object' };
     const properties = {};
     const required = [];
     for (const [key, value] of Object.entries(shape)) {
-        properties[key] = toJSONSchema(value, options);
+        const child = value;
+        properties[key] = schemaToJSONSchema(child, options);
         // VLD objects require all keys by default
-        if (schema._strict !== false) {
+        if (!isOptionalLike(child)) {
             required.push(key);
         }
     }
@@ -425,28 +498,40 @@ function buildObjectSchema(schema, options) {
         result.required = required;
     }
     // Handle passthrough mode
-    if (schema._passthrough || schema._loose) {
+    if (schema._passthrough || schema._loose || schema.config?.passthrough) {
         result.additionalProperties = true;
     }
-    else if (schema._strict) {
+    else if (schema._strict || schema.config?.strict) {
         result.additionalProperties = false;
     }
+    else if (schema.config?.catchall) {
+        result.additionalProperties = schemaToJSONSchema(schema.config.catchall, options);
+    }
     return result;
 }
+function isOptionalLike(schema) {
+    const name = schema.constructor.name;
+    return (name === 'VldOptional' ||
+        name === 'VldNullish' ||
+        name === 'VldExactOptional' ||
+        schema.validatorType === VLD_VALIDATOR_TYPES.OPTIONAL ||
+        schema.validatorType === VLD_VALIDATOR_TYPES.NULLISH ||
+        schema.validatorType === VLD_VALIDATOR_TYPES.EXACT_OPTIONAL);
+}
 /**
  * Build union JSON Schema
  */
 function buildUnionSchema(schema, options) {
-    const validators = schema._validators || schema._options || [];
+    const validators = schema._validators || schema._options || schema.validators || [];
     return {
-        anyOf: validators.map((v) => toJSONSchema(v, options))
+        anyOf: validators.map((v) => schemaToJSONSchema(v, options))
     };
 }
 /**
  * Build literal JSON Schema
  */
 function buildLiteralSchema(schema) {
-    const value = schema._value || schema.value;
+    const value = schema._literal ?? schema.literal ?? schema._value ?? schema.value;
     if (value === null)
         return { type: 'null' };
     if (typeof value === 'string')
@@ -471,26 +556,60 @@ function buildEnumSchema(schema) {
  * Build record JSON Schema
  */
 function buildRecordSchema(schema, options) {
-    const valueValidator = schema._value || schema._inner;
+    const valueValidator = schema.valueSchema || schema._value || schema._inner || schema.valueValidator;
     if (valueValidator) {
         return {
             type: 'object',
-            additionalProperties: toJSONSchema(valueValidator, options)
+            additionalProperties: schemaToJSONSchema(valueValidator, options)
         };
     }
     return { type: 'object' };
 }
+/**
+ * Build Set JSON Schema as the JSON-compatible array representation.
+ */
+function buildSetSchema(schema, options) {
+    const itemValidator = schema.itemSchema || schema.itemValidator || schema._item || schema._inner;
+    const result = {
+        type: 'array',
+        uniqueItems: true,
+        'x-vld-type': 'set'
+    };
+    if (itemValidator) {
+        result.items = schemaToJSONSchema(itemValidator, options);
+    }
+    return result;
+}
+/**
+ * Build Map JSON Schema as an array of key/value pairs.
+ */
+function buildMapSchema(schema, options) {
+    const keyValidator = schema.keySchema || schema.keyValidator || schema._key;
+    const valueValidator = schema.valueSchema || schema.valueValidator || schema._value;
+    const keySchema = keyValidator ? schemaToJSONSchema(keyValidator, options) : {};
+    const valueSchema = valueValidator ? schemaToJSONSchema(valueValidator, options) : {};
+    return {
+        type: 'array',
+        'x-vld-type': 'map',
+        items: {
+            type: 'array',
+            items: [keySchema, valueSchema],
+            minItems: 2,
+            maxItems: 2
+        }
+    };
+}
 /**
  * Build tuple JSON Schema
  */
 function buildTupleSchema(schema, options) {
-    const items = schema._items || schema.items;
+    const items = schema.items || schema._items || schema.validators;
     if (!items || !Array.isArray(items)) {
         return { type: 'array' };
     }
     return {
         type: 'array',
-        items: items.map((item) => toJSONSchema(item, options)),
+        items: items.map((item) => schemaToJSONSchema(item, options)),
         minItems: items.length,
         maxItems: items.length
     };
@@ -503,23 +622,23 @@ function buildIntersectionSchema(schema, options) {
     const second = schema._second || schema.second;
     const schemas = [];
     if (first)
-        schemas.push(toJSONSchema(first, options));
+        schemas.push(schemaToJSONSchema(first, options));
     if (second)
-        schemas.push(toJSONSchema(second, options));
+        schemas.push(schemaToJSONSchema(second, options));
     if (schemas.length === 0)
         return {};
     if (schemas.length === 1)
-        return schemas[0];
+        return schemas[0] ?? {};
     return { allOf: schemas };
 }
 /**
  * Build optional JSON Schema
  */
 function buildOptionalSchema(schema, options) {
-    const inner = schema._inner || schema._baseValidator;
+    const inner = unwrapInner(schema);
     if (!inner)
         return {};
-    const result = toJSONSchema(inner, options);
+    const result = schemaToJSONSchema(inner, options);
     // Remove from required array - but we don't track required here
     return result;
 }
@@ -527,10 +646,10 @@ function buildOptionalSchema(schema, options) {
  * Build nullable JSON Schema
  */
 function buildNullableSchema(schema, options) {
-    const inner = schema._inner || schema._baseValidator;
+    const inner = unwrapInner(schema);
     if (!inner)
         return { type: 'null' };
-    const result = toJSONSchema(inner, options);
+    const result = schemaToJSONSchema(inner, options);
     if (typeof result.type === 'string') {
         return { type: [result.type, 'null'] };
     }
@@ -546,37 +665,31 @@ function buildNullableSchema(schema, options) {
  * Build nullish JSON Schema
  */
 function buildNullishSchema(schema, options) {
-    const inner = schema._inner || schema._baseValidator;
+    const inner = unwrapInner(schema);
     if (!inner)
         return {};
-    return toJSONSchema(inner, options);
+    const result = schemaToJSONSchema(inner, options);
+    if (typeof result.type === 'string') {
+        return { ...result, type: [result.type, 'null'] };
+    }
+    return result;
 }
 /**
  * Build exactOptional JSON Schema
  */
 function buildExactOptionalSchema(schema, options) {
-    const inner = schema._inner || schema._baseValidator;
+    const inner = unwrapInner(schema);
     if (!inner)
         return {};
-    return toJSONSchema(inner, options);
+    return schemaToJSONSchema(inner, options);
 }
 /**
  * Internal function to convert JSON Schema to VLD schema
  */
 function jsonSchemaToVLD(json) {
-    // This is a simplified implementation
-    // Full implementation would recursively handle all JSON Schema types
-    const VldString = require('../validators/string').VldString;
-    const VldNumber = require('../validators/number').VldNumber;
-    const VldBoolean = require('../validators/boolean').VldBoolean;
-    const VldObject = require('../validators/object').VldObject;
-    const VldArray = require('../validators/array').VldArray;
-    const VldUnion = require('../validators/union').VldUnion;
-    const VldLiteral = require('../validators/literal').VldLiteral;
-    const VldEnum = require('../validators/enum').VldEnum;
-    const VldNull = require('../validators/null').VldNull;
-    const VldAny = require('../validators/any').VldAny;
-    const VldRecord = require('../validators/record').VldRecord;
+    return applyJSONSchemaMetadata(jsonSchemaToVLDInner(json), json);
+}
+function jsonSchemaToVLDInner(json) {
     // Handle $ref
     if (json.$ref) {
         // For now, return any - full $ref handling requires registry
@@ -594,10 +707,13 @@ function jsonSchemaToVLD(json) {
     // Handle allOf (intersection)
     if (json.allOf) {
         // For intersection, we'd need VldIntersection
-        const first = jsonSchemaToVLD(json.allOf[0]);
+        const firstSchema = json.allOf[0];
+        if (firstSchema === undefined) {
+            return VldAny.create();
+        }
+        const first = jsonSchemaToVLD(firstSchema);
         if (json.allOf.length > 1) {
             const second = jsonSchemaToVLD({ allOf: json.allOf.slice(1) });
-            const VldIntersection = require('../validators/intersection').VldIntersection;
             return VldIntersection.create(first, second);
         }
         return first;
@@ -616,15 +732,17 @@ function jsonSchemaToVLD(json) {
         return VldEnum.create(json.enum);
     }
     // Handle type
-    const type = json.type;
+    const type = json.nullable && typeof json.type === 'string'
+        ? [json.type, 'null']
+        : json.type;
     if (type === 'string' || type === undefined) {
-        const s = VldString.create();
-        if (json.minLength)
-            s.minLength = json.minLength;
-        if (json.maxLength)
-            s.maxLength = json.maxLength;
+        let s = VldString.create();
+        if (json.minLength !== undefined)
+            s = s.min(json.minLength);
+        if (json.maxLength !== undefined)
+            s = s.max(json.maxLength);
         if (json.pattern)
-            s.pattern = json.pattern;
+            s = s.regex(new RegExp(json.pattern));
         if (json.format) {
             // Map JSON Schema formats to VLD validators
             switch (json.format) {
@@ -634,39 +752,48 @@ function jsonSchemaToVLD(json) {
                     // Would need DateTime validator
                     break;
                 case 'email':
-                    const email = require('../validators/string-formats').email;
-                    return email();
+                    return email$1();
                 case 'uri':
                 case 'uri-reference':
-                    const httpUrl = require('../validators/string-formats').httpUrl;
-                    return httpUrl();
+                    return httpUrl$1();
                 case 'uuid':
-                    const uuid = require('../validators/string-formats').uuid;
-                    return uuid();
+                    return uuid$1();
             }
         }
         return s;
     }
     if (type === 'number' || type === 'integer') {
-        const n = VldNumber.create();
+        let n = VldNumber.create();
         if (type === 'integer')
-            n.int();
+            n = n.int();
         if (json.minimum !== undefined)
-            n.min(json.minimum);
+            n = n.min(json.minimum);
         if (json.maximum !== undefined)
-            n.max(json.maximum);
-        if (json.exclusiveMinimum !== undefined)
-            n.gt(json.exclusiveMinimum);
-        if (json.exclusiveMaximum !== undefined)
-            n.lt(json.exclusiveMaximum);
+            n = n.max(json.maximum);
+        if (typeof json.exclusiveMinimum === 'number')
+            n = n.gt(json.exclusiveMinimum);
+        if (typeof json.exclusiveMaximum === 'number')
+            n = n.lt(json.exclusiveMaximum);
+        if (json.exclusiveMinimum === true && json.minimum !== undefined)
+            n = n.gt(json.minimum);
+        if (json.exclusiveMaximum === true && json.maximum !== undefined)
+            n = n.lt(json.maximum);
         if (json.multipleOf !== undefined)
-            n.multipleOf(json.multipleOf);
+            n = n.multipleOf(json.multipleOf);
         return n;
     }
     if (type === 'boolean') {
         return VldBoolean.create();
     }
     if (type === 'array') {
+        if (json.prefixItems && json.prefixItems.length > 0) {
+            const validators = json.prefixItems.map((item) => jsonSchemaToVLD(item));
+            return VldTuple.create(...validators);
+        }
+        if (Array.isArray(json.items)) {
+            const validators = json.items.map((item) => jsonSchemaToVLD(item));
+            return VldTuple.create(...validators);
+        }
         if (json.items && !Array.isArray(json.items)) {
             return VldArray.create(jsonSchemaToVLD(json.items));
         }
@@ -675,17 +802,12 @@ function jsonSchemaToVLD(json) {
     if (type === 'object') {
         if (json.properties) {
             const shape = {};
-            const required = json.required || [];
+            const required = new Set(json.required || []);
             for (const [key, propSchema] of Object.entries(json.properties)) {
-                shape[key] = jsonSchemaToVLD(propSchema);
+                const fieldSchema = jsonSchemaToVLD(propSchema);
+                shape[key] = required.has(key) ? fieldSchema : fieldSchema.optional();
             }
             let obj = VldObject.create(shape);
-            if (!required.length) {
-                // If no required fields, make all optional
-                for (const key of Object.keys(shape)) {
-                    if (!required.includes(key)) ;
-                }
-            }
             if (json.additionalProperties === false) {
                 obj = obj.strict();
             }
@@ -695,7 +817,7 @@ function jsonSchemaToVLD(json) {
             else if (json.additionalProperties) {
                 // additionalProperties is a schema
                 const valueSchema = jsonSchemaToVLD(json.additionalProperties);
-                obj = VldRecord.create(valueSchema);
+                return VldRecord.create(valueSchema);
             }
             return obj;
         }
@@ -708,7 +830,7 @@ function jsonSchemaToVLD(json) {
     if (Array.isArray(type)) {
         // Union of types
         const options = type.map((t) => {
-            return jsonSchemaToVLD({ ...json, type: t });
+            return jsonSchemaToVLD({ ...json, type: t, nullable: false });
         });
         if (options.length > 0) {
             return VldUnion.create(...options);
@@ -717,6 +839,206 @@ function jsonSchemaToVLD(json) {
     // Fallback to any
     return VldAny.create();
 }
+function applyJSONSchemaMetadata(schema, json) {
+    const metadata = {};
+    if (json.$id)
+        metadata.id = json.$id;
+    if (json.title)
+        metadata.title = json.title;
+    if (json.description)
+        metadata.description = json.description;
+    if (json.examples)
+        metadata.examples = json.examples;
+    if (json.default !== undefined)
+        metadata.default = json.default;
+    if (json.deprecated)
+        metadata.deprecated = true;
+    if (json.readOnly)
+        metadata.readOnly = true;
+    if (json.writeOnly)
+        metadata.writeOnly = true;
+    return Object.keys(metadata).length > 0
+        ? schema.meta(metadata)
+        : schema;
+}
+
+/**
+ * VLD Logger
+ *
+ * This module provides a debug logging system for VLD,
+ * compatible with @oxog/log when available.
+ */
+/**
+ * Log level priorities (lower = more verbose)
+ */
+const LOG_LEVEL_PRIORITY = {
+    debug: 0,
+    info: 1,
+    warn: 2,
+    error: 3,
+    silent: 4
+};
+/**
+ * ANSI color codes for terminal output
+ */
+const COLORS = {
+    reset: '\x1b[0m',
+    dim: '\x1b[2m',
+    red: '\x1b[31m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    cyan: '\x1b[36m',
+    gray: '\x1b[90m'
+};
+/**
+ * Level colors
+ */
+const LEVEL_COLORS = {
+    debug: COLORS.gray,
+    info: COLORS.blue,
+    warn: COLORS.yellow,
+    error: COLORS.red
+};
+/**
+ * Level labels
+ */
+const LEVEL_LABELS = {
+    debug: 'DEBUG',
+    info: 'INFO ',
+    warn: 'WARN ',
+    error: 'ERROR'
+};
+/**
+ * Default log handler
+ */
+function createDefaultHandler(options) {
+    const colored = options.colored ?? true;
+    const timestamps = options.timestamps ?? true;
+    return (entry) => {
+        const parts = [];
+        // Timestamp
+        if (timestamps) {
+            const time = entry.timestamp.toISOString().slice(11, 23);
+            parts.push(colored ? `${COLORS.dim}${time}${COLORS.reset}` : time);
+        }
+        // Level
+        const levelLabel = LEVEL_LABELS[entry.level];
+        const levelColor = LEVEL_COLORS[entry.level];
+        parts.push(colored ? `${levelColor}${levelLabel}${COLORS.reset}` : levelLabel);
+        // Name
+        parts.push(colored ? `${COLORS.cyan}[${entry.name}]${COLORS.reset}` : `[${entry.name}]`);
+        // Message
+        parts.push(entry.message);
+        // Output
+        const output = parts.join(' ');
+        // Use appropriate console method
+        switch (entry.level) {
+            case 'debug':
+                console.debug(output, entry.data !== undefined ? entry.data : '');
+                break;
+            case 'info':
+                console.info(output, entry.data !== undefined ? entry.data : '');
+                break;
+            case 'warn':
+                console.warn(output, entry.data !== undefined ? entry.data : '');
+                break;
+            case 'error':
+                console.error(output, entry.data !== undefined ? entry.data : '');
+                break;
+        }
+    };
+}
+/**
+ * Create a logger instance
+ */
+function createLogger(options = {}) {
+    const name = options.name ?? 'vld';
+    let level = options.level ?? 'warn';
+    const handler = options.handler ?? createDefaultHandler(options);
+    const log = (logLevel, message, data) => {
+        if (LOG_LEVEL_PRIORITY[logLevel] < LOG_LEVEL_PRIORITY[level]) {
+            return;
+        }
+        const entry = {
+            level: logLevel,
+            message,
+            data,
+            timestamp: new Date(),
+            name
+        };
+        handler(entry);
+    };
+    const logger = {
+        debug: (message, data) => log('debug', message, data),
+        info: (message, data) => log('info', message, data),
+        warn: (message, data) => log('warn', message, data),
+        error: (message, data) => log('error', message, data),
+        isLevelEnabled: (checkLevel) => LOG_LEVEL_PRIORITY[checkLevel] >= LOG_LEVEL_PRIORITY[level],
+        setLevel: (newLevel) => {
+            level = newLevel;
+        },
+        getLevel: () => level,
+        child: (childName) => createLogger({
+            ...options,
+            name: `${name}:${childName}`
+        })
+    };
+    return logger;
+}
+// ============================================
+// Global Logger Management
+// ============================================
+let globalLogger = null;
+/**
+ * Initialize the global VLD logger
+ */
+function initLogger(options) {
+    globalLogger = createLogger({
+        name: 'vld',
+        ...options
+    });
+    return globalLogger;
+}
+/**
+ * Get the global VLD logger
+ * Returns null if not initialized
+ */
+function getLogger() {
+    return globalLogger;
+}
+/**
+ * Set log level for the global logger
+ */
+function setLogLevel(level) {
+    if (globalLogger) {
+        globalLogger.setLevel(level);
+    }
+}
+/**
+ * Enable debug mode for VLD
+ */
+function enableDebug() {
+    if (!globalLogger) {
+        initLogger({ level: 'debug' });
+    }
+    else {
+        globalLogger.setLevel('debug');
+    }
+}
+/**
+ * Disable all VLD logging
+ */
+function disableLogging() {
+    if (globalLogger) {
+        globalLogger.setLevel('silent');
+    }
+}
+/**
+ * Create a no-op logger for testing
+ */
+function createNoOpLogger() {
+    return createLogger({ level: 'silent' });
+}
 
 /**
  * VLD - Fast, Type-Safe Validation Library
@@ -733,7 +1055,192 @@ function jsonSchemaToVLD(json) {
  * - Colored console output for better debugging
  * - Debug logging system
  */
-// Import validators
+// Import base class
+let globalConfig = {};
+let globalErrorMap;
+function configure(config) {
+    if (config === undefined) {
+        return { ...globalConfig };
+    }
+    globalConfig = { ...globalConfig, ...config };
+    if ('customError' in config) {
+        globalErrorMap = config.customError;
+    }
+    else if ('errorMap' in config) {
+        globalErrorMap = config.errorMap;
+    }
+    return { ...globalConfig };
+}
+function setGlobalErrorMap(errorMap) {
+    globalErrorMap = errorMap;
+    globalConfig = { ...globalConfig, errorMap };
+}
+function getGlobalErrorMap() {
+    return globalErrorMap;
+}
+function enumValuesFromNativeEnum(enumObject) {
+    const values = Object.keys(enumObject)
+        .filter(key => !/^\d+$/.test(key))
+        .map(key => enumObject[key])
+        .filter((value) => typeof value === 'string' || typeof value === 'number');
+    const uniqueValues = Array.from(new Set(values));
+    if (uniqueValues.length === 0) {
+        throw new Error('nativeEnum requires at least one string or number value');
+    }
+    return uniqueValues;
+}
+function toErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function addFormattedIssue(root, path, message) {
+    let current = root;
+    for (const segment of path) {
+        const key = String(segment);
+        const next = current[key];
+        if (!next || Array.isArray(next)) {
+            current[key] = { _errors: [] };
+        }
+        current = current[key];
+    }
+    current._errors.push(message);
+}
+function isCodec(schema) {
+    return schema instanceof VldCodec;
+}
+function messageFromRefinementParam(param) {
+    return param === undefined ? undefined : resolveErrorMessage(param, 'Refinement check failed');
+}
+function cloneSchema(schema) {
+    return schema;
+}
+function createTransform(transformer) {
+    return custom$1({
+        parse: (value) => {
+            const transformed = transformer(value, { addIssue: () => undefined, path: [] });
+            if (transformed !== null && typeof transformed === 'object' && typeof transformed.then === 'function') {
+                throw new Error('Use parseAsync for async transforms');
+            }
+            return transformed;
+        },
+        parseAsync: async (value) => {
+            const transformed = await Promise.resolve(transformer(value, { addIssue: () => undefined, path: [] }));
+            return transformed;
+        }
+    });
+}
+function createRefinement(predicate, message) {
+    return custom$1({
+        parse: (value) => {
+            const passed = predicate(value);
+            if (passed !== null && typeof passed === 'object' && typeof passed.then === 'function') {
+                throw new Error('Use parseAsync for async refinements');
+            }
+            if (!passed) {
+                throw new Error(messageFromRefinementParam(message) || 'Refinement check failed');
+            }
+            return value;
+        },
+        parseAsync: async (value) => {
+            if (!await predicate(value)) {
+                throw new Error(messageFromRefinementParam(message) || 'Refinement check failed');
+            }
+            return value;
+        }
+    });
+}
+function createSuperRefinement(refinement) {
+    return VldUnknown.create().superRefine(refinement);
+}
+function propertyCheck(property, schema, message) {
+    return custom$1({
+        parse: (value) => {
+            if (typeof value !== 'object' || value === null || !(property in value)) {
+                throw new Error(messageFromRefinementParam(message) || `Expected object with property "${property}"`);
+            }
+            const result = schema.safeParse(value[property]);
+            if (!result.success) {
+                throw new Error(messageFromRefinementParam(message) || result.error.message);
+            }
+            return value;
+        }
+    });
+}
+function getParsedType(value) {
+    if (value === null)
+        return 'null';
+    if (Array.isArray(value))
+        return 'array';
+    if (Number.isNaN(value))
+        return 'nan';
+    return typeof value;
+}
+const TimePrecision = {
+    Any: null,
+    Minute: -1,
+    Second: 0,
+    Millisecond: 3,
+    Microsecond: 6
+};
+const ZodFirstPartyTypeKind = {};
+const $brand = Symbol.for('vld_brand');
+const $input = Symbol.for('VldInput');
+const $output = Symbol.for('VldOutput');
+const ZodIssueCode = {
+    invalid_type: 'invalid_type',
+    too_big: 'too_big',
+    too_small: 'too_small',
+    invalid_format: 'invalid_format',
+    not_multiple_of: 'not_multiple_of',
+    unrecognized_keys: 'unrecognized_keys',
+    invalid_union: 'invalid_union',
+    invalid_key: 'invalid_key',
+    invalid_element: 'invalid_element',
+    invalid_value: 'invalid_value',
+    custom: 'custom'
+};
+const util = {
+    getParsedType,
+    propertyKeyTypes: new Set(['string', 'number', 'symbol']),
+    primitiveTypes: new Set(['string', 'number', 'bigint', 'boolean', 'symbol', 'undefined', 'null']),
+    assert: (condition, message = 'Assertion failed') => {
+        if (!condition) {
+            throw new Error(message);
+        }
+    },
+    assertNever: (value) => {
+        throw new Error(`Unexpected value: ${String(value)}`);
+    },
+    joinValues: (values, separator = ' | ') => values.map(value => JSON.stringify(value)).join(separator),
+    jsonStringifyReplacer: (_key, value) => typeof value === 'bigint' ? value.toString() : value,
+    nullish: (value) => value === null || value === undefined,
+    cached: (getter) => {
+        let initialized = false;
+        let value;
+        return () => {
+            if (!initialized) {
+                value = getter();
+                initialized = true;
+            }
+            return value;
+        };
+    }
+};
+const core = {
+    util,
+    regexes: REGEXES,
+    locales: localeNamespace,
+    NEVER: VldNever.create(),
+    TimePrecision,
+    ZodIssueCode,
+    globalRegistry,
+    config: configure,
+    getErrorMap: getGlobalErrorMap,
+    setErrorMap: setGlobalErrorMap,
+    parse: (schema, value) => schema.parse(value),
+    safeParse: (schema, value) => schema.safeParse(value),
+    parseAsync: (schema, value) => schema.parseAsync(value),
+    safeParseAsync: (schema, value) => schema.safeParseAsync(value)
+};
 /**
  * Main API object with factory methods for all validators
  */
@@ -769,9 +1276,11 @@ const v = {
     intersection: (first, second) => VldIntersection.create(first, second),
     discriminatedUnion: (discriminator, ...options) => VldDiscriminatedUnion.create(discriminator, [...options]),
     xor: (...options) => VldXor.create([...options]),
+    keyof: (schema) => schema.keyof(),
     // Literal and enum
     literal: (value) => VldLiteral.create(value),
     enum: (...values) => VldEnum.create(values),
+    nativeEnum: (enumObject) => VldEnum.create(enumValuesFromNativeEnum(enumObject)),
     // Special validators
     any: () => VldAny.create(),
     unknown: () => VldUnknown.create(),
@@ -782,19 +1291,62 @@ const v = {
     nan: () => VldNan.create(),
     // NEVER constant - Zod 4 API parity for use in transforms
     NEVER: VldNever.create(),
+    TimePrecision,
+    ZodIssueCode,
+    ZodFirstPartyTypeKind,
     // Utility validators
     optional: (validator) => VldOptional.create(validator),
     nullable: (validator) => VldNullable.create(validator),
     nullish: (validator) => VldNullish.create(validator),
     exactOptional: (validator) => VldExactOptional.create(validator),
+    nonoptional: (validator, message) => validator.refine((value) => value !== undefined, messageFromRefinementParam(message)),
+    catch: (validator, fallbackValue) => validator.catch(fallbackValue),
+    prefault: (validator, defaultValue) => validator.default(typeof defaultValue === 'function' ? defaultValue() : defaultValue).prefault(),
+    readonly: (validator) => validator.readonly(),
+    pipe: (first, second) => first.pipe(second),
+    clone: (schema) => cloneSchema(schema),
+    describe: (schemaOrDescription, description) => schemaOrDescription instanceof VldBase
+        ? schemaOrDescription.describe(description || '')
+        : VldUnknown.create().describe(schemaOrDescription),
+    meta: (schemaOrMetadata, metadata) => schemaOrMetadata instanceof VldBase
+        ? schemaOrMetadata.meta(metadata || {})
+        : VldUnknown.create().meta(schemaOrMetadata),
+    transform: (schemaOrTransformer, transformer) => schemaOrTransformer instanceof VldBase
+        ? schemaOrTransformer.transform(transformer || ((value) => value))
+        : createTransform(schemaOrTransformer),
+    overwrite: (transformer) => createTransform(transformer),
+    refine: (schemaOrPredicate, predicateOrMessage, message) => schemaOrPredicate instanceof VldBase
+        ? schemaOrPredicate.refine(predicateOrMessage, messageFromRefinementParam(message))
+        : createRefinement(schemaOrPredicate, predicateOrMessage),
+    check: (schemaOrPredicate, predicateOrMessage, message) => schemaOrPredicate instanceof VldBase
+        ? schemaOrPredicate.check(predicateOrMessage, messageFromRefinementParam(message))
+        : createRefinement(schemaOrPredicate, predicateOrMessage),
+    superRefine: (schemaOrRefinement, refinement) => schemaOrRefinement instanceof VldBase
+        ? schemaOrRefinement.superRefine(refinement || (() => undefined))
+        : createSuperRefinement(schemaOrRefinement),
+    property: propertyCheck,
+    instanceof: (constructor, message) => custom$1({
+        parse: (value) => {
+            if (!(value instanceof constructor)) {
+                throw new Error(messageFromRefinementParam(message) || `Expected instance of ${constructor.name || 'provided constructor'}`);
+            }
+            return value;
+        }
+    }),
+    config: configure,
+    setErrorMap: setGlobalErrorMap,
+    getErrorMap: getGlobalErrorMap,
+    core,
+    util,
+    locales: localeNamespace,
     // Recursive schemas
     lazy: (schemaGetter) => VldLazy.create(schemaGetter),
     // JSON validator
     json: (schema) => VldJson.create(schema),
     // Custom validator for type-safe user-defined schemas
-    custom: (options) => custom(options),
+    custom: (options) => custom$1(options),
     // File validator for file uploads
-    file: () => file(),
+    file: () => file$1(),
     // Function validator for function validation
     function: () => functionValidator(),
     // Preprocessing
@@ -808,48 +1360,175 @@ const v = {
         bigint: () => VldCoerceBigInt.create(),
     },
     // String format validators (Zod 4 parity)
-    email: (options) => email(options),
-    uuid: (options) => uuid(options),
-    uuidv4: () => uuidv4(),
-    hostname: () => hostname(),
-    emoji: () => emoji(),
-    base64: () => base64(),
-    base64url: () => base64url(),
-    hex: () => hex(),
-    jwt: () => jwt(),
-    nanoid: () => nanoid(),
-    cuid: () => cuid(),
-    cuid2: () => cuid2(),
-    ulid: () => ulid(),
-    ipv4: () => ipv4(),
-    ipv6: () => ipv6(),
-    mac: () => mac(),
-    cidrv4: () => cidrv4(),
-    cidrv6: () => cidrv6(),
-    e164: () => e164(),
-    hash: (algorithm) => hash(algorithm),
+    email: (options) => email$1(options),
+    url: () => VldString.create().url(),
+    uuid: (options) => uuid$1(options),
+    uuidv4: () => uuidv4$1(),
+    uuidv6: () => uuidv6$1(),
+    uuidv7: () => uuidv7$1(),
+    hostname: () => hostname$1(),
+    emoji: () => emoji$1(),
+    base64: () => base64$1(),
+    base64url: () => base64url$1(),
+    hex: () => hex$1(),
+    jwt: () => jwt$1(),
+    nanoid: () => nanoid$1(),
+    cuid: () => cuid$1(),
+    cuid2: () => cuid2$1(),
+    ulid: () => ulid$1(),
+    ipv4: () => ipv4$1(),
+    ipv6: () => ipv6$1(),
+    mac: () => mac$1(),
+    cidrv4: () => cidrv4$1(),
+    cidrv6: () => cidrv6$1(),
+    e164: () => e164$1(),
+    hash: (algorithm) => hash$1(algorithm),
     iso: {
-        date: () => iso.date(),
-        time: () => iso.time(),
-        dateTime: () => iso.dateTime(),
-        duration: () => iso.duration(),
+        date: () => iso$1.date(),
+        time: () => iso$1.time(),
+        dateTime: () => iso$1.dateTime(),
+        duration: () => iso$1.duration(),
     },
-    stringFormat: (name, validator) => stringFormat(name, validator),
+    stringFormat: (name, validator) => stringFormat$1(name, validator),
+    minLength: (value, message) => VldString.create().min(value, message),
+    maxLength: (value, message) => VldString.create().max(value, message),
+    length: (value, message) => VldString.create().length(value, message),
+    regex: (pattern, message) => VldString.create().regex(pattern, message),
+    startsWith: (value, message) => VldString.create().startsWith(value, message),
+    endsWith: (value, message) => VldString.create().endsWith(value, message),
+    includes: (value, message) => VldString.create().includes(value, message),
+    trim: () => VldString.create().trim(),
+    toLowerCase: () => VldString.create().toLowerCase(),
+    lowercase: () => VldString.create().toLowerCase(),
+    toUpperCase: () => VldString.create().toUpperCase(),
+    uppercase: () => VldString.create().toUpperCase(),
+    gt: (value, message) => VldNumber.create().gt(value, message),
+    gte: (value, message) => VldNumber.create().gte(value, message),
+    lt: (value, message) => VldNumber.create().lt(value, message),
+    lte: (value, message) => VldNumber.create().lte(value, message),
+    positive: (message) => VldNumber.create().positive(message),
+    negative: (message) => VldNumber.create().negative(message),
+    nonnegative: (message) => VldNumber.create().nonnegative(message),
+    nonpositive: (message) => VldNumber.create().nonpositive(message),
+    multipleOf: (value, message) => VldNumber.create().multipleOf(value, message),
+    minSize: (value, message) => VldString.create().min(value, message),
+    maxSize: (value, message) => VldString.create().max(value, message),
+    size: (value, message) => VldString.create().length(value, message),
+    normalize: (form) => VldString.create().transform(value => value.normalize(form)),
+    slugify: () => VldString.create().transform(value => value
+        .normalize('NFKD')
+        .replace(/[\u0300-\u036f]/g, '')
+        .toLowerCase()
+        .trim()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '')),
+    mime: (types, message) => VldFile.create().mime(types, message),
     // Zod v4 parity string formats
-    xid: () => xid(),
-    guid: () => guid(),
-    httpUrl: () => httpUrl(),
+    xid: () => xid$1(),
+    guid: () => guid$1(),
+    httpUrl: () => httpUrl$1(),
+    ksuid: () => ksuid$1(),
+    regexes: REGEXES,
     // Template literal validator
-    templateLiteral: (...components) => templateLiteral(...components),
+    templateLiteral: (...components) => templateLiteral$1(...components),
     // Codec validators (binary data validators)
     base64Bytes: () => VldBase64.create(),
     hexBytes: () => VldHex.create(),
     uint8Array: () => VldUint8Array.create(),
     // Codec factory
     codec: (inputValidator, outputValidator, transform) => VldCodec.create(inputValidator, outputValidator, transform),
+    invertCodec: (codec) => codec.invert(),
     // Promise validator (Zod v4 parity)
-    promise: (inner) => promise(inner)
+    promise: (inner) => promise$1(inner),
+    // Root parse helpers (Zod v4 parity)
+    parse: (schema, value) => schema.parse(value),
+    safeParse: (schema, value) => schema.safeParse(value),
+    parseAsync: (schema, value) => schema.parseAsync(value),
+    safeParseAsync: (schema, value) => schema.safeParseAsync(value),
+    decode: (schema, value) => schema.parse(value),
+    safeDecode: (schema, value) => schema.safeParse(value),
+    decodeAsync: (schema, value) => schema.parseAsync(value),
+    safeDecodeAsync: (schema, value) => schema.safeParseAsync(value),
+    encode: (schema, value) => isCodec(schema)
+        ? schema.encode(value)
+        : schema.parse(value),
+    safeEncode: (schema, value) => isCodec(schema)
+        ? schema.safeEncode(value)
+        : schema.safeParse(value),
+    encodeAsync: async (schema, value) => isCodec(schema)
+        ? schema.encodeAsync(value)
+        : schema.parseAsync(value),
+    safeEncodeAsync: async (schema, value) => isCodec(schema)
+        ? schema.safeEncodeAsync(value)
+        : schema.safeParseAsync(value),
+    formatError: (error) => {
+        const formatted = { _errors: [] };
+        if (error instanceof VldError) {
+            for (const issue of error.issues) {
+                addFormattedIssue(formatted, issue.path, issue.message);
+            }
+            return formatted;
+        }
+        formatted._errors.push(toErrorMessage(error));
+        return formatted;
+    },
+    treeifyError: treeifyError,
+    prettifyError: prettifyError,
+    flattenError: flattenError,
+    toJSONSchema: toJSONSchema
 };
+/**
+ * Zod-compatible namespace alias.
+ */
+const z = v;
+/**
+ * Zod-compatible root-level factory aliases.
+ *
+ * VLD's primary API remains `v.*`, but Zod exposes most factories directly
+ * from the package root. Re-exporting these aliases makes migration less
+ * intrusive without changing existing behavior.
+ */
+const { string, number, int, int32, uint32, uint64, int64, float32, float64, boolean, date, bigint, symbol, stringbool, array, object, strictObject, looseObject, tuple, record, partialRecord, looseRecord, set, union, intersection, discriminatedUnion, xor, keyof, literal, nativeEnum, any, unknown, nan, optional, nullable, nullish, exactOptional, nonoptional, readonly, pipe, clone, describe, meta, transform, overwrite, refine, check, superRefine, property, config, setErrorMap, getErrorMap, locales, lazy, json, custom, file, preprocess, coerce, email, url, uuid, uuidv4, uuidv6, uuidv7, hostname, emoji, base64, base64url, hex, jwt, nanoid, cuid, cuid2, ulid, ipv4, ipv6, mac, cidrv4, cidrv6, e164, hash, iso, stringFormat, normalize, slugify, mime, xid, guid, httpUrl, ksuid, regexes, templateLiteral, base64Bytes, hexBytes, uint8Array, codec, promise, prefault, parse, safeParse, parseAsync, safeParseAsync, decode, safeDecode, decodeAsync, safeDecodeAsync, encode, safeEncode, encodeAsync, safeEncodeAsync, formatError, NEVER } = v;
+const catchFactory = v.catch;
+const enumFactory = v.enum;
+const functionFactory = v.function;
+const instanceOfFactory = v.instanceof;
+const mapFactory = v.map;
+const neverFactory = v.never;
+const nullFactory = v.null;
+const undefinedFactory = v.undefined;
+const voidFactory = v.void;
+const defaultFactory = v;
+const zodStringFactory = VldString;
+function map(first, second) {
+    if (first instanceof VldBase && second instanceof VldBase) {
+        return v.map(first, second);
+    }
+    return map$1(first, second);
+}
+const minLength = (value, message) => v.string().min(value, message);
+const maxLength = (value, message) => v.string().max(value, message);
+const length = (value, message) => v.string().length(value, message);
+const regex = (pattern, message) => v.string().regex(pattern, message);
+const startsWith = (value, message) => v.string().startsWith(value, message);
+const endsWith = (value, message) => v.string().endsWith(value, message);
+const includes = (value, message) => v.string().includes(value, message);
+const trim = () => v.string().trim();
+const toLowerCase = () => v.string().toLowerCase();
+const lowercase = toLowerCase;
+const toUpperCase = () => v.string().toUpperCase();
+const uppercase = toUpperCase;
+const gt = (value, message) => v.number().gt(value, message);
+const gte = (value, message) => v.number().gte(value, message);
+const lt = (value, message) => v.number().lt(value, message);
+const lte = (value, message) => v.number().lte(value, message);
+const positive = (message) => v.number().positive(message);
+const negative = (message) => v.number().negative(message);
+const nonnegative = (message) => v.number().nonnegative(message);
+const nonpositive = (message) => v.number().nonpositive(message);
+const multipleOf = (value, message) => v.number().multipleOf(value, message);
+const minSize = minLength;
+const maxSize = maxLength;
+const size = length;
 
-export { VldIntersection, createLogger, createNoOpLogger, v as default, disableLogging, enableDebug, fromJSONSchema, getLogger, initLogger, setLogLevel, toJSONSchema, v };
-//# sourceMappingURL=index.js.map
+export { $brand, $input, $output, NEVER, TimePrecision, VldBase, VldError, VldIntersection, VldAny as ZodAny, VldArray as ZodArray, VldBigInt as ZodBigInt, VldBigInt as ZodBigIntFormat, VldBoolean as ZodBoolean, VldCodec as ZodCodec, VldDate as ZodDate, VldDiscriminatedUnion as ZodDiscriminatedUnion, VldEnum as ZodEnum, VldError as ZodError, VldExactOptional as ZodExactOptional, VldFile as ZodFile, ZodFirstPartyTypeKind, VldIntersection as ZodIntersection, ZodIssueCode, VldJson as ZodJSON, VldLazy as ZodLazy, VldLiteral as ZodLiteral, VldMap as ZodMap, VldNan as ZodNaN, VldNever as ZodNever, VldNull as ZodNull, VldNullable as ZodNullable, VldNumber as ZodNumber, VldNumber as ZodNumberFormat, VldObject as ZodObject, VldOptional as ZodOptional, VldPreprocess as ZodPreprocess, VldError as ZodRealError, VldRecord as ZodRecord, VldSet as ZodSet, VldString as ZodString, VldSymbol as ZodSymbol, VldTuple as ZodTuple, VldBase as ZodType, VldUndefined as ZodUndefined, VldUnion as ZodUnion, VldUnknown as ZodUnknown, VldVoid as ZodVoid, VldXor as ZodXor, zodStringFactory as _ZodString, defaultFactory as _default, functionFactory as _function, any, array, base64, base64Bytes, base64url, bigint, boolean, catchFactory as catch, check, cidrv4, cidrv6, clone, codec, coerce, config, core, createLogger, createNoOpLogger, cuid, cuid2, custom, date, decode, decodeAsync, v as default, describe, disableLogging, discriminatedUnion, e164, email, emoji, enableDebug, encode, encodeAsync, endsWith, enumFactory as enum, exactOptional, file, flattenError, float32, float64, formatError, fromJSONSchema, functionFactory as function, getErrorMap, getLogger, globalRegistry, gt, gte, guid, hash, hex, hexBytes, hostname, httpUrl, includes, initLogger, instanceOfFactory as instanceof, int, int32, int64, intersection, ipv4, ipv6, iso, json, jwt, keyof, ksuid, lazy, length, literal, locales, looseObject, looseRecord, lowercase, lt, lte, mac, map, mapFactory as mapSchema, maxLength, maxSize, meta, mime, minLength, minSize, multipleOf, nan, nanoid, nativeEnum, negative, neverFactory as never, nonnegative, nonoptional, nonpositive, normalize, nullFactory as null, nullable, nullish, number, object, optional, overwrite, parse, parseAsync, partialRecord, pipe, positive, prefault, preprocess, prettifyError, promise, property, readonly, record, refine, regex, regexes, safeDecode, safeDecodeAsync, safeEncode, safeEncodeAsync, safeParse, safeParseAsync, set, setErrorMap, setLogLevel, size, slugify, startsWith, strictObject, string, stringFormat, stringbool, superRefine, symbol, templateLiteral, toJSONSchema, toLowerCase, toUpperCase, transform, treeifyError, trim, tuple, uint32, uint64, uint8Array, ulid, undefinedFactory as undefined, union, unknown, uppercase, url, util, uuid, uuidv4, uuidv6, uuidv7, v, voidFactory as void, xid, xor, z };