@oxog/vld 2.0.2 → 2.1.0

package/dist/index.d.ts

@@ -13,58 +13,206 @@
  * - Colored console output for better debugging
  * - Debug logging system
  */
-import { VldBase } from './validators/base';
-import { VldString } from './validators/string';
-import { VldNumber } from './validators/number';
-import { VldBoolean } from './validators/boolean';
-import { VldDate } from './validators/date';
-import { VldStringBool } from './validators/string-bool';
-import { VldArray } from './validators/array';
-import { VldObject } from './validators/object';
-import { VldUnion } from './validators/union';
-import { VldLiteral } from './validators/literal';
-import { VldBigInt } from './validators/bigint';
-import { VldSymbol } from './validators/symbol';
-import { VldTuple } from './validators/tuple';
-import { VldRecord } from './validators/record';
-import { VldSet } from './validators/set';
-import { VldMap } from './validators/map';
-import { VldEnum } from './validators/enum';
-import { VldIntersection } from './validators/intersection';
-import { VldAny } from './validators/any';
-import { VldUnknown } from './validators/unknown';
-import { VldVoid } from './validators/void';
-import { VldNever } from './validators/never';
-import { VldNull } from './validators/null';
-import { VldUndefined } from './validators/undefined';
-import { VldNan } from './validators/nan';
-import { VldLazy } from './validators/lazy';
-import { VldDiscriminatedUnion } from './validators/discriminated-union';
-import { VldXor } from './validators/xor';
-import { VldJson } from './validators/json';
-import { type CustomValidatorOptions } from './validators/custom';
-import { VldPreprocess } from './validators/base';
-import { VldOptional } from './validators/base';
-import { VldNullable } from './validators/base';
-import { VldNullish } from './validators/base';
-import { VldCodec } from './validators/codec';
-import { VldBase64 } from './validators/base64';
-import { VldHex } from './validators/hex';
-import { VldUint8Array } from './validators/uint8array';
-import { VldCoerceString } from './coercion/string';
-import { VldCoerceNumber } from './coercion/number';
-import { VldCoerceBoolean } from './coercion/boolean';
-import { VldCoerceDate } from './coercion/date';
-import { VldCoerceBigInt } from './coercion/bigint';
-export type { ParseResult } from './validators/base';
-export type { Infer, Input, Output } from './validators';
-export { VldBase } from './validators/base';
-export { VldIntersection } from './validators/intersection';
-export { setLocale, getLocale, getMessages, type Locale } from './locales';
-export { VldError, VldIssue, VldErrorCode, VldErrorTree, VldFlattenedError, VldErrorJSON, treeifyError, prettifyError, prettifyErrorColored, prettifyErrorPlain, flattenError, type PrettifyOptions } from './errors';
-export { base64ToUint8Array, uint8ArrayToBase64, uint8ArrayToBase64Url, hexToUint8Array, uint8ArrayToHex, stringToUint8Array, uint8ArrayToString } from './utils/codec-utils';
-export type { CodecTransform } from './validators/codec';
-export { stringToNumber, stringToInt, stringToBigInt, numberToBigInt, stringToBoolean, isoDatetimeToDate, epochSecondsToDate, epochMillisToDate, jsonCodec, stringToURL, stringToHttpURL, uriComponent, base64ToBytes, base64UrlToBytes, base64urlToBytes, hexToBytes, hexLowerToBytes, utf8ToBytes, bytesToUtf8, base64Json, jwtPayload } from './codecs';
+import { VldBase, type ErrorParam, type ParseResult, type SchemaMetadata, type SuperRefineContext } from './validators/base.js';
+import type { Infer, Input, Output } from './validators/index.js';
+import { VldString } from './validators/string.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 { VldTemplateLiteral } from './validators/template-literal.js';
+import { VldCustom, type CustomValidatorOptions } from './validators/custom.js';
+import { VldFile } from './validators/file.js';
+import { VldFunction } from './validators/function.js';
+import { VldBrand, VldCatch, VldDefault, VldExactOptional, VldMeta, VldNullable, VldNullish, VldOptional, VldPipe, VldPrefault, VldPreprocess, VldReadonly, VldRefine, VldTransform } from './validators/base.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 { VldPromise } from './validators/promise.js';
+import type { Result } from './compat/result.js';
+import * as localeNamespace from './locales/index.js';
+import { VldCoerceString } from './coercion/string.js';
+import { VldCoerceNumber } from './coercion/number.js';
+import { VldCoerceBoolean } from './coercion/boolean.js';
+import { VldCoerceDate } from './coercion/date.js';
+import { VldCoerceBigInt } from './coercion/bigint.js';
+import { flattenError as flattenErrorFn, prettifyError as prettifyErrorFn, treeifyError as treeifyErrorFn } from './errors.js';
+import { toJSONSchema as toJSONSchemaFn } from './utils/json-schema.js';
+import * as stringFormats from './validators/string-formats.js';
+type NativeEnumLike = Record<string, string | number>;
+type Constructor<T = unknown> = abstract new (...args: any[]) => T;
+type RefinementMessage = string | {
+    error?: string;
+    message?: string;
+};
+type GlobalConfig = {
+    customError?: unknown;
+    errorMap?: unknown;
+    locale?: unknown;
+    [key: string]: unknown;
+};
+declare function configure(config?: GlobalConfig): GlobalConfig;
+declare function setGlobalErrorMap(errorMap: unknown): void;
+declare function getGlobalErrorMap(): unknown;
+export interface FormattedError {
+    _errors: string[];
+    [key: string]: FormattedError | string[];
+}
+declare function propertyCheck<K extends string, T>(property: K, schema: VldBase<unknown, T>, message?: RefinementMessage): VldBase<unknown, {
+    [P in K]: T;
+}>;
+declare function getParsedType(value: unknown): string;
+export declare const TimePrecision: {
+    readonly Any: null;
+    readonly Minute: -1;
+    readonly Second: 0;
+    readonly Millisecond: 3;
+    readonly Microsecond: 6;
+};
+export declare const ZodFirstPartyTypeKind: {};
+export declare const $brand: unique symbol;
+export declare const $input: unique symbol;
+export declare const $output: unique symbol;
+export declare const ZodIssueCode: {
+    readonly invalid_type: "invalid_type";
+    readonly too_big: "too_big";
+    readonly too_small: "too_small";
+    readonly invalid_format: "invalid_format";
+    readonly not_multiple_of: "not_multiple_of";
+    readonly unrecognized_keys: "unrecognized_keys";
+    readonly invalid_union: "invalid_union";
+    readonly invalid_key: "invalid_key";
+    readonly invalid_element: "invalid_element";
+    readonly invalid_value: "invalid_value";
+    readonly custom: "custom";
+};
+export declare const util: {
+    readonly getParsedType: typeof getParsedType;
+    readonly propertyKeyTypes: Set<string>;
+    readonly primitiveTypes: Set<string>;
+    readonly assert: (condition: unknown, message?: string) => asserts condition;
+    readonly assertNever: (value: never) => never;
+    readonly joinValues: (values: readonly unknown[], separator?: string) => string;
+    readonly jsonStringifyReplacer: (_key: string, value: unknown) => unknown;
+    readonly nullish: (value: unknown) => value is null | undefined;
+    readonly cached: <T>(getter: () => T) => (() => T);
+};
+export declare const core: {
+    readonly util: {
+        readonly getParsedType: typeof getParsedType;
+        readonly propertyKeyTypes: Set<string>;
+        readonly primitiveTypes: Set<string>;
+        readonly assert: (condition: unknown, message?: string) => asserts condition;
+        readonly assertNever: (value: never) => never;
+        readonly joinValues: (values: readonly unknown[], separator?: string) => string;
+        readonly jsonStringifyReplacer: (_key: string, value: unknown) => unknown;
+        readonly nullish: (value: unknown) => value is null | undefined;
+        readonly cached: <T>(getter: () => T) => (() => T);
+    };
+    readonly regexes: {
+        readonly email: RegExp;
+        readonly uuid: RegExp;
+        readonly uuidv4: RegExp;
+        readonly uuidv6: RegExp;
+        readonly uuidv7: RegExp;
+        readonly hostname: RegExp;
+        readonly emoji: RegExp;
+        readonly base64: RegExp;
+        readonly base64url: RegExp;
+        readonly hex: RegExp;
+        readonly jwt: RegExp;
+        readonly nanoid: RegExp;
+        readonly cuid: RegExp;
+        readonly cuid2: RegExp;
+        readonly ulid: RegExp;
+        readonly ipv4: RegExp;
+        readonly ipv6: RegExp;
+        readonly mac: RegExp;
+        readonly cidrv4: RegExp;
+        readonly cidrv6: RegExp;
+        readonly e164: RegExp;
+        readonly isoDate: RegExp;
+        readonly isoTime: RegExp;
+        readonly isoDateTime: RegExp;
+        readonly md5: RegExp;
+        readonly sha1: RegExp;
+        readonly sha256: RegExp;
+        readonly sha384: RegExp;
+        readonly sha512: RegExp;
+        readonly xid: RegExp;
+        readonly guid: RegExp;
+        readonly httpUrl: RegExp;
+        readonly ksuid: RegExp;
+    };
+    readonly locales: typeof localeNamespace;
+    readonly NEVER: VldNever;
+    readonly TimePrecision: {
+        readonly Any: null;
+        readonly Minute: -1;
+        readonly Second: 0;
+        readonly Millisecond: 3;
+        readonly Microsecond: 6;
+    };
+    readonly ZodIssueCode: {
+        readonly invalid_type: "invalid_type";
+        readonly too_big: "too_big";
+        readonly too_small: "too_small";
+        readonly invalid_format: "invalid_format";
+        readonly not_multiple_of: "not_multiple_of";
+        readonly unrecognized_keys: "unrecognized_keys";
+        readonly invalid_union: "invalid_union";
+        readonly invalid_key: "invalid_key";
+        readonly invalid_element: "invalid_element";
+        readonly invalid_value: "invalid_value";
+        readonly custom: "custom";
+    };
+    readonly globalRegistry: import("./registry.js").SchemaRegistry<SchemaMetadata>;
+    readonly config: typeof configure;
+    readonly getErrorMap: typeof getGlobalErrorMap;
+    readonly setErrorMap: typeof setGlobalErrorMap;
+    readonly parse: <T>(schema: VldBase<unknown, T>, value: unknown) => T;
+    readonly safeParse: <T>(schema: VldBase<unknown, T>, value: unknown) => ParseResult<T>;
+    readonly parseAsync: <T>(schema: VldBase<unknown, T>, value: unknown) => Promise<T>;
+    readonly safeParseAsync: <T>(schema: VldBase<unknown, T>, value: unknown) => Promise<ParseResult<T>>;
+};
+export type { ParseResult, StandardSchemaV1, StandardSchemaV1FailureResult, StandardSchemaV1Issue, StandardSchemaV1Options, StandardSchemaV1PathSegment, StandardSchemaV1Props, StandardSchemaV1Result, StandardSchemaV1SuccessResult, StandardTypedV1, StandardTypedV1Props, StandardTypedV1Types } from './validators/base.js';
+export type { Infer, Input, Output } from './validators/index.js';
+export { VldBase } from './validators/base.js';
+export { VldIntersection } from './validators/intersection.js';
+export { VldMeta, type SchemaMetadata } from './validators/base.js';
+export { VldBase as ZodType, VldAny as ZodAny, VldArray as ZodArray, VldBigInt as ZodBigInt, VldBigInt as ZodBigIntFormat, VldBoolean as ZodBoolean, VldBrand as ZodBranded, VldCatch as ZodCatch, VldCodec as ZodCodec, VldCustom as ZodCustom, VldCustom as ZodSuccess, VldDate as ZodDate, VldDefault as ZodDefault, VldDiscriminatedUnion as ZodDiscriminatedUnion, VldEnum as ZodEnum, VldExactOptional as ZodExactOptional, VldFile as ZodFile, VldFunction as ZodFunction, VldIntersection as ZodIntersection, VldJson as ZodJSON, VldLazy as ZodLazy, VldLiteral as ZodLiteral, VldMap as ZodMap, VldMeta as ZodMeta, VldNan as ZodNaN, VldNever as ZodNever, VldNull as ZodNull, VldNullable as ZodNullable, VldNumber as ZodNumber, VldNumber as ZodNumberFormat, VldObject as ZodObject, VldOptional as ZodOptional, VldPipe as ZodPipe, VldPrefault as ZodPrefault, VldPreprocess as ZodPreprocess, VldPromise as ZodPromise, VldReadonly as ZodReadonly, VldRecord as ZodRecord, VldRefine as ZodNonOptional, VldSet as ZodSet, VldString as ZodString, VldSymbol as ZodSymbol, VldTemplateLiteral as ZodTemplateLiteral, VldTuple as ZodTuple, VldTransform as ZodTransform, VldUndefined as ZodUndefined, VldUnion as ZodUnion, VldUnknown as ZodUnknown, VldVoid as ZodVoid, VldXor as ZodXor };
+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 { VldError as ZodError, VldError as ZodRealError } from './errors.js';
+export { registry, globalRegistry, type SchemaRegistry } from './registry.js';
+export { setLocale, setLocaleAsync, registerLocale, getLocale, getMessages, isLocaleLoaded, getSupportedLocales, isLocaleSupported, type Locale } from './locales/index.js';
+export { VldError, VldIssue, VldErrorCode, VldErrorTree, VldFlattenedError, VldErrorJSON, treeifyError, prettifyError, prettifyErrorColored, prettifyErrorPlain, flattenError, type PrettifyOptions } from './errors.js';
+export { base64ToUint8Array, uint8ArrayToBase64, uint8ArrayToBase64Url, hexToUint8Array, uint8ArrayToHex, stringToUint8Array, uint8ArrayToString } from './utils/codec-utils.js';
+export type { CodecTransform } from './validators/codec.js';
+export { invertCodec, stringToNumber, stringToInt, stringToBigInt, numberToBigInt, stringToBoolean, isoDatetimeToDate, epochSecondsToDate, epochMillisToDate, jsonCodec, stringToURL, stringToHttpURL, uriComponent, base64ToBytes, base64UrlToBytes, base64urlToBytes, hexToBytes, hexLowerToBytes, utf8ToBytes, bytesToUtf8, base64Json, jwtPayload } from './codecs/index.js';
 /**
  * Main API object with factory methods for all validators
  */
@@ -73,6 +221,11 @@ export declare const v: {
     number: () => VldNumber;
     int: () => VldNumber;
     int32: () => VldNumber;
+    uint32: () => VldNumber;
+    uint64: () => VldNumber;
+    int64: () => VldNumber;
+    float32: () => VldNumber;
+    float64: () => VldNumber;
     boolean: () => VldBoolean;
     date: () => VldDate;
     bigint: () => VldBigInt;
@@ -96,8 +249,10 @@ export declare const v: {
     intersection: <A, B>(first: VldBase<unknown, A>, second: VldBase<unknown, B>) => VldIntersection<A, B>;
     discriminatedUnion: <K extends string, T extends readonly VldBase<any, any>[]>(discriminator: K, ...options: T) => VldDiscriminatedUnion<K, any>;
     xor: <T extends readonly VldBase<any, any>[]>(...options: T) => VldXor<any>;
+    keyof: <T extends Record<string, any>>(schema: VldObject<T>) => VldEnum<[string, ...string[]]>;
     literal: <T extends string | number | boolean | null | undefined>(value: T) => VldLiteral<T>;
-    enum: <T extends readonly [string, ...string[]]>(...values: T) => VldEnum<any>;
+    enum: <T extends readonly [string | number, ...(string | number)[]]>(...values: T) => VldEnum<any>;
+    nativeEnum: <T extends NativeEnumLike>(enumObject: T) => VldEnum<any>;
     any: () => VldAny;
     unknown: () => VldUnknown;
     void: () => VldVoid;
@@ -106,14 +261,144 @@ export declare const v: {
     undefined: () => VldUndefined;
     nan: () => VldNan;
     NEVER: VldNever;
+    TimePrecision: {
+        readonly Any: null;
+        readonly Minute: -1;
+        readonly Second: 0;
+        readonly Millisecond: 3;
+        readonly Microsecond: 6;
+    };
+    ZodIssueCode: {
+        readonly invalid_type: "invalid_type";
+        readonly too_big: "too_big";
+        readonly too_small: "too_small";
+        readonly invalid_format: "invalid_format";
+        readonly not_multiple_of: "not_multiple_of";
+        readonly unrecognized_keys: "unrecognized_keys";
+        readonly invalid_union: "invalid_union";
+        readonly invalid_key: "invalid_key";
+        readonly invalid_element: "invalid_element";
+        readonly invalid_value: "invalid_value";
+        readonly custom: "custom";
+    };
+    ZodFirstPartyTypeKind: {};
     optional: <T>(validator: VldBase<unknown, T>) => VldOptional<unknown, T>;
     nullable: <T>(validator: VldBase<unknown, T>) => VldNullable<unknown, T>;
     nullish: <T>(validator: VldBase<unknown, T>) => VldNullish<unknown, T>;
+    exactOptional: <T>(validator: VldBase<unknown, T>) => VldExactOptional<unknown, T>;
+    nonoptional: <T>(validator: VldBase<unknown, T | undefined>, message?: RefinementMessage) => VldRefine<unknown, T | undefined, Exclude<T, undefined>>;
+    catch: <T>(validator: VldBase<unknown, T>, fallbackValue: T) => VldCatch<unknown, T>;
+    prefault: <T>(validator: VldBase<unknown, T>, defaultValue: T | (() => T)) => VldPrefault<unknown, T>;
+    readonly: <T>(validator: VldBase<unknown, T>) => VldReadonly<unknown, T>;
+    pipe: <TInput, TIntermediate, TOutput>(first: VldBase<TInput, TIntermediate>, second: VldBase<TIntermediate, TOutput>) => VldPipe<TInput, TIntermediate, TOutput>;
+    clone: <T extends VldBase<any, any>>(schema: T) => T;
+    describe: <TInput, TOutput>(schemaOrDescription: VldBase<TInput, TOutput> | string, description?: string) => VldMeta<unknown, unknown>;
+    meta: <TInput, TOutput>(schemaOrMetadata: VldBase<TInput, TOutput> | Partial<SchemaMetadata>, metadata?: Partial<SchemaMetadata>) => VldMeta<unknown, unknown>;
+    transform: <TInput = unknown, TOutput = TInput>(schemaOrTransformer: VldBase<unknown, TInput> | ((value: TInput, ctx?: SuperRefineContext) => TOutput | Promise<TOutput>), transformer?: (value: TInput) => TOutput | Promise<TOutput>) => VldTransform<unknown, TInput, TOutput> | VldBase<TInput, Awaited<TOutput>>;
+    overwrite: <T>(transformer: (value: T) => T) => VldBase<T, Awaited<T>>;
+    refine: <T = unknown>(schemaOrPredicate: VldBase<unknown, T> | ((value: T) => boolean | Promise<boolean>), predicateOrMessage?: ((value: T) => boolean | Promise<boolean>) | RefinementMessage, message?: RefinementMessage) => VldBase<unknown, T>;
+    check: <T = unknown>(schemaOrPredicate: VldBase<unknown, T> | ((value: T) => boolean | Promise<boolean>), predicateOrMessage?: ((value: T) => boolean | Promise<boolean>) | RefinementMessage, message?: RefinementMessage) => VldBase<unknown, T>;
+    superRefine: <T = unknown>(schemaOrRefinement: VldBase<unknown, T> | ((value: T, ctx: SuperRefineContext) => void | Promise<void>), refinement?: (value: T, ctx: SuperRefineContext) => void | Promise<void>) => VldBase<unknown, T>;
+    property: typeof propertyCheck;
+    instanceof: <T>(constructor: Constructor<T>, message?: RefinementMessage) => VldCustom<T>;
+    config: typeof configure;
+    setErrorMap: typeof setGlobalErrorMap;
+    getErrorMap: typeof getGlobalErrorMap;
+    core: {
+        readonly util: {
+            readonly getParsedType: typeof getParsedType;
+            readonly propertyKeyTypes: Set<string>;
+            readonly primitiveTypes: Set<string>;
+            readonly assert: (condition: unknown, message?: string) => asserts condition;
+            readonly assertNever: (value: never) => never;
+            readonly joinValues: (values: readonly unknown[], separator?: string) => string;
+            readonly jsonStringifyReplacer: (_key: string, value: unknown) => unknown;
+            readonly nullish: (value: unknown) => value is null | undefined;
+            readonly cached: <T>(getter: () => T) => (() => T);
+        };
+        readonly regexes: {
+            readonly email: RegExp;
+            readonly uuid: RegExp;
+            readonly uuidv4: RegExp;
+            readonly uuidv6: RegExp;
+            readonly uuidv7: RegExp;
+            readonly hostname: RegExp;
+            readonly emoji: RegExp;
+            readonly base64: RegExp;
+            readonly base64url: RegExp;
+            readonly hex: RegExp;
+            readonly jwt: RegExp;
+            readonly nanoid: RegExp;
+            readonly cuid: RegExp;
+            readonly cuid2: RegExp;
+            readonly ulid: RegExp;
+            readonly ipv4: RegExp;
+            readonly ipv6: RegExp;
+            readonly mac: RegExp;
+            readonly cidrv4: RegExp;
+            readonly cidrv6: RegExp;
+            readonly e164: RegExp;
+            readonly isoDate: RegExp;
+            readonly isoTime: RegExp;
+            readonly isoDateTime: RegExp;
+            readonly md5: RegExp;
+            readonly sha1: RegExp;
+            readonly sha256: RegExp;
+            readonly sha384: RegExp;
+            readonly sha512: RegExp;
+            readonly xid: RegExp;
+            readonly guid: RegExp;
+            readonly httpUrl: RegExp;
+            readonly ksuid: RegExp;
+        };
+        readonly locales: typeof localeNamespace;
+        readonly NEVER: VldNever;
+        readonly TimePrecision: {
+            readonly Any: null;
+            readonly Minute: -1;
+            readonly Second: 0;
+            readonly Millisecond: 3;
+            readonly Microsecond: 6;
+        };
+        readonly ZodIssueCode: {
+            readonly invalid_type: "invalid_type";
+            readonly too_big: "too_big";
+            readonly too_small: "too_small";
+            readonly invalid_format: "invalid_format";
+            readonly not_multiple_of: "not_multiple_of";
+            readonly unrecognized_keys: "unrecognized_keys";
+            readonly invalid_union: "invalid_union";
+            readonly invalid_key: "invalid_key";
+            readonly invalid_element: "invalid_element";
+            readonly invalid_value: "invalid_value";
+            readonly custom: "custom";
+        };
+        readonly globalRegistry: import("./registry.js").SchemaRegistry<SchemaMetadata>;
+        readonly config: typeof configure;
+        readonly getErrorMap: typeof getGlobalErrorMap;
+        readonly setErrorMap: typeof setGlobalErrorMap;
+        readonly parse: <T>(schema: VldBase<unknown, T>, value: unknown) => T;
+        readonly safeParse: <T>(schema: VldBase<unknown, T>, value: unknown) => ParseResult<T>;
+        readonly parseAsync: <T>(schema: VldBase<unknown, T>, value: unknown) => Promise<T>;
+        readonly safeParseAsync: <T>(schema: VldBase<unknown, T>, value: unknown) => Promise<ParseResult<T>>;
+    };
+    util: {
+        readonly getParsedType: typeof getParsedType;
+        readonly propertyKeyTypes: Set<string>;
+        readonly primitiveTypes: Set<string>;
+        readonly assert: (condition: unknown, message?: string) => asserts condition;
+        readonly assertNever: (value: never) => never;
+        readonly joinValues: (values: readonly unknown[], separator?: string) => string;
+        readonly jsonStringifyReplacer: (_key: string, value: unknown) => unknown;
+        readonly nullish: (value: unknown) => value is null | undefined;
+        readonly cached: <T>(getter: () => T) => (() => T);
+    };
+    locales: typeof localeNamespace;
     lazy: <T>(schemaGetter: () => VldBase<unknown, T>) => VldLazy<unknown, T>;
     json: <T = unknown>(schema?: VldBase<unknown, T>) => VldJson<T>;
-    custom: <TOutput = unknown>(options: CustomValidatorOptions<TOutput>) => import("./validators").VldCustom<TOutput>;
-    file: () => import("./validators").VldFile;
-    function: () => import("./validators").VldFunction;
+    custom: <TOutput = unknown>(options: CustomValidatorOptions<TOutput>) => VldCustom<TOutput>;
+    file: () => VldFile;
+    function: () => VldFunction;
     preprocess: <TInput, TOutput>(preprocessor: (input: unknown) => unknown, schema: VldBase<TInput, TOutput>) => VldPreprocess<TInput, TOutput>;
     coerce: {
         string: () => VldCoerceString;
@@ -124,561 +409,824 @@ export declare const v: {
     };
     email: (options?: {
         pattern?: RegExp;
-    }) => {
-        readonly _format: string;
-        readonly _validator: (val: string) => boolean;
-        readonly _errorMessage?: string | undefined;
-        parse(value: unknown): string;
-        safeParse(value: unknown): import("./validators").ParseResult<string>;
-        isValid(value: unknown): boolean;
-        parseOrDefault(value: unknown, defaultValue: string): string;
-        refine<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
-        refine(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
-        superRefine(refinement: (value: string, ctx: import("./validators").SuperRefineContext) => void | Promise<void>): import("./validators").VldSuperRefine<unknown, string>;
-        transform<TTransformed>(transformer: (value: string) => TTransformed): import("./validators").VldTransform<unknown, string, TTransformed>;
-        default(defaultValue: string): import("./validators").VldDefault<unknown, string>;
-        catch(fallbackValue: string): import("./validators").VldCatch<unknown, string>;
-        optional(): VldOptional<unknown, string>;
-        nullable(): VldNullable<unknown, string>;
-        nullish(): VldNullish<unknown, string>;
-        pipe<TNextOutput>(next: VldBase<string, TNextOutput>): import("./validators").VldPipe<unknown, string, TNextOutput>;
-        readonly(): import("./validators").VldReadonly<unknown, string>;
-        brand<TBrand extends string>(): import("./validators").VldBrand<unknown, string, TBrand>;
-        apply<TNewOutput>(fn: (schema: /*elided*/ any) => VldBase<unknown, TNewOutput>): VldBase<unknown, TNewOutput>;
-    };
+    }) => stringFormats.VldStringFormat;
+    url: () => VldString;
     uuid: (options?: {
         version?: "v4" | "v6" | "v7";
-    }) => {
-        readonly _format: string;
-        readonly _validator: (val: string) => boolean;
-        readonly _errorMessage?: string | undefined;
-        parse(value: unknown): string;
-        safeParse(value: unknown): import("./validators").ParseResult<string>;
-        isValid(value: unknown): boolean;
-        parseOrDefault(value: unknown, defaultValue: string): string;
-        refine<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
-        refine(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
-        superRefine(refinement: (value: string, ctx: import("./validators").SuperRefineContext) => void | Promise<void>): import("./validators").VldSuperRefine<unknown, string>;
-        transform<TTransformed>(transformer: (value: string) => TTransformed): import("./validators").VldTransform<unknown, string, TTransformed>;
-        default(defaultValue: string): import("./validators").VldDefault<unknown, string>;
-        catch(fallbackValue: string): import("./validators").VldCatch<unknown, string>;
-        optional(): VldOptional<unknown, string>;
-        nullable(): VldNullable<unknown, string>;
-        nullish(): VldNullish<unknown, string>;
-        pipe<TNextOutput>(next: VldBase<string, TNextOutput>): import("./validators").VldPipe<unknown, string, TNextOutput>;
-        readonly(): import("./validators").VldReadonly<unknown, string>;
-        brand<TBrand extends string>(): import("./validators").VldBrand<unknown, string, TBrand>;
-        apply<TNewOutput>(fn: (schema: /*elided*/ any) => VldBase<unknown, TNewOutput>): VldBase<unknown, TNewOutput>;
-    };
-    uuidv4: () => {
-        readonly _format: string;
-        readonly _validator: (val: string) => boolean;
-        readonly _errorMessage?: string | undefined;
-        parse(value: unknown): string;
-        safeParse(value: unknown): import("./validators").ParseResult<string>;
-        isValid(value: unknown): boolean;
-        parseOrDefault(value: unknown, defaultValue: string): string;
-        refine<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
-        refine(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
-        superRefine(refinement: (value: string, ctx: import("./validators").SuperRefineContext) => void | Promise<void>): import("./validators").VldSuperRefine<unknown, string>;
-        transform<TTransformed>(transformer: (value: string) => TTransformed): import("./validators").VldTransform<unknown, string, TTransformed>;
-        default(defaultValue: string): import("./validators").VldDefault<unknown, string>;
-        catch(fallbackValue: string): import("./validators").VldCatch<unknown, string>;
-        optional(): VldOptional<unknown, string>;
-        nullable(): VldNullable<unknown, string>;
-        nullish(): VldNullish<unknown, string>;
-        pipe<TNextOutput>(next: VldBase<string, TNextOutput>): import("./validators").VldPipe<unknown, string, TNextOutput>;
-        readonly(): import("./validators").VldReadonly<unknown, string>;
-        brand<TBrand extends string>(): import("./validators").VldBrand<unknown, string, TBrand>;
-        apply<TNewOutput>(fn: (schema: /*elided*/ any) => VldBase<unknown, TNewOutput>): VldBase<unknown, TNewOutput>;
-    };
-    hostname: () => {
-        readonly _format: string;
-        readonly _validator: (val: string) => boolean;
-        readonly _errorMessage?: string | undefined;
-        parse(value: unknown): string;
-        safeParse(value: unknown): import("./validators").ParseResult<string>;
-        isValid(value: unknown): boolean;
-        parseOrDefault(value: unknown, defaultValue: string): string;
-        refine<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
-        refine(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
-        superRefine(refinement: (value: string, ctx: import("./validators").SuperRefineContext) => void | Promise<void>): import("./validators").VldSuperRefine<unknown, string>;
-        transform<TTransformed>(transformer: (value: string) => TTransformed): import("./validators").VldTransform<unknown, string, TTransformed>;
-        default(defaultValue: string): import("./validators").VldDefault<unknown, string>;
-        catch(fallbackValue: string): import("./validators").VldCatch<unknown, string>;
-        optional(): VldOptional<unknown, string>;
-        nullable(): VldNullable<unknown, string>;
-        nullish(): VldNullish<unknown, string>;
-        pipe<TNextOutput>(next: VldBase<string, TNextOutput>): import("./validators").VldPipe<unknown, string, TNextOutput>;
-        readonly(): import("./validators").VldReadonly<unknown, string>;
-        brand<TBrand extends string>(): import("./validators").VldBrand<unknown, string, TBrand>;
-        apply<TNewOutput>(fn: (schema: /*elided*/ any) => VldBase<unknown, TNewOutput>): VldBase<unknown, TNewOutput>;
-    };
-    emoji: () => {
-        readonly _format: string;
-        readonly _validator: (val: string) => boolean;
-        readonly _errorMessage?: string | undefined;
-        parse(value: unknown): string;
-        safeParse(value: unknown): import("./validators").ParseResult<string>;
-        isValid(value: unknown): boolean;
-        parseOrDefault(value: unknown, defaultValue: string): string;
-        refine<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
-        refine(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
-        superRefine(refinement: (value: string, ctx: import("./validators").SuperRefineContext) => void | Promise<void>): import("./validators").VldSuperRefine<unknown, string>;
-        transform<TTransformed>(transformer: (value: string) => TTransformed): import("./validators").VldTransform<unknown, string, TTransformed>;
-        default(defaultValue: string): import("./validators").VldDefault<unknown, string>;
-        catch(fallbackValue: string): import("./validators").VldCatch<unknown, string>;
-        optional(): VldOptional<unknown, string>;
-        nullable(): VldNullable<unknown, string>;
-        nullish(): VldNullish<unknown, string>;
-        pipe<TNextOutput>(next: VldBase<string, TNextOutput>): import("./validators").VldPipe<unknown, string, TNextOutput>;
-        readonly(): import("./validators").VldReadonly<unknown, string>;
-        brand<TBrand extends string>(): import("./validators").VldBrand<unknown, string, TBrand>;
-        apply<TNewOutput>(fn: (schema: /*elided*/ any) => VldBase<unknown, TNewOutput>): VldBase<unknown, TNewOutput>;
-    };
-    base64: () => {
-        readonly _format: string;
-        readonly _validator: (val: string) => boolean;
-        readonly _errorMessage?: string | undefined;
-        parse(value: unknown): string;
-        safeParse(value: unknown): import("./validators").ParseResult<string>;
-        isValid(value: unknown): boolean;
-        parseOrDefault(value: unknown, defaultValue: string): string;
-        refine<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
-        refine(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
-        superRefine(refinement: (value: string, ctx: import("./validators").SuperRefineContext) => void | Promise<void>): import("./validators").VldSuperRefine<unknown, string>;
-        transform<TTransformed>(transformer: (value: string) => TTransformed): import("./validators").VldTransform<unknown, string, TTransformed>;
-        default(defaultValue: string): import("./validators").VldDefault<unknown, string>;
-        catch(fallbackValue: string): import("./validators").VldCatch<unknown, string>;
-        optional(): VldOptional<unknown, string>;
-        nullable(): VldNullable<unknown, string>;
-        nullish(): VldNullish<unknown, string>;
-        pipe<TNextOutput>(next: VldBase<string, TNextOutput>): import("./validators").VldPipe<unknown, string, TNextOutput>;
-        readonly(): import("./validators").VldReadonly<unknown, string>;
-        brand<TBrand extends string>(): import("./validators").VldBrand<unknown, string, TBrand>;
-        apply<TNewOutput>(fn: (schema: /*elided*/ any) => VldBase<unknown, TNewOutput>): VldBase<unknown, TNewOutput>;
-    };
-    base64url: () => {
-        readonly _format: string;
-        readonly _validator: (val: string) => boolean;
-        readonly _errorMessage?: string | undefined;
-        parse(value: unknown): string;
-        safeParse(value: unknown): import("./validators").ParseResult<string>;
-        isValid(value: unknown): boolean;
-        parseOrDefault(value: unknown, defaultValue: string): string;
-        refine<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
-        refine(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
-        superRefine(refinement: (value: string, ctx: import("./validators").SuperRefineContext) => void | Promise<void>): import("./validators").VldSuperRefine<unknown, string>;
-        transform<TTransformed>(transformer: (value: string) => TTransformed): import("./validators").VldTransform<unknown, string, TTransformed>;
-        default(defaultValue: string): import("./validators").VldDefault<unknown, string>;
-        catch(fallbackValue: string): import("./validators").VldCatch<unknown, string>;
-        optional(): VldOptional<unknown, string>;
-        nullable(): VldNullable<unknown, string>;
-        nullish(): VldNullish<unknown, string>;
-        pipe<TNextOutput>(next: VldBase<string, TNextOutput>): import("./validators").VldPipe<unknown, string, TNextOutput>;
-        readonly(): import("./validators").VldReadonly<unknown, string>;
-        brand<TBrand extends string>(): import("./validators").VldBrand<unknown, string, TBrand>;
-        apply<TNewOutput>(fn: (schema: /*elided*/ any) => VldBase<unknown, TNewOutput>): VldBase<unknown, TNewOutput>;
-    };
-    hex: () => {
-        readonly _format: string;
-        readonly _validator: (val: string) => boolean;
-        readonly _errorMessage?: string | undefined;
-        parse(value: unknown): string;
-        safeParse(value: unknown): import("./validators").ParseResult<string>;
-        isValid(value: unknown): boolean;
-        parseOrDefault(value: unknown, defaultValue: string): string;
-        refine<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
-        refine(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
-        superRefine(refinement: (value: string, ctx: import("./validators").SuperRefineContext) => void | Promise<void>): import("./validators").VldSuperRefine<unknown, string>;
-        transform<TTransformed>(transformer: (value: string) => TTransformed): import("./validators").VldTransform<unknown, string, TTransformed>;
-        default(defaultValue: string): import("./validators").VldDefault<unknown, string>;
-        catch(fallbackValue: string): import("./validators").VldCatch<unknown, string>;
-        optional(): VldOptional<unknown, string>;
-        nullable(): VldNullable<unknown, string>;
-        nullish(): VldNullish<unknown, string>;
-        pipe<TNextOutput>(next: VldBase<string, TNextOutput>): import("./validators").VldPipe<unknown, string, TNextOutput>;
-        readonly(): import("./validators").VldReadonly<unknown, string>;
-        brand<TBrand extends string>(): import("./validators").VldBrand<unknown, string, TBrand>;
-        apply<TNewOutput>(fn: (schema: /*elided*/ any) => VldBase<unknown, TNewOutput>): VldBase<unknown, TNewOutput>;
-    };
-    jwt: () => {
-        readonly _format: string;
-        readonly _validator: (val: string) => boolean;
-        readonly _errorMessage?: string | undefined;
-        parse(value: unknown): string;
-        safeParse(value: unknown): import("./validators").ParseResult<string>;
-        isValid(value: unknown): boolean;
-        parseOrDefault(value: unknown, defaultValue: string): string;
-        refine<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
-        refine(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
-        superRefine(refinement: (value: string, ctx: import("./validators").SuperRefineContext) => void | Promise<void>): import("./validators").VldSuperRefine<unknown, string>;
-        transform<TTransformed>(transformer: (value: string) => TTransformed): import("./validators").VldTransform<unknown, string, TTransformed>;
-        default(defaultValue: string): import("./validators").VldDefault<unknown, string>;
-        catch(fallbackValue: string): import("./validators").VldCatch<unknown, string>;
-        optional(): VldOptional<unknown, string>;
-        nullable(): VldNullable<unknown, string>;
-        nullish(): VldNullish<unknown, string>;
-        pipe<TNextOutput>(next: VldBase<string, TNextOutput>): import("./validators").VldPipe<unknown, string, TNextOutput>;
-        readonly(): import("./validators").VldReadonly<unknown, string>;
-        brand<TBrand extends string>(): import("./validators").VldBrand<unknown, string, TBrand>;
-        apply<TNewOutput>(fn: (schema: /*elided*/ any) => VldBase<unknown, TNewOutput>): VldBase<unknown, TNewOutput>;
-    };
-    nanoid: () => {
-        readonly _format: string;
-        readonly _validator: (val: string) => boolean;
-        readonly _errorMessage?: string | undefined;
-        parse(value: unknown): string;
-        safeParse(value: unknown): import("./validators").ParseResult<string>;
-        isValid(value: unknown): boolean;
-        parseOrDefault(value: unknown, defaultValue: string): string;
-        refine<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
-        refine(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
-        superRefine(refinement: (value: string, ctx: import("./validators").SuperRefineContext) => void | Promise<void>): import("./validators").VldSuperRefine<unknown, string>;
-        transform<TTransformed>(transformer: (value: string) => TTransformed): import("./validators").VldTransform<unknown, string, TTransformed>;
-        default(defaultValue: string): import("./validators").VldDefault<unknown, string>;
-        catch(fallbackValue: string): import("./validators").VldCatch<unknown, string>;
-        optional(): VldOptional<unknown, string>;
-        nullable(): VldNullable<unknown, string>;
-        nullish(): VldNullish<unknown, string>;
-        pipe<TNextOutput>(next: VldBase<string, TNextOutput>): import("./validators").VldPipe<unknown, string, TNextOutput>;
-        readonly(): import("./validators").VldReadonly<unknown, string>;
-        brand<TBrand extends string>(): import("./validators").VldBrand<unknown, string, TBrand>;
-        apply<TNewOutput>(fn: (schema: /*elided*/ any) => VldBase<unknown, TNewOutput>): VldBase<unknown, TNewOutput>;
+    }) => stringFormats.VldStringFormat;
+    uuidv4: () => stringFormats.VldStringFormat;
+    uuidv6: () => stringFormats.VldStringFormat;
+    uuidv7: () => stringFormats.VldStringFormat;
+    hostname: () => stringFormats.VldStringFormat;
+    emoji: () => stringFormats.VldStringFormat;
+    base64: () => stringFormats.VldStringFormat;
+    base64url: () => stringFormats.VldStringFormat;
+    hex: () => stringFormats.VldStringFormat;
+    jwt: () => stringFormats.VldStringFormat;
+    nanoid: () => stringFormats.VldStringFormat;
+    cuid: () => stringFormats.VldStringFormat;
+    cuid2: () => stringFormats.VldStringFormat;
+    ulid: () => stringFormats.VldStringFormat;
+    ipv4: () => stringFormats.VldStringFormat;
+    ipv6: () => stringFormats.VldStringFormat;
+    mac: () => stringFormats.VldStringFormat;
+    cidrv4: () => stringFormats.VldStringFormat;
+    cidrv6: () => stringFormats.VldStringFormat;
+    e164: () => stringFormats.VldStringFormat;
+    hash: (algorithm: "md5" | "sha1" | "sha256" | "sha384" | "sha512") => stringFormats.VldStringFormat;
+    iso: {
+        date: () => stringFormats.VldStringFormat;
+        time: () => stringFormats.VldStringFormat;
+        dateTime: () => stringFormats.VldStringFormat;
+        duration: () => stringFormats.VldStringFormat;
     };
-    cuid: () => {
-        readonly _format: string;
-        readonly _validator: (val: string) => boolean;
-        readonly _errorMessage?: string | undefined;
-        parse(value: unknown): string;
-        safeParse(value: unknown): import("./validators").ParseResult<string>;
-        isValid(value: unknown): boolean;
-        parseOrDefault(value: unknown, defaultValue: string): string;
-        refine<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
-        refine(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
-        superRefine(refinement: (value: string, ctx: import("./validators").SuperRefineContext) => void | Promise<void>): import("./validators").VldSuperRefine<unknown, string>;
-        transform<TTransformed>(transformer: (value: string) => TTransformed): import("./validators").VldTransform<unknown, string, TTransformed>;
-        default(defaultValue: string): import("./validators").VldDefault<unknown, string>;
-        catch(fallbackValue: string): import("./validators").VldCatch<unknown, string>;
-        optional(): VldOptional<unknown, string>;
-        nullable(): VldNullable<unknown, string>;
-        nullish(): VldNullish<unknown, string>;
-        pipe<TNextOutput>(next: VldBase<string, TNextOutput>): import("./validators").VldPipe<unknown, string, TNextOutput>;
-        readonly(): import("./validators").VldReadonly<unknown, string>;
-        brand<TBrand extends string>(): import("./validators").VldBrand<unknown, string, TBrand>;
-        apply<TNewOutput>(fn: (schema: /*elided*/ any) => VldBase<unknown, TNewOutput>): VldBase<unknown, TNewOutput>;
+    stringFormat: (name: string, validator: ((val: string) => boolean) | RegExp) => stringFormats.VldStringFormat;
+    minLength: (value: number, message?: ErrorParam) => VldString;
+    maxLength: (value: number, message?: ErrorParam) => VldString;
+    length: (value: number, message?: ErrorParam) => VldString;
+    regex: (pattern: RegExp, message?: ErrorParam) => VldString;
+    startsWith: (value: string, message?: ErrorParam) => VldString;
+    endsWith: (value: string, message?: ErrorParam) => VldString;
+    includes: (value: string, message?: ErrorParam) => VldString;
+    trim: () => VldString;
+    toLowerCase: () => VldString;
+    lowercase: () => VldString;
+    toUpperCase: () => VldString;
+    uppercase: () => VldString;
+    gt: (value: number, message?: ErrorParam) => VldNumber;
+    gte: (value: number, message?: ErrorParam) => VldNumber;
+    lt: (value: number, message?: ErrorParam) => VldNumber;
+    lte: (value: number, message?: ErrorParam) => VldNumber;
+    positive: (message?: ErrorParam) => VldNumber;
+    negative: (message?: ErrorParam) => VldNumber;
+    nonnegative: (message?: ErrorParam) => VldNumber;
+    nonpositive: (message?: ErrorParam) => VldNumber;
+    multipleOf: (value: number, message?: ErrorParam) => VldNumber;
+    minSize: (value: number, message?: ErrorParam) => VldString;
+    maxSize: (value: number, message?: ErrorParam) => VldString;
+    size: (value: number, message?: ErrorParam) => VldString;
+    normalize: (form?: "NFC" | "NFD" | "NFKC" | "NFKD" | (string & {})) => VldTransform<string, string, string>;
+    slugify: () => VldTransform<string, string, string>;
+    mime: (types: string | string[], message?: string) => VldFile;
+    xid: () => stringFormats.VldStringFormat;
+    guid: () => stringFormats.VldStringFormat;
+    httpUrl: () => stringFormats.VldStringFormat;
+    ksuid: () => stringFormats.VldStringFormat;
+    regexes: {
+        readonly email: RegExp;
+        readonly uuid: RegExp;
+        readonly uuidv4: RegExp;
+        readonly uuidv6: RegExp;
+        readonly uuidv7: RegExp;
+        readonly hostname: RegExp;
+        readonly emoji: RegExp;
+        readonly base64: RegExp;
+        readonly base64url: RegExp;
+        readonly hex: RegExp;
+        readonly jwt: RegExp;
+        readonly nanoid: RegExp;
+        readonly cuid: RegExp;
+        readonly cuid2: RegExp;
+        readonly ulid: RegExp;
+        readonly ipv4: RegExp;
+        readonly ipv6: RegExp;
+        readonly mac: RegExp;
+        readonly cidrv4: RegExp;
+        readonly cidrv6: RegExp;
+        readonly e164: RegExp;
+        readonly isoDate: RegExp;
+        readonly isoTime: RegExp;
+        readonly isoDateTime: RegExp;
+        readonly md5: RegExp;
+        readonly sha1: RegExp;
+        readonly sha256: RegExp;
+        readonly sha384: RegExp;
+        readonly sha512: RegExp;
+        readonly xid: RegExp;
+        readonly guid: RegExp;
+        readonly httpUrl: RegExp;
+        readonly ksuid: RegExp;
     };
-    cuid2: () => {
-        readonly _format: string;
-        readonly _validator: (val: string) => boolean;
-        readonly _errorMessage?: string | undefined;
-        parse(value: unknown): string;
-        safeParse(value: unknown): import("./validators").ParseResult<string>;
-        isValid(value: unknown): boolean;
-        parseOrDefault(value: unknown, defaultValue: string): string;
-        refine<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
-        refine(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
-        superRefine(refinement: (value: string, ctx: import("./validators").SuperRefineContext) => void | Promise<void>): import("./validators").VldSuperRefine<unknown, string>;
-        transform<TTransformed>(transformer: (value: string) => TTransformed): import("./validators").VldTransform<unknown, string, TTransformed>;
-        default(defaultValue: string): import("./validators").VldDefault<unknown, string>;
-        catch(fallbackValue: string): import("./validators").VldCatch<unknown, string>;
-        optional(): VldOptional<unknown, string>;
-        nullable(): VldNullable<unknown, string>;
-        nullish(): VldNullish<unknown, string>;
-        pipe<TNextOutput>(next: VldBase<string, TNextOutput>): import("./validators").VldPipe<unknown, string, TNextOutput>;
-        readonly(): import("./validators").VldReadonly<unknown, string>;
-        brand<TBrand extends string>(): import("./validators").VldBrand<unknown, string, TBrand>;
-        apply<TNewOutput>(fn: (schema: /*elided*/ any) => VldBase<unknown, TNewOutput>): VldBase<unknown, TNewOutput>;
+    templateLiteral: (...components: (VldBase<any, any> | string)[]) => VldTemplateLiteral;
+    base64Bytes: () => VldBase64;
+    hexBytes: () => VldHex;
+    uint8Array: () => VldUint8Array;
+    codec: <TInput, TOutput>(inputValidator: VldBase<unknown, TInput>, outputValidator: VldBase<unknown, TOutput>, transform: {
+        decode: (value: TInput) => TOutput | Promise<TOutput>;
+        encode: (value: TOutput) => TInput | Promise<TInput>;
+    }) => VldCodec<TInput, TOutput>;
+    invertCodec: <TInput, TOutput>(codec: VldCodec<TInput, TOutput>) => VldCodec<TOutput, TInput>;
+    promise: <T>(inner: VldBase<unknown, T>) => VldPromise<T>;
+    parse: <T>(schema: VldBase<unknown, T>, value: unknown) => T;
+    safeParse: <T>(schema: VldBase<unknown, T>, value: unknown) => ParseResult<T>;
+    parseAsync: <T>(schema: VldBase<unknown, T>, value: unknown) => Promise<T>;
+    safeParseAsync: <T>(schema: VldBase<unknown, T>, value: unknown) => Promise<ParseResult<T>>;
+    decode: <T>(schema: VldBase<unknown, T>, value: unknown) => T;
+    safeDecode: <T>(schema: VldBase<unknown, T>, value: unknown) => ParseResult<T>;
+    decodeAsync: <T>(schema: VldBase<unknown, T>, value: unknown) => Promise<T>;
+    safeDecodeAsync: <T>(schema: VldBase<unknown, T>, value: unknown) => Promise<ParseResult<T>>;
+    encode: <TInput, TOutput>(schema: VldBase<TInput, TOutput>, value: unknown) => TInput | TOutput;
+    safeEncode: <TInput, TOutput>(schema: VldBase<TInput, TOutput>, value: unknown) => ParseResult<TInput | TOutput>;
+    encodeAsync: <TInput, TOutput>(schema: VldBase<TInput, TOutput>, value: unknown) => Promise<TInput | TOutput>;
+    safeEncodeAsync: <TInput, TOutput>(schema: VldBase<TInput, TOutput>, value: unknown) => Promise<ParseResult<TInput | TOutput>>;
+    formatError: (error: Error) => FormattedError;
+    treeifyError: typeof treeifyErrorFn;
+    prettifyError: typeof prettifyErrorFn;
+    flattenError: typeof flattenErrorFn;
+    toJSONSchema: typeof toJSONSchemaFn;
+};
+export declare namespace v {
+    type infer<T extends VldBase<any, any>> = Infer<T>;
+    type input<T extends VldBase<any, any>> = Input<T>;
+    type output<T extends VldBase<any, any>> = Output<T>;
+}
+/**
+ * Zod-compatible namespace alias.
+ */
+export declare const z: {
+    string: () => VldString;
+    number: () => VldNumber;
+    int: () => VldNumber;
+    int32: () => VldNumber;
+    uint32: () => VldNumber;
+    uint64: () => VldNumber;
+    int64: () => VldNumber;
+    float32: () => VldNumber;
+    float64: () => VldNumber;
+    boolean: () => VldBoolean;
+    date: () => VldDate;
+    bigint: () => VldBigInt;
+    symbol: () => VldSymbol;
+    stringbool: (options?: {
+        truthy?: readonly string[];
+        falsy?: readonly string[];
+        caseSensitive?: boolean;
+    }) => VldStringBool;
+    array: <T>(item: VldBase<unknown, T>) => VldArray<T>;
+    object: <T extends Record<string, any>>(shape: { [K in keyof T]: VldBase<unknown, T[K]>; }) => VldObject<T>;
+    strictObject: <T extends Record<string, any>>(shape: { [K in keyof T]: VldBase<unknown, T[K]>; }) => VldObject<T>;
+    looseObject: <T extends Record<string, any>>(shape: { [K in keyof T]: VldBase<unknown, T[K]>; }) => VldObject<T>;
+    tuple: <T extends readonly VldBase<any, any>[]>(...items: T) => VldTuple<[...T]>;
+    record: <T>(value: VldBase<unknown, T>) => VldRecord<T>;
+    partialRecord: <T>(value: VldBase<unknown, T>) => VldRecord<T | undefined>;
+    looseRecord: <T>(value: VldBase<unknown, T>) => VldBase<unknown, Record<string, T>>;
+    set: <T>(item: VldBase<unknown, T>) => VldSet<T>;
+    map: <K, V>(key: VldBase<unknown, K>, value: VldBase<unknown, V>) => VldMap<K, V>;
+    union: <T extends readonly VldBase<any, any>[]>(...validators: T) => VldUnion<[...T]>;
+    intersection: <A, B>(first: VldBase<unknown, A>, second: VldBase<unknown, B>) => VldIntersection<A, B>;
+    discriminatedUnion: <K extends string, T extends readonly VldBase<any, any>[]>(discriminator: K, ...options: T) => VldDiscriminatedUnion<K, any>;
+    xor: <T extends readonly VldBase<any, any>[]>(...options: T) => VldXor<any>;
+    keyof: <T extends Record<string, any>>(schema: VldObject<T>) => VldEnum<[string, ...string[]]>;
+    literal: <T extends string | number | boolean | null | undefined>(value: T) => VldLiteral<T>;
+    enum: <T extends readonly [string | number, ...(string | number)[]]>(...values: T) => VldEnum<any>;
+    nativeEnum: <T extends NativeEnumLike>(enumObject: T) => VldEnum<any>;
+    any: () => VldAny;
+    unknown: () => VldUnknown;
+    void: () => VldVoid;
+    never: () => VldNever;
+    null: () => VldNull;
+    undefined: () => VldUndefined;
+    nan: () => VldNan;
+    NEVER: VldNever;
+    TimePrecision: {
+        readonly Any: null;
+        readonly Minute: -1;
+        readonly Second: 0;
+        readonly Millisecond: 3;
+        readonly Microsecond: 6;
     };
-    ulid: () => {
-        readonly _format: string;
-        readonly _validator: (val: string) => boolean;
-        readonly _errorMessage?: string | undefined;
-        parse(value: unknown): string;
-        safeParse(value: unknown): import("./validators").ParseResult<string>;
-        isValid(value: unknown): boolean;
-        parseOrDefault(value: unknown, defaultValue: string): string;
-        refine<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
-        refine(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
-        superRefine(refinement: (value: string, ctx: import("./validators").SuperRefineContext) => void | Promise<void>): import("./validators").VldSuperRefine<unknown, string>;
-        transform<TTransformed>(transformer: (value: string) => TTransformed): import("./validators").VldTransform<unknown, string, TTransformed>;
-        default(defaultValue: string): import("./validators").VldDefault<unknown, string>;
-        catch(fallbackValue: string): import("./validators").VldCatch<unknown, string>;
-        optional(): VldOptional<unknown, string>;
-        nullable(): VldNullable<unknown, string>;
-        nullish(): VldNullish<unknown, string>;
-        pipe<TNextOutput>(next: VldBase<string, TNextOutput>): import("./validators").VldPipe<unknown, string, TNextOutput>;
-        readonly(): import("./validators").VldReadonly<unknown, string>;
-        brand<TBrand extends string>(): import("./validators").VldBrand<unknown, string, TBrand>;
-        apply<TNewOutput>(fn: (schema: /*elided*/ any) => VldBase<unknown, TNewOutput>): VldBase<unknown, TNewOutput>;
+    ZodIssueCode: {
+        readonly invalid_type: "invalid_type";
+        readonly too_big: "too_big";
+        readonly too_small: "too_small";
+        readonly invalid_format: "invalid_format";
+        readonly not_multiple_of: "not_multiple_of";
+        readonly unrecognized_keys: "unrecognized_keys";
+        readonly invalid_union: "invalid_union";
+        readonly invalid_key: "invalid_key";
+        readonly invalid_element: "invalid_element";
+        readonly invalid_value: "invalid_value";
+        readonly custom: "custom";
     };
-    ipv4: () => {
-        readonly _format: string;
-        readonly _validator: (val: string) => boolean;
-        readonly _errorMessage?: string | undefined;
-        parse(value: unknown): string;
-        safeParse(value: unknown): import("./validators").ParseResult<string>;
-        isValid(value: unknown): boolean;
-        parseOrDefault(value: unknown, defaultValue: string): string;
-        refine<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
-        refine(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
-        superRefine(refinement: (value: string, ctx: import("./validators").SuperRefineContext) => void | Promise<void>): import("./validators").VldSuperRefine<unknown, string>;
-        transform<TTransformed>(transformer: (value: string) => TTransformed): import("./validators").VldTransform<unknown, string, TTransformed>;
-        default(defaultValue: string): import("./validators").VldDefault<unknown, string>;
-        catch(fallbackValue: string): import("./validators").VldCatch<unknown, string>;
-        optional(): VldOptional<unknown, string>;
-        nullable(): VldNullable<unknown, string>;
-        nullish(): VldNullish<unknown, string>;
-        pipe<TNextOutput>(next: VldBase<string, TNextOutput>): import("./validators").VldPipe<unknown, string, TNextOutput>;
-        readonly(): import("./validators").VldReadonly<unknown, string>;
-        brand<TBrand extends string>(): import("./validators").VldBrand<unknown, string, TBrand>;
-        apply<TNewOutput>(fn: (schema: /*elided*/ any) => VldBase<unknown, TNewOutput>): VldBase<unknown, TNewOutput>;
+    ZodFirstPartyTypeKind: {};
+    optional: <T>(validator: VldBase<unknown, T>) => VldOptional<unknown, T>;
+    nullable: <T>(validator: VldBase<unknown, T>) => VldNullable<unknown, T>;
+    nullish: <T>(validator: VldBase<unknown, T>) => VldNullish<unknown, T>;
+    exactOptional: <T>(validator: VldBase<unknown, T>) => VldExactOptional<unknown, T>;
+    nonoptional: <T>(validator: VldBase<unknown, T | undefined>, message?: RefinementMessage) => VldRefine<unknown, T | undefined, Exclude<T, undefined>>;
+    catch: <T>(validator: VldBase<unknown, T>, fallbackValue: T) => VldCatch<unknown, T>;
+    prefault: <T>(validator: VldBase<unknown, T>, defaultValue: T | (() => T)) => VldPrefault<unknown, T>;
+    readonly: <T>(validator: VldBase<unknown, T>) => VldReadonly<unknown, T>;
+    pipe: <TInput, TIntermediate, TOutput>(first: VldBase<TInput, TIntermediate>, second: VldBase<TIntermediate, TOutput>) => VldPipe<TInput, TIntermediate, TOutput>;
+    clone: <T extends VldBase<any, any>>(schema: T) => T;
+    describe: <TInput, TOutput>(schemaOrDescription: VldBase<TInput, TOutput> | string, description?: string) => VldMeta<unknown, unknown>;
+    meta: <TInput, TOutput>(schemaOrMetadata: VldBase<TInput, TOutput> | Partial<SchemaMetadata>, metadata?: Partial<SchemaMetadata>) => VldMeta<unknown, unknown>;
+    transform: <TInput = unknown, TOutput = TInput>(schemaOrTransformer: VldBase<unknown, TInput> | ((value: TInput, ctx?: SuperRefineContext) => TOutput | Promise<TOutput>), transformer?: (value: TInput) => TOutput | Promise<TOutput>) => VldTransform<unknown, TInput, TOutput> | VldBase<TInput, Awaited<TOutput>>;
+    overwrite: <T>(transformer: (value: T) => T) => VldBase<T, Awaited<T>>;
+    refine: <T = unknown>(schemaOrPredicate: VldBase<unknown, T> | ((value: T) => boolean | Promise<boolean>), predicateOrMessage?: ((value: T) => boolean | Promise<boolean>) | RefinementMessage, message?: RefinementMessage) => VldBase<unknown, T>;
+    check: <T = unknown>(schemaOrPredicate: VldBase<unknown, T> | ((value: T) => boolean | Promise<boolean>), predicateOrMessage?: ((value: T) => boolean | Promise<boolean>) | RefinementMessage, message?: RefinementMessage) => VldBase<unknown, T>;
+    superRefine: <T = unknown>(schemaOrRefinement: VldBase<unknown, T> | ((value: T, ctx: SuperRefineContext) => void | Promise<void>), refinement?: (value: T, ctx: SuperRefineContext) => void | Promise<void>) => VldBase<unknown, T>;
+    property: typeof propertyCheck;
+    instanceof: <T>(constructor: Constructor<T>, message?: RefinementMessage) => VldCustom<T>;
+    config: typeof configure;
+    setErrorMap: typeof setGlobalErrorMap;
+    getErrorMap: typeof getGlobalErrorMap;
+    core: {
+        readonly util: {
+            readonly getParsedType: typeof getParsedType;
+            readonly propertyKeyTypes: Set<string>;
+            readonly primitiveTypes: Set<string>;
+            readonly assert: (condition: unknown, message?: string) => asserts condition;
+            readonly assertNever: (value: never) => never;
+            readonly joinValues: (values: readonly unknown[], separator?: string) => string;
+            readonly jsonStringifyReplacer: (_key: string, value: unknown) => unknown;
+            readonly nullish: (value: unknown) => value is null | undefined;
+            readonly cached: <T>(getter: () => T) => (() => T);
+        };
+        readonly regexes: {
+            readonly email: RegExp;
+            readonly uuid: RegExp;
+            readonly uuidv4: RegExp;
+            readonly uuidv6: RegExp;
+            readonly uuidv7: RegExp;
+            readonly hostname: RegExp;
+            readonly emoji: RegExp;
+            readonly base64: RegExp;
+            readonly base64url: RegExp;
+            readonly hex: RegExp;
+            readonly jwt: RegExp;
+            readonly nanoid: RegExp;
+            readonly cuid: RegExp;
+            readonly cuid2: RegExp;
+            readonly ulid: RegExp;
+            readonly ipv4: RegExp;
+            readonly ipv6: RegExp;
+            readonly mac: RegExp;
+            readonly cidrv4: RegExp;
+            readonly cidrv6: RegExp;
+            readonly e164: RegExp;
+            readonly isoDate: RegExp;
+            readonly isoTime: RegExp;
+            readonly isoDateTime: RegExp;
+            readonly md5: RegExp;
+            readonly sha1: RegExp;
+            readonly sha256: RegExp;
+            readonly sha384: RegExp;
+            readonly sha512: RegExp;
+            readonly xid: RegExp;
+            readonly guid: RegExp;
+            readonly httpUrl: RegExp;
+            readonly ksuid: RegExp;
+        };
+        readonly locales: typeof localeNamespace;
+        readonly NEVER: VldNever;
+        readonly TimePrecision: {
+            readonly Any: null;
+            readonly Minute: -1;
+            readonly Second: 0;
+            readonly Millisecond: 3;
+            readonly Microsecond: 6;
+        };
+        readonly ZodIssueCode: {
+            readonly invalid_type: "invalid_type";
+            readonly too_big: "too_big";
+            readonly too_small: "too_small";
+            readonly invalid_format: "invalid_format";
+            readonly not_multiple_of: "not_multiple_of";
+            readonly unrecognized_keys: "unrecognized_keys";
+            readonly invalid_union: "invalid_union";
+            readonly invalid_key: "invalid_key";
+            readonly invalid_element: "invalid_element";
+            readonly invalid_value: "invalid_value";
+            readonly custom: "custom";
+        };
+        readonly globalRegistry: import("./registry.js").SchemaRegistry<SchemaMetadata>;
+        readonly config: typeof configure;
+        readonly getErrorMap: typeof getGlobalErrorMap;
+        readonly setErrorMap: typeof setGlobalErrorMap;
+        readonly parse: <T>(schema: VldBase<unknown, T>, value: unknown) => T;
+        readonly safeParse: <T>(schema: VldBase<unknown, T>, value: unknown) => ParseResult<T>;
+        readonly parseAsync: <T>(schema: VldBase<unknown, T>, value: unknown) => Promise<T>;
+        readonly safeParseAsync: <T>(schema: VldBase<unknown, T>, value: unknown) => Promise<ParseResult<T>>;
     };
-    ipv6: () => {
-        readonly _format: string;
-        readonly _validator: (val: string) => boolean;
-        readonly _errorMessage?: string | undefined;
-        parse(value: unknown): string;
-        safeParse(value: unknown): import("./validators").ParseResult<string>;
-        isValid(value: unknown): boolean;
-        parseOrDefault(value: unknown, defaultValue: string): string;
-        refine<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
-        refine(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
-        superRefine(refinement: (value: string, ctx: import("./validators").SuperRefineContext) => void | Promise<void>): import("./validators").VldSuperRefine<unknown, string>;
-        transform<TTransformed>(transformer: (value: string) => TTransformed): import("./validators").VldTransform<unknown, string, TTransformed>;
-        default(defaultValue: string): import("./validators").VldDefault<unknown, string>;
-        catch(fallbackValue: string): import("./validators").VldCatch<unknown, string>;
-        optional(): VldOptional<unknown, string>;
-        nullable(): VldNullable<unknown, string>;
-        nullish(): VldNullish<unknown, string>;
-        pipe<TNextOutput>(next: VldBase<string, TNextOutput>): import("./validators").VldPipe<unknown, string, TNextOutput>;
-        readonly(): import("./validators").VldReadonly<unknown, string>;
-        brand<TBrand extends string>(): import("./validators").VldBrand<unknown, string, TBrand>;
-        apply<TNewOutput>(fn: (schema: /*elided*/ any) => VldBase<unknown, TNewOutput>): VldBase<unknown, TNewOutput>;
+    util: {
+        readonly getParsedType: typeof getParsedType;
+        readonly propertyKeyTypes: Set<string>;
+        readonly primitiveTypes: Set<string>;
+        readonly assert: (condition: unknown, message?: string) => asserts condition;
+        readonly assertNever: (value: never) => never;
+        readonly joinValues: (values: readonly unknown[], separator?: string) => string;
+        readonly jsonStringifyReplacer: (_key: string, value: unknown) => unknown;
+        readonly nullish: (value: unknown) => value is null | undefined;
+        readonly cached: <T>(getter: () => T) => (() => T);
     };
-    mac: () => {
-        readonly _format: string;
-        readonly _validator: (val: string) => boolean;
-        readonly _errorMessage?: string | undefined;
-        parse(value: unknown): string;
-        safeParse(value: unknown): import("./validators").ParseResult<string>;
-        isValid(value: unknown): boolean;
-        parseOrDefault(value: unknown, defaultValue: string): string;
-        refine<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
-        refine(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
-        superRefine(refinement: (value: string, ctx: import("./validators").SuperRefineContext) => void | Promise<void>): import("./validators").VldSuperRefine<unknown, string>;
-        transform<TTransformed>(transformer: (value: string) => TTransformed): import("./validators").VldTransform<unknown, string, TTransformed>;
-        default(defaultValue: string): import("./validators").VldDefault<unknown, string>;
-        catch(fallbackValue: string): import("./validators").VldCatch<unknown, string>;
-        optional(): VldOptional<unknown, string>;
-        nullable(): VldNullable<unknown, string>;
-        nullish(): VldNullish<unknown, string>;
-        pipe<TNextOutput>(next: VldBase<string, TNextOutput>): import("./validators").VldPipe<unknown, string, TNextOutput>;
-        readonly(): import("./validators").VldReadonly<unknown, string>;
-        brand<TBrand extends string>(): import("./validators").VldBrand<unknown, string, TBrand>;
-        apply<TNewOutput>(fn: (schema: /*elided*/ any) => VldBase<unknown, TNewOutput>): VldBase<unknown, TNewOutput>;
+    locales: typeof localeNamespace;
+    lazy: <T>(schemaGetter: () => VldBase<unknown, T>) => VldLazy<unknown, T>;
+    json: <T = unknown>(schema?: VldBase<unknown, T>) => VldJson<T>;
+    custom: <TOutput = unknown>(options: CustomValidatorOptions<TOutput>) => VldCustom<TOutput>;
+    file: () => VldFile;
+    function: () => VldFunction;
+    preprocess: <TInput, TOutput>(preprocessor: (input: unknown) => unknown, schema: VldBase<TInput, TOutput>) => VldPreprocess<TInput, TOutput>;
+    coerce: {
+        string: () => VldCoerceString;
+        number: () => VldCoerceNumber;
+        boolean: () => VldCoerceBoolean;
+        date: () => VldCoerceDate;
+        bigint: () => VldCoerceBigInt;
     };
-    cidrv4: () => {
-        readonly _format: string;
-        readonly _validator: (val: string) => boolean;
-        readonly _errorMessage?: string | undefined;
-        parse(value: unknown): string;
-        safeParse(value: unknown): import("./validators").ParseResult<string>;
-        isValid(value: unknown): boolean;
-        parseOrDefault(value: unknown, defaultValue: string): string;
-        refine<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
-        refine(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
-        superRefine(refinement: (value: string, ctx: import("./validators").SuperRefineContext) => void | Promise<void>): import("./validators").VldSuperRefine<unknown, string>;
-        transform<TTransformed>(transformer: (value: string) => TTransformed): import("./validators").VldTransform<unknown, string, TTransformed>;
-        default(defaultValue: string): import("./validators").VldDefault<unknown, string>;
-        catch(fallbackValue: string): import("./validators").VldCatch<unknown, string>;
-        optional(): VldOptional<unknown, string>;
-        nullable(): VldNullable<unknown, string>;
-        nullish(): VldNullish<unknown, string>;
-        pipe<TNextOutput>(next: VldBase<string, TNextOutput>): import("./validators").VldPipe<unknown, string, TNextOutput>;
-        readonly(): import("./validators").VldReadonly<unknown, string>;
-        brand<TBrand extends string>(): import("./validators").VldBrand<unknown, string, TBrand>;
-        apply<TNewOutput>(fn: (schema: /*elided*/ any) => VldBase<unknown, TNewOutput>): VldBase<unknown, TNewOutput>;
+    email: (options?: {
+        pattern?: RegExp;
+    }) => stringFormats.VldStringFormat;
+    url: () => VldString;
+    uuid: (options?: {
+        version?: "v4" | "v6" | "v7";
+    }) => stringFormats.VldStringFormat;
+    uuidv4: () => stringFormats.VldStringFormat;
+    uuidv6: () => stringFormats.VldStringFormat;
+    uuidv7: () => stringFormats.VldStringFormat;
+    hostname: () => stringFormats.VldStringFormat;
+    emoji: () => stringFormats.VldStringFormat;
+    base64: () => stringFormats.VldStringFormat;
+    base64url: () => stringFormats.VldStringFormat;
+    hex: () => stringFormats.VldStringFormat;
+    jwt: () => stringFormats.VldStringFormat;
+    nanoid: () => stringFormats.VldStringFormat;
+    cuid: () => stringFormats.VldStringFormat;
+    cuid2: () => stringFormats.VldStringFormat;
+    ulid: () => stringFormats.VldStringFormat;
+    ipv4: () => stringFormats.VldStringFormat;
+    ipv6: () => stringFormats.VldStringFormat;
+    mac: () => stringFormats.VldStringFormat;
+    cidrv4: () => stringFormats.VldStringFormat;
+    cidrv6: () => stringFormats.VldStringFormat;
+    e164: () => stringFormats.VldStringFormat;
+    hash: (algorithm: "md5" | "sha1" | "sha256" | "sha384" | "sha512") => stringFormats.VldStringFormat;
+    iso: {
+        date: () => stringFormats.VldStringFormat;
+        time: () => stringFormats.VldStringFormat;
+        dateTime: () => stringFormats.VldStringFormat;
+        duration: () => stringFormats.VldStringFormat;
     };
-    cidrv6: () => {
-        readonly _format: string;
-        readonly _validator: (val: string) => boolean;
-        readonly _errorMessage?: string | undefined;
-        parse(value: unknown): string;
-        safeParse(value: unknown): import("./validators").ParseResult<string>;
-        isValid(value: unknown): boolean;
-        parseOrDefault(value: unknown, defaultValue: string): string;
-        refine<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
-        refine(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
-        superRefine(refinement: (value: string, ctx: import("./validators").SuperRefineContext) => void | Promise<void>): import("./validators").VldSuperRefine<unknown, string>;
-        transform<TTransformed>(transformer: (value: string) => TTransformed): import("./validators").VldTransform<unknown, string, TTransformed>;
-        default(defaultValue: string): import("./validators").VldDefault<unknown, string>;
-        catch(fallbackValue: string): import("./validators").VldCatch<unknown, string>;
-        optional(): VldOptional<unknown, string>;
-        nullable(): VldNullable<unknown, string>;
-        nullish(): VldNullish<unknown, string>;
-        pipe<TNextOutput>(next: VldBase<string, TNextOutput>): import("./validators").VldPipe<unknown, string, TNextOutput>;
-        readonly(): import("./validators").VldReadonly<unknown, string>;
-        brand<TBrand extends string>(): import("./validators").VldBrand<unknown, string, TBrand>;
-        apply<TNewOutput>(fn: (schema: /*elided*/ any) => VldBase<unknown, TNewOutput>): VldBase<unknown, TNewOutput>;
+    stringFormat: (name: string, validator: ((val: string) => boolean) | RegExp) => stringFormats.VldStringFormat;
+    minLength: (value: number, message?: ErrorParam) => VldString;
+    maxLength: (value: number, message?: ErrorParam) => VldString;
+    length: (value: number, message?: ErrorParam) => VldString;
+    regex: (pattern: RegExp, message?: ErrorParam) => VldString;
+    startsWith: (value: string, message?: ErrorParam) => VldString;
+    endsWith: (value: string, message?: ErrorParam) => VldString;
+    includes: (value: string, message?: ErrorParam) => VldString;
+    trim: () => VldString;
+    toLowerCase: () => VldString;
+    lowercase: () => VldString;
+    toUpperCase: () => VldString;
+    uppercase: () => VldString;
+    gt: (value: number, message?: ErrorParam) => VldNumber;
+    gte: (value: number, message?: ErrorParam) => VldNumber;
+    lt: (value: number, message?: ErrorParam) => VldNumber;
+    lte: (value: number, message?: ErrorParam) => VldNumber;
+    positive: (message?: ErrorParam) => VldNumber;
+    negative: (message?: ErrorParam) => VldNumber;
+    nonnegative: (message?: ErrorParam) => VldNumber;
+    nonpositive: (message?: ErrorParam) => VldNumber;
+    multipleOf: (value: number, message?: ErrorParam) => VldNumber;
+    minSize: (value: number, message?: ErrorParam) => VldString;
+    maxSize: (value: number, message?: ErrorParam) => VldString;
+    size: (value: number, message?: ErrorParam) => VldString;
+    normalize: (form?: "NFC" | "NFD" | "NFKC" | "NFKD" | (string & {})) => VldTransform<string, string, string>;
+    slugify: () => VldTransform<string, string, string>;
+    mime: (types: string | string[], message?: string) => VldFile;
+    xid: () => stringFormats.VldStringFormat;
+    guid: () => stringFormats.VldStringFormat;
+    httpUrl: () => stringFormats.VldStringFormat;
+    ksuid: () => stringFormats.VldStringFormat;
+    regexes: {
+        readonly email: RegExp;
+        readonly uuid: RegExp;
+        readonly uuidv4: RegExp;
+        readonly uuidv6: RegExp;
+        readonly uuidv7: RegExp;
+        readonly hostname: RegExp;
+        readonly emoji: RegExp;
+        readonly base64: RegExp;
+        readonly base64url: RegExp;
+        readonly hex: RegExp;
+        readonly jwt: RegExp;
+        readonly nanoid: RegExp;
+        readonly cuid: RegExp;
+        readonly cuid2: RegExp;
+        readonly ulid: RegExp;
+        readonly ipv4: RegExp;
+        readonly ipv6: RegExp;
+        readonly mac: RegExp;
+        readonly cidrv4: RegExp;
+        readonly cidrv6: RegExp;
+        readonly e164: RegExp;
+        readonly isoDate: RegExp;
+        readonly isoTime: RegExp;
+        readonly isoDateTime: RegExp;
+        readonly md5: RegExp;
+        readonly sha1: RegExp;
+        readonly sha256: RegExp;
+        readonly sha384: RegExp;
+        readonly sha512: RegExp;
+        readonly xid: RegExp;
+        readonly guid: RegExp;
+        readonly httpUrl: RegExp;
+        readonly ksuid: RegExp;
     };
-    e164: () => {
-        readonly _format: string;
-        readonly _validator: (val: string) => boolean;
-        readonly _errorMessage?: string | undefined;
-        parse(value: unknown): string;
-        safeParse(value: unknown): import("./validators").ParseResult<string>;
-        isValid(value: unknown): boolean;
-        parseOrDefault(value: unknown, defaultValue: string): string;
-        refine<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
-        refine(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
-        superRefine(refinement: (value: string, ctx: import("./validators").SuperRefineContext) => void | Promise<void>): import("./validators").VldSuperRefine<unknown, string>;
-        transform<TTransformed>(transformer: (value: string) => TTransformed): import("./validators").VldTransform<unknown, string, TTransformed>;
-        default(defaultValue: string): import("./validators").VldDefault<unknown, string>;
-        catch(fallbackValue: string): import("./validators").VldCatch<unknown, string>;
-        optional(): VldOptional<unknown, string>;
-        nullable(): VldNullable<unknown, string>;
-        nullish(): VldNullish<unknown, string>;
-        pipe<TNextOutput>(next: VldBase<string, TNextOutput>): import("./validators").VldPipe<unknown, string, TNextOutput>;
-        readonly(): import("./validators").VldReadonly<unknown, string>;
-        brand<TBrand extends string>(): import("./validators").VldBrand<unknown, string, TBrand>;
-        apply<TNewOutput>(fn: (schema: /*elided*/ any) => VldBase<unknown, TNewOutput>): VldBase<unknown, TNewOutput>;
+    templateLiteral: (...components: (VldBase<any, any> | string)[]) => VldTemplateLiteral;
+    base64Bytes: () => VldBase64;
+    hexBytes: () => VldHex;
+    uint8Array: () => VldUint8Array;
+    codec: <TInput, TOutput>(inputValidator: VldBase<unknown, TInput>, outputValidator: VldBase<unknown, TOutput>, transform: {
+        decode: (value: TInput) => TOutput | Promise<TOutput>;
+        encode: (value: TOutput) => TInput | Promise<TInput>;
+    }) => VldCodec<TInput, TOutput>;
+    invertCodec: <TInput, TOutput>(codec: VldCodec<TInput, TOutput>) => VldCodec<TOutput, TInput>;
+    promise: <T>(inner: VldBase<unknown, T>) => VldPromise<T>;
+    parse: <T>(schema: VldBase<unknown, T>, value: unknown) => T;
+    safeParse: <T>(schema: VldBase<unknown, T>, value: unknown) => ParseResult<T>;
+    parseAsync: <T>(schema: VldBase<unknown, T>, value: unknown) => Promise<T>;
+    safeParseAsync: <T>(schema: VldBase<unknown, T>, value: unknown) => Promise<ParseResult<T>>;
+    decode: <T>(schema: VldBase<unknown, T>, value: unknown) => T;
+    safeDecode: <T>(schema: VldBase<unknown, T>, value: unknown) => ParseResult<T>;
+    decodeAsync: <T>(schema: VldBase<unknown, T>, value: unknown) => Promise<T>;
+    safeDecodeAsync: <T>(schema: VldBase<unknown, T>, value: unknown) => Promise<ParseResult<T>>;
+    encode: <TInput, TOutput>(schema: VldBase<TInput, TOutput>, value: unknown) => TInput | TOutput;
+    safeEncode: <TInput, TOutput>(schema: VldBase<TInput, TOutput>, value: unknown) => ParseResult<TInput | TOutput>;
+    encodeAsync: <TInput, TOutput>(schema: VldBase<TInput, TOutput>, value: unknown) => Promise<TInput | TOutput>;
+    safeEncodeAsync: <TInput, TOutput>(schema: VldBase<TInput, TOutput>, value: unknown) => Promise<ParseResult<TInput | TOutput>>;
+    formatError: (error: Error) => FormattedError;
+    treeifyError: typeof treeifyErrorFn;
+    prettifyError: typeof prettifyErrorFn;
+    flattenError: typeof flattenErrorFn;
+    toJSONSchema: typeof toJSONSchemaFn;
+};
+/**
+ * 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.
+ */
+export declare const string: () => VldString, number: () => VldNumber, int: () => VldNumber, int32: () => VldNumber, uint32: () => VldNumber, uint64: () => VldNumber, int64: () => VldNumber, float32: () => VldNumber, float64: () => VldNumber, boolean: () => VldBoolean, date: () => VldDate, bigint: () => VldBigInt, symbol: () => VldSymbol, stringbool: (options?: {
+    truthy?: readonly string[];
+    falsy?: readonly string[];
+    caseSensitive?: boolean;
+}) => VldStringBool, array: <T>(item: VldBase<unknown, T>) => VldArray<T>, object: <T extends Record<string, any>>(shape: { [K in keyof T]: VldBase<unknown, T[K]>; }) => VldObject<T>, strictObject: <T extends Record<string, any>>(shape: { [K in keyof T]: VldBase<unknown, T[K]>; }) => VldObject<T>, looseObject: <T extends Record<string, any>>(shape: { [K in keyof T]: VldBase<unknown, T[K]>; }) => VldObject<T>, tuple: <T extends readonly VldBase<any, any>[]>(...items: T) => VldTuple<[...T]>, record: <T>(value: VldBase<unknown, T>) => VldRecord<T>, partialRecord: <T>(value: VldBase<unknown, T>) => VldRecord<T | undefined>, looseRecord: <T>(value: VldBase<unknown, T>) => VldBase<unknown, Record<string, T>>, set: <T>(item: VldBase<unknown, T>) => VldSet<T>, union: <T extends readonly VldBase<any, any>[]>(...validators: T) => VldUnion<[...T]>, intersection: <A, B>(first: VldBase<unknown, A>, second: VldBase<unknown, B>) => VldIntersection<A, B>, discriminatedUnion: <K extends string, T extends readonly VldBase<any, any>[]>(discriminator: K, ...options: T) => VldDiscriminatedUnion<K, any>, xor: <T extends readonly VldBase<any, any>[]>(...options: T) => VldXor<any>, keyof: <T extends Record<string, any>>(schema: VldObject<T>) => VldEnum<[string, ...string[]]>, literal: <T extends string | number | boolean | null | undefined>(value: T) => VldLiteral<T>, nativeEnum: <T extends NativeEnumLike>(enumObject: T) => VldEnum<any>, any: () => VldAny, unknown: () => VldUnknown, nan: () => VldNan, optional: <T>(validator: VldBase<unknown, T>) => VldOptional<unknown, T>, nullable: <T>(validator: VldBase<unknown, T>) => VldNullable<unknown, T>, nullish: <T>(validator: VldBase<unknown, T>) => VldNullish<unknown, T>, exactOptional: <T>(validator: VldBase<unknown, T>) => VldExactOptional<unknown, T>, nonoptional: <T>(validator: VldBase<unknown, T | undefined>, message?: RefinementMessage) => VldRefine<unknown, T | undefined, Exclude<T, undefined>>, readonly: <T>(validator: VldBase<unknown, T>) => VldReadonly<unknown, T>, pipe: <TInput, TIntermediate, TOutput>(first: VldBase<TInput, TIntermediate>, second: VldBase<TIntermediate, TOutput>) => VldPipe<TInput, TIntermediate, TOutput>, clone: <T extends VldBase<any, any>>(schema: T) => T, describe: <TInput, TOutput>(schemaOrDescription: VldBase<TInput, TOutput> | string, description?: string) => VldMeta<unknown, unknown>, meta: <TInput, TOutput>(schemaOrMetadata: VldBase<TInput, TOutput> | Partial<SchemaMetadata>, metadata?: Partial<SchemaMetadata>) => VldMeta<unknown, unknown>, transform: <TInput = unknown, TOutput = TInput>(schemaOrTransformer: VldBase<unknown, TInput> | ((value: TInput, ctx?: SuperRefineContext) => TOutput | Promise<TOutput>), transformer?: (value: TInput) => TOutput | Promise<TOutput>) => VldTransform<unknown, TInput, TOutput> | VldBase<TInput, Awaited<TOutput>>, overwrite: <T>(transformer: (value: T) => T) => VldBase<T, Awaited<T>>, refine: <T = unknown>(schemaOrPredicate: VldBase<unknown, T> | ((value: T) => boolean | Promise<boolean>), predicateOrMessage?: ((value: T) => boolean | Promise<boolean>) | RefinementMessage, message?: RefinementMessage) => VldBase<unknown, T>, check: <T = unknown>(schemaOrPredicate: VldBase<unknown, T> | ((value: T) => boolean | Promise<boolean>), predicateOrMessage?: ((value: T) => boolean | Promise<boolean>) | RefinementMessage, message?: RefinementMessage) => VldBase<unknown, T>, superRefine: <T = unknown>(schemaOrRefinement: VldBase<unknown, T> | ((value: T, ctx: SuperRefineContext) => void | Promise<void>), refinement?: (value: T, ctx: SuperRefineContext) => void | Promise<void>) => VldBase<unknown, T>, property: typeof propertyCheck, config: typeof configure, setErrorMap: typeof setGlobalErrorMap, getErrorMap: typeof getGlobalErrorMap, locales: typeof localeNamespace, lazy: <T>(schemaGetter: () => VldBase<unknown, T>) => VldLazy<unknown, T>, json: <T = unknown>(schema?: VldBase<unknown, T>) => VldJson<T>, custom: <TOutput = unknown>(options: CustomValidatorOptions<TOutput>) => VldCustom<TOutput>, file: () => VldFile, preprocess: <TInput, TOutput>(preprocessor: (input: unknown) => unknown, schema: VldBase<TInput, TOutput>) => VldPreprocess<TInput, TOutput>, coerce: {
+    string: () => VldCoerceString;
+    number: () => VldCoerceNumber;
+    boolean: () => VldCoerceBoolean;
+    date: () => VldCoerceDate;
+    bigint: () => VldCoerceBigInt;
+}, email: (options?: {
+    pattern?: RegExp;
+}) => stringFormats.VldStringFormat, url: () => VldString, uuid: (options?: {
+    version?: "v4" | "v6" | "v7";
+}) => stringFormats.VldStringFormat, uuidv4: () => stringFormats.VldStringFormat, uuidv6: () => stringFormats.VldStringFormat, uuidv7: () => stringFormats.VldStringFormat, hostname: () => stringFormats.VldStringFormat, emoji: () => stringFormats.VldStringFormat, base64: () => stringFormats.VldStringFormat, base64url: () => stringFormats.VldStringFormat, hex: () => stringFormats.VldStringFormat, jwt: () => stringFormats.VldStringFormat, nanoid: () => stringFormats.VldStringFormat, cuid: () => stringFormats.VldStringFormat, cuid2: () => stringFormats.VldStringFormat, ulid: () => stringFormats.VldStringFormat, ipv4: () => stringFormats.VldStringFormat, ipv6: () => stringFormats.VldStringFormat, mac: () => stringFormats.VldStringFormat, cidrv4: () => stringFormats.VldStringFormat, cidrv6: () => stringFormats.VldStringFormat, e164: () => stringFormats.VldStringFormat, hash: (algorithm: "md5" | "sha1" | "sha256" | "sha384" | "sha512") => stringFormats.VldStringFormat, iso: {
+    date: () => stringFormats.VldStringFormat;
+    time: () => stringFormats.VldStringFormat;
+    dateTime: () => stringFormats.VldStringFormat;
+    duration: () => stringFormats.VldStringFormat;
+}, stringFormat: (name: string, validator: ((val: string) => boolean) | RegExp) => stringFormats.VldStringFormat, normalize: (form?: "NFC" | "NFD" | "NFKC" | "NFKD" | (string & {})) => VldTransform<string, string, string>, slugify: () => VldTransform<string, string, string>, mime: (types: string | string[], message?: string) => VldFile, xid: () => stringFormats.VldStringFormat, guid: () => stringFormats.VldStringFormat, httpUrl: () => stringFormats.VldStringFormat, ksuid: () => stringFormats.VldStringFormat, regexes: {
+    readonly email: RegExp;
+    readonly uuid: RegExp;
+    readonly uuidv4: RegExp;
+    readonly uuidv6: RegExp;
+    readonly uuidv7: RegExp;
+    readonly hostname: RegExp;
+    readonly emoji: RegExp;
+    readonly base64: RegExp;
+    readonly base64url: RegExp;
+    readonly hex: RegExp;
+    readonly jwt: RegExp;
+    readonly nanoid: RegExp;
+    readonly cuid: RegExp;
+    readonly cuid2: RegExp;
+    readonly ulid: RegExp;
+    readonly ipv4: RegExp;
+    readonly ipv6: RegExp;
+    readonly mac: RegExp;
+    readonly cidrv4: RegExp;
+    readonly cidrv6: RegExp;
+    readonly e164: RegExp;
+    readonly isoDate: RegExp;
+    readonly isoTime: RegExp;
+    readonly isoDateTime: RegExp;
+    readonly md5: RegExp;
+    readonly sha1: RegExp;
+    readonly sha256: RegExp;
+    readonly sha384: RegExp;
+    readonly sha512: RegExp;
+    readonly xid: RegExp;
+    readonly guid: RegExp;
+    readonly httpUrl: RegExp;
+    readonly ksuid: RegExp;
+}, templateLiteral: (...components: (VldBase<any, any> | string)[]) => VldTemplateLiteral, base64Bytes: () => VldBase64, hexBytes: () => VldHex, uint8Array: () => VldUint8Array, codec: <TInput, TOutput>(inputValidator: VldBase<unknown, TInput>, outputValidator: VldBase<unknown, TOutput>, transform: {
+    decode: (value: TInput) => TOutput | Promise<TOutput>;
+    encode: (value: TOutput) => TInput | Promise<TInput>;
+}) => VldCodec<TInput, TOutput>, promise: <T>(inner: VldBase<unknown, T>) => VldPromise<T>, prefault: <T>(validator: VldBase<unknown, T>, defaultValue: T | (() => T)) => VldPrefault<unknown, T>, parse: <T>(schema: VldBase<unknown, T>, value: unknown) => T, safeParse: <T>(schema: VldBase<unknown, T>, value: unknown) => ParseResult<T>, parseAsync: <T>(schema: VldBase<unknown, T>, value: unknown) => Promise<T>, safeParseAsync: <T>(schema: VldBase<unknown, T>, value: unknown) => Promise<ParseResult<T>>, decode: <T>(schema: VldBase<unknown, T>, value: unknown) => T, safeDecode: <T>(schema: VldBase<unknown, T>, value: unknown) => ParseResult<T>, decodeAsync: <T>(schema: VldBase<unknown, T>, value: unknown) => Promise<T>, safeDecodeAsync: <T>(schema: VldBase<unknown, T>, value: unknown) => Promise<ParseResult<T>>, encode: <TInput, TOutput>(schema: VldBase<TInput, TOutput>, value: unknown) => TInput | TOutput, safeEncode: <TInput, TOutput>(schema: VldBase<TInput, TOutput>, value: unknown) => ParseResult<TInput | TOutput>, encodeAsync: <TInput, TOutput>(schema: VldBase<TInput, TOutput>, value: unknown) => Promise<TInput | TOutput>, safeEncodeAsync: <TInput, TOutput>(schema: VldBase<TInput, TOutput>, value: unknown) => Promise<ParseResult<TInput | TOutput>>, formatError: (error: Error) => FormattedError, NEVER: VldNever;
+declare const catchFactory: <T>(validator: VldBase<unknown, T>, fallbackValue: T) => VldCatch<unknown, T>;
+declare const enumFactory: <T extends readonly [string | number, ...(string | number)[]]>(...values: T) => VldEnum<any>;
+declare const functionFactory: () => VldFunction;
+declare const instanceOfFactory: <T>(constructor: Constructor<T>, message?: RefinementMessage) => VldCustom<T>;
+declare const mapFactory: <K, V>(key: VldBase<unknown, K>, value: VldBase<unknown, V>) => VldMap<K, V>;
+declare const neverFactory: () => VldNever;
+declare const nullFactory: () => VldNull;
+declare const undefinedFactory: () => VldUndefined;
+declare const voidFactory: () => VldVoid;
+declare const defaultFactory: {
+    string: () => VldString;
+    number: () => VldNumber;
+    int: () => VldNumber;
+    int32: () => VldNumber;
+    uint32: () => VldNumber;
+    uint64: () => VldNumber;
+    int64: () => VldNumber;
+    float32: () => VldNumber;
+    float64: () => VldNumber;
+    boolean: () => VldBoolean;
+    date: () => VldDate;
+    bigint: () => VldBigInt;
+    symbol: () => VldSymbol;
+    stringbool: (options?: {
+        truthy?: readonly string[];
+        falsy?: readonly string[];
+        caseSensitive?: boolean;
+    }) => VldStringBool;
+    array: <T>(item: VldBase<unknown, T>) => VldArray<T>;
+    object: <T extends Record<string, any>>(shape: { [K in keyof T]: VldBase<unknown, T[K]>; }) => VldObject<T>;
+    strictObject: <T extends Record<string, any>>(shape: { [K in keyof T]: VldBase<unknown, T[K]>; }) => VldObject<T>;
+    looseObject: <T extends Record<string, any>>(shape: { [K in keyof T]: VldBase<unknown, T[K]>; }) => VldObject<T>;
+    tuple: <T extends readonly VldBase<any, any>[]>(...items: T) => VldTuple<[...T]>;
+    record: <T>(value: VldBase<unknown, T>) => VldRecord<T>;
+    partialRecord: <T>(value: VldBase<unknown, T>) => VldRecord<T | undefined>;
+    looseRecord: <T>(value: VldBase<unknown, T>) => VldBase<unknown, Record<string, T>>;
+    set: <T>(item: VldBase<unknown, T>) => VldSet<T>;
+    map: <K, V>(key: VldBase<unknown, K>, value: VldBase<unknown, V>) => VldMap<K, V>;
+    union: <T extends readonly VldBase<any, any>[]>(...validators: T) => VldUnion<[...T]>;
+    intersection: <A, B>(first: VldBase<unknown, A>, second: VldBase<unknown, B>) => VldIntersection<A, B>;
+    discriminatedUnion: <K extends string, T extends readonly VldBase<any, any>[]>(discriminator: K, ...options: T) => VldDiscriminatedUnion<K, any>;
+    xor: <T extends readonly VldBase<any, any>[]>(...options: T) => VldXor<any>;
+    keyof: <T extends Record<string, any>>(schema: VldObject<T>) => VldEnum<[string, ...string[]]>;
+    literal: <T extends string | number | boolean | null | undefined>(value: T) => VldLiteral<T>;
+    enum: <T extends readonly [string | number, ...(string | number)[]]>(...values: T) => VldEnum<any>;
+    nativeEnum: <T extends NativeEnumLike>(enumObject: T) => VldEnum<any>;
+    any: () => VldAny;
+    unknown: () => VldUnknown;
+    void: () => VldVoid;
+    never: () => VldNever;
+    null: () => VldNull;
+    undefined: () => VldUndefined;
+    nan: () => VldNan;
+    NEVER: VldNever;
+    TimePrecision: {
+        readonly Any: null;
+        readonly Minute: -1;
+        readonly Second: 0;
+        readonly Millisecond: 3;
+        readonly Microsecond: 6;
     };
-    hash: (algorithm: "md5" | "sha1" | "sha256" | "sha384" | "sha512") => {
-        readonly _format: string;
-        readonly _validator: (val: string) => boolean;
-        readonly _errorMessage?: string | undefined;
-        parse(value: unknown): string;
-        safeParse(value: unknown): import("./validators").ParseResult<string>;
-        isValid(value: unknown): boolean;
-        parseOrDefault(value: unknown, defaultValue: string): string;
-        refine<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
-        refine(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
-        superRefine(refinement: (value: string, ctx: import("./validators").SuperRefineContext) => void | Promise<void>): import("./validators").VldSuperRefine<unknown, string>;
-        transform<TTransformed>(transformer: (value: string) => TTransformed): import("./validators").VldTransform<unknown, string, TTransformed>;
-        default(defaultValue: string): import("./validators").VldDefault<unknown, string>;
-        catch(fallbackValue: string): import("./validators").VldCatch<unknown, string>;
-        optional(): VldOptional<unknown, string>;
-        nullable(): VldNullable<unknown, string>;
-        nullish(): VldNullish<unknown, string>;
-        pipe<TNextOutput>(next: VldBase<string, TNextOutput>): import("./validators").VldPipe<unknown, string, TNextOutput>;
-        readonly(): import("./validators").VldReadonly<unknown, string>;
-        brand<TBrand extends string>(): import("./validators").VldBrand<unknown, string, TBrand>;
-        apply<TNewOutput>(fn: (schema: /*elided*/ any) => VldBase<unknown, TNewOutput>): VldBase<unknown, TNewOutput>;
+    ZodIssueCode: {
+        readonly invalid_type: "invalid_type";
+        readonly too_big: "too_big";
+        readonly too_small: "too_small";
+        readonly invalid_format: "invalid_format";
+        readonly not_multiple_of: "not_multiple_of";
+        readonly unrecognized_keys: "unrecognized_keys";
+        readonly invalid_union: "invalid_union";
+        readonly invalid_key: "invalid_key";
+        readonly invalid_element: "invalid_element";
+        readonly invalid_value: "invalid_value";
+        readonly custom: "custom";
     };
-    iso: {
-        date: () => {
-            readonly _format: string;
-            readonly _validator: (val: string) => boolean;
-            readonly _errorMessage?: string | undefined;
-            parse(value: unknown): string;
-            safeParse(value: unknown): import("./validators").ParseResult<string>;
-            isValid(value: unknown): boolean;
-            parseOrDefault(value: unknown, defaultValue: string): string;
-            refine<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
-            refine(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
-            superRefine(refinement: (value: string, ctx: import("./validators").SuperRefineContext) => void | Promise<void>): import("./validators").VldSuperRefine<unknown, string>;
-            transform<TTransformed>(transformer: (value: string) => TTransformed): import("./validators").VldTransform<unknown, string, TTransformed>;
-            default(defaultValue: string): import("./validators").VldDefault<unknown, string>;
-            catch(fallbackValue: string): import("./validators").VldCatch<unknown, string>;
-            optional(): VldOptional<unknown, string>;
-            nullable(): VldNullable<unknown, string>;
-            nullish(): VldNullish<unknown, string>;
-            pipe<TNextOutput>(next: VldBase<string, TNextOutput>): import("./validators").VldPipe<unknown, string, TNextOutput>;
-            readonly(): import("./validators").VldReadonly<unknown, string>;
-            brand<TBrand extends string>(): import("./validators").VldBrand<unknown, string, TBrand>;
-            apply<TNewOutput>(fn: (schema: /*elided*/ any) => VldBase<unknown, TNewOutput>): VldBase<unknown, TNewOutput>;
+    ZodFirstPartyTypeKind: {};
+    optional: <T>(validator: VldBase<unknown, T>) => VldOptional<unknown, T>;
+    nullable: <T>(validator: VldBase<unknown, T>) => VldNullable<unknown, T>;
+    nullish: <T>(validator: VldBase<unknown, T>) => VldNullish<unknown, T>;
+    exactOptional: <T>(validator: VldBase<unknown, T>) => VldExactOptional<unknown, T>;
+    nonoptional: <T>(validator: VldBase<unknown, T | undefined>, message?: RefinementMessage) => VldRefine<unknown, T | undefined, Exclude<T, undefined>>;
+    catch: <T>(validator: VldBase<unknown, T>, fallbackValue: T) => VldCatch<unknown, T>;
+    prefault: <T>(validator: VldBase<unknown, T>, defaultValue: T | (() => T)) => VldPrefault<unknown, T>;
+    readonly: <T>(validator: VldBase<unknown, T>) => VldReadonly<unknown, T>;
+    pipe: <TInput, TIntermediate, TOutput>(first: VldBase<TInput, TIntermediate>, second: VldBase<TIntermediate, TOutput>) => VldPipe<TInput, TIntermediate, TOutput>;
+    clone: <T extends VldBase<any, any>>(schema: T) => T;
+    describe: <TInput, TOutput>(schemaOrDescription: VldBase<TInput, TOutput> | string, description?: string) => VldMeta<unknown, unknown>;
+    meta: <TInput, TOutput>(schemaOrMetadata: VldBase<TInput, TOutput> | Partial<SchemaMetadata>, metadata?: Partial<SchemaMetadata>) => VldMeta<unknown, unknown>;
+    transform: <TInput = unknown, TOutput = TInput>(schemaOrTransformer: VldBase<unknown, TInput> | ((value: TInput, ctx?: SuperRefineContext) => TOutput | Promise<TOutput>), transformer?: (value: TInput) => TOutput | Promise<TOutput>) => VldTransform<unknown, TInput, TOutput> | VldBase<TInput, Awaited<TOutput>>;
+    overwrite: <T>(transformer: (value: T) => T) => VldBase<T, Awaited<T>>;
+    refine: <T = unknown>(schemaOrPredicate: VldBase<unknown, T> | ((value: T) => boolean | Promise<boolean>), predicateOrMessage?: ((value: T) => boolean | Promise<boolean>) | RefinementMessage, message?: RefinementMessage) => VldBase<unknown, T>;
+    check: <T = unknown>(schemaOrPredicate: VldBase<unknown, T> | ((value: T) => boolean | Promise<boolean>), predicateOrMessage?: ((value: T) => boolean | Promise<boolean>) | RefinementMessage, message?: RefinementMessage) => VldBase<unknown, T>;
+    superRefine: <T = unknown>(schemaOrRefinement: VldBase<unknown, T> | ((value: T, ctx: SuperRefineContext) => void | Promise<void>), refinement?: (value: T, ctx: SuperRefineContext) => void | Promise<void>) => VldBase<unknown, T>;
+    property: typeof propertyCheck;
+    instanceof: <T>(constructor: Constructor<T>, message?: RefinementMessage) => VldCustom<T>;
+    config: typeof configure;
+    setErrorMap: typeof setGlobalErrorMap;
+    getErrorMap: typeof getGlobalErrorMap;
+    core: {
+        readonly util: {
+            readonly getParsedType: typeof getParsedType;
+            readonly propertyKeyTypes: Set<string>;
+            readonly primitiveTypes: Set<string>;
+            readonly assert: (condition: unknown, message?: string) => asserts condition;
+            readonly assertNever: (value: never) => never;
+            readonly joinValues: (values: readonly unknown[], separator?: string) => string;
+            readonly jsonStringifyReplacer: (_key: string, value: unknown) => unknown;
+            readonly nullish: (value: unknown) => value is null | undefined;
+            readonly cached: <T>(getter: () => T) => (() => T);
         };
-        time: () => {
-            readonly _format: string;
-            readonly _validator: (val: string) => boolean;
-            readonly _errorMessage?: string | undefined;
-            parse(value: unknown): string;
-            safeParse(value: unknown): import("./validators").ParseResult<string>;
-            isValid(value: unknown): boolean;
-            parseOrDefault(value: unknown, defaultValue: string): string;
-            refine<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
-            refine(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
-            superRefine(refinement: (value: string, ctx: import("./validators").SuperRefineContext) => void | Promise<void>): import("./validators").VldSuperRefine<unknown, string>;
-            transform<TTransformed>(transformer: (value: string) => TTransformed): import("./validators").VldTransform<unknown, string, TTransformed>;
-            default(defaultValue: string): import("./validators").VldDefault<unknown, string>;
-            catch(fallbackValue: string): import("./validators").VldCatch<unknown, string>;
-            optional(): VldOptional<unknown, string>;
-            nullable(): VldNullable<unknown, string>;
-            nullish(): VldNullish<unknown, string>;
-            pipe<TNextOutput>(next: VldBase<string, TNextOutput>): import("./validators").VldPipe<unknown, string, TNextOutput>;
-            readonly(): import("./validators").VldReadonly<unknown, string>;
-            brand<TBrand extends string>(): import("./validators").VldBrand<unknown, string, TBrand>;
-            apply<TNewOutput>(fn: (schema: /*elided*/ any) => VldBase<unknown, TNewOutput>): VldBase<unknown, TNewOutput>;
+        readonly regexes: {
+            readonly email: RegExp;
+            readonly uuid: RegExp;
+            readonly uuidv4: RegExp;
+            readonly uuidv6: RegExp;
+            readonly uuidv7: RegExp;
+            readonly hostname: RegExp;
+            readonly emoji: RegExp;
+            readonly base64: RegExp;
+            readonly base64url: RegExp;
+            readonly hex: RegExp;
+            readonly jwt: RegExp;
+            readonly nanoid: RegExp;
+            readonly cuid: RegExp;
+            readonly cuid2: RegExp;
+            readonly ulid: RegExp;
+            readonly ipv4: RegExp;
+            readonly ipv6: RegExp;
+            readonly mac: RegExp;
+            readonly cidrv4: RegExp;
+            readonly cidrv6: RegExp;
+            readonly e164: RegExp;
+            readonly isoDate: RegExp;
+            readonly isoTime: RegExp;
+            readonly isoDateTime: RegExp;
+            readonly md5: RegExp;
+            readonly sha1: RegExp;
+            readonly sha256: RegExp;
+            readonly sha384: RegExp;
+            readonly sha512: RegExp;
+            readonly xid: RegExp;
+            readonly guid: RegExp;
+            readonly httpUrl: RegExp;
+            readonly ksuid: RegExp;
         };
-        dateTime: () => {
-            readonly _format: string;
-            readonly _validator: (val: string) => boolean;
-            readonly _errorMessage?: string | undefined;
-            parse(value: unknown): string;
-            safeParse(value: unknown): import("./validators").ParseResult<string>;
-            isValid(value: unknown): boolean;
-            parseOrDefault(value: unknown, defaultValue: string): string;
-            refine<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
-            refine(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
-            superRefine(refinement: (value: string, ctx: import("./validators").SuperRefineContext) => void | Promise<void>): import("./validators").VldSuperRefine<unknown, string>;
-            transform<TTransformed>(transformer: (value: string) => TTransformed): import("./validators").VldTransform<unknown, string, TTransformed>;
-            default(defaultValue: string): import("./validators").VldDefault<unknown, string>;
-            catch(fallbackValue: string): import("./validators").VldCatch<unknown, string>;
-            optional(): VldOptional<unknown, string>;
-            nullable(): VldNullable<unknown, string>;
-            nullish(): VldNullish<unknown, string>;
-            pipe<TNextOutput>(next: VldBase<string, TNextOutput>): import("./validators").VldPipe<unknown, string, TNextOutput>;
-            readonly(): import("./validators").VldReadonly<unknown, string>;
-            brand<TBrand extends string>(): import("./validators").VldBrand<unknown, string, TBrand>;
-            apply<TNewOutput>(fn: (schema: /*elided*/ any) => VldBase<unknown, TNewOutput>): VldBase<unknown, TNewOutput>;
+        readonly locales: typeof localeNamespace;
+        readonly NEVER: VldNever;
+        readonly TimePrecision: {
+            readonly Any: null;
+            readonly Minute: -1;
+            readonly Second: 0;
+            readonly Millisecond: 3;
+            readonly Microsecond: 6;
         };
-        duration: () => {
-            readonly _format: string;
-            readonly _validator: (val: string) => boolean;
-            readonly _errorMessage?: string | undefined;
-            parse(value: unknown): string;
-            safeParse(value: unknown): import("./validators").ParseResult<string>;
-            isValid(value: unknown): boolean;
-            parseOrDefault(value: unknown, defaultValue: string): string;
-            refine<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
-            refine(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
-            superRefine(refinement: (value: string, ctx: import("./validators").SuperRefineContext) => void | Promise<void>): import("./validators").VldSuperRefine<unknown, string>;
-            transform<TTransformed>(transformer: (value: string) => TTransformed): import("./validators").VldTransform<unknown, string, TTransformed>;
-            default(defaultValue: string): import("./validators").VldDefault<unknown, string>;
-            catch(fallbackValue: string): import("./validators").VldCatch<unknown, string>;
-            optional(): VldOptional<unknown, string>;
-            nullable(): VldNullable<unknown, string>;
-            nullish(): VldNullish<unknown, string>;
-            pipe<TNextOutput>(next: VldBase<string, TNextOutput>): import("./validators").VldPipe<unknown, string, TNextOutput>;
-            readonly(): import("./validators").VldReadonly<unknown, string>;
-            brand<TBrand extends string>(): import("./validators").VldBrand<unknown, string, TBrand>;
-            apply<TNewOutput>(fn: (schema: /*elided*/ any) => VldBase<unknown, TNewOutput>): VldBase<unknown, TNewOutput>;
+        readonly ZodIssueCode: {
+            readonly invalid_type: "invalid_type";
+            readonly too_big: "too_big";
+            readonly too_small: "too_small";
+            readonly invalid_format: "invalid_format";
+            readonly not_multiple_of: "not_multiple_of";
+            readonly unrecognized_keys: "unrecognized_keys";
+            readonly invalid_union: "invalid_union";
+            readonly invalid_key: "invalid_key";
+            readonly invalid_element: "invalid_element";
+            readonly invalid_value: "invalid_value";
+            readonly custom: "custom";
         };
+        readonly globalRegistry: import("./registry.js").SchemaRegistry<SchemaMetadata>;
+        readonly config: typeof configure;
+        readonly getErrorMap: typeof getGlobalErrorMap;
+        readonly setErrorMap: typeof setGlobalErrorMap;
+        readonly parse: <T>(schema: VldBase<unknown, T>, value: unknown) => T;
+        readonly safeParse: <T>(schema: VldBase<unknown, T>, value: unknown) => ParseResult<T>;
+        readonly parseAsync: <T>(schema: VldBase<unknown, T>, value: unknown) => Promise<T>;
+        readonly safeParseAsync: <T>(schema: VldBase<unknown, T>, value: unknown) => Promise<ParseResult<T>>;
+    };
+    util: {
+        readonly getParsedType: typeof getParsedType;
+        readonly propertyKeyTypes: Set<string>;
+        readonly primitiveTypes: Set<string>;
+        readonly assert: (condition: unknown, message?: string) => asserts condition;
+        readonly assertNever: (value: never) => never;
+        readonly joinValues: (values: readonly unknown[], separator?: string) => string;
+        readonly jsonStringifyReplacer: (_key: string, value: unknown) => unknown;
+        readonly nullish: (value: unknown) => value is null | undefined;
+        readonly cached: <T>(getter: () => T) => (() => T);
+    };
+    locales: typeof localeNamespace;
+    lazy: <T>(schemaGetter: () => VldBase<unknown, T>) => VldLazy<unknown, T>;
+    json: <T = unknown>(schema?: VldBase<unknown, T>) => VldJson<T>;
+    custom: <TOutput = unknown>(options: CustomValidatorOptions<TOutput>) => VldCustom<TOutput>;
+    file: () => VldFile;
+    function: () => VldFunction;
+    preprocess: <TInput, TOutput>(preprocessor: (input: unknown) => unknown, schema: VldBase<TInput, TOutput>) => VldPreprocess<TInput, TOutput>;
+    coerce: {
+        string: () => VldCoerceString;
+        number: () => VldCoerceNumber;
+        boolean: () => VldCoerceBoolean;
+        date: () => VldCoerceDate;
+        bigint: () => VldCoerceBigInt;
+    };
+    email: (options?: {
+        pattern?: RegExp;
+    }) => stringFormats.VldStringFormat;
+    url: () => VldString;
+    uuid: (options?: {
+        version?: "v4" | "v6" | "v7";
+    }) => stringFormats.VldStringFormat;
+    uuidv4: () => stringFormats.VldStringFormat;
+    uuidv6: () => stringFormats.VldStringFormat;
+    uuidv7: () => stringFormats.VldStringFormat;
+    hostname: () => stringFormats.VldStringFormat;
+    emoji: () => stringFormats.VldStringFormat;
+    base64: () => stringFormats.VldStringFormat;
+    base64url: () => stringFormats.VldStringFormat;
+    hex: () => stringFormats.VldStringFormat;
+    jwt: () => stringFormats.VldStringFormat;
+    nanoid: () => stringFormats.VldStringFormat;
+    cuid: () => stringFormats.VldStringFormat;
+    cuid2: () => stringFormats.VldStringFormat;
+    ulid: () => stringFormats.VldStringFormat;
+    ipv4: () => stringFormats.VldStringFormat;
+    ipv6: () => stringFormats.VldStringFormat;
+    mac: () => stringFormats.VldStringFormat;
+    cidrv4: () => stringFormats.VldStringFormat;
+    cidrv6: () => stringFormats.VldStringFormat;
+    e164: () => stringFormats.VldStringFormat;
+    hash: (algorithm: "md5" | "sha1" | "sha256" | "sha384" | "sha512") => stringFormats.VldStringFormat;
+    iso: {
+        date: () => stringFormats.VldStringFormat;
+        time: () => stringFormats.VldStringFormat;
+        dateTime: () => stringFormats.VldStringFormat;
+        duration: () => stringFormats.VldStringFormat;
     };
-    stringFormat: (name: string, validator: ((val: string) => boolean) | RegExp) => {
-        readonly _format: string;
-        readonly _validator: (val: string) => boolean;
-        readonly _errorMessage?: string | undefined;
-        parse(value: unknown): string;
-        safeParse(value: unknown): import("./validators").ParseResult<string>;
-        isValid(value: unknown): boolean;
-        parseOrDefault(value: unknown, defaultValue: string): string;
-        refine<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
-        refine(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
-        superRefine(refinement: (value: string, ctx: import("./validators").SuperRefineContext) => void | Promise<void>): import("./validators").VldSuperRefine<unknown, string>;
-        transform<TTransformed>(transformer: (value: string) => TTransformed): import("./validators").VldTransform<unknown, string, TTransformed>;
-        default(defaultValue: string): import("./validators").VldDefault<unknown, string>;
-        catch(fallbackValue: string): import("./validators").VldCatch<unknown, string>;
-        optional(): VldOptional<unknown, string>;
-        nullable(): VldNullable<unknown, string>;
-        nullish(): VldNullish<unknown, string>;
-        pipe<TNextOutput>(next: VldBase<string, TNextOutput>): import("./validators").VldPipe<unknown, string, TNextOutput>;
-        readonly(): import("./validators").VldReadonly<unknown, string>;
-        brand<TBrand extends string>(): import("./validators").VldBrand<unknown, string, TBrand>;
-        apply<TNewOutput>(fn: (schema: /*elided*/ any) => VldBase<unknown, TNewOutput>): VldBase<unknown, TNewOutput>;
+    stringFormat: (name: string, validator: ((val: string) => boolean) | RegExp) => stringFormats.VldStringFormat;
+    minLength: (value: number, message?: ErrorParam) => VldString;
+    maxLength: (value: number, message?: ErrorParam) => VldString;
+    length: (value: number, message?: ErrorParam) => VldString;
+    regex: (pattern: RegExp, message?: ErrorParam) => VldString;
+    startsWith: (value: string, message?: ErrorParam) => VldString;
+    endsWith: (value: string, message?: ErrorParam) => VldString;
+    includes: (value: string, message?: ErrorParam) => VldString;
+    trim: () => VldString;
+    toLowerCase: () => VldString;
+    lowercase: () => VldString;
+    toUpperCase: () => VldString;
+    uppercase: () => VldString;
+    gt: (value: number, message?: ErrorParam) => VldNumber;
+    gte: (value: number, message?: ErrorParam) => VldNumber;
+    lt: (value: number, message?: ErrorParam) => VldNumber;
+    lte: (value: number, message?: ErrorParam) => VldNumber;
+    positive: (message?: ErrorParam) => VldNumber;
+    negative: (message?: ErrorParam) => VldNumber;
+    nonnegative: (message?: ErrorParam) => VldNumber;
+    nonpositive: (message?: ErrorParam) => VldNumber;
+    multipleOf: (value: number, message?: ErrorParam) => VldNumber;
+    minSize: (value: number, message?: ErrorParam) => VldString;
+    maxSize: (value: number, message?: ErrorParam) => VldString;
+    size: (value: number, message?: ErrorParam) => VldString;
+    normalize: (form?: "NFC" | "NFD" | "NFKC" | "NFKD" | (string & {})) => VldTransform<string, string, string>;
+    slugify: () => VldTransform<string, string, string>;
+    mime: (types: string | string[], message?: string) => VldFile;
+    xid: () => stringFormats.VldStringFormat;
+    guid: () => stringFormats.VldStringFormat;
+    httpUrl: () => stringFormats.VldStringFormat;
+    ksuid: () => stringFormats.VldStringFormat;
+    regexes: {
+        readonly email: RegExp;
+        readonly uuid: RegExp;
+        readonly uuidv4: RegExp;
+        readonly uuidv6: RegExp;
+        readonly uuidv7: RegExp;
+        readonly hostname: RegExp;
+        readonly emoji: RegExp;
+        readonly base64: RegExp;
+        readonly base64url: RegExp;
+        readonly hex: RegExp;
+        readonly jwt: RegExp;
+        readonly nanoid: RegExp;
+        readonly cuid: RegExp;
+        readonly cuid2: RegExp;
+        readonly ulid: RegExp;
+        readonly ipv4: RegExp;
+        readonly ipv6: RegExp;
+        readonly mac: RegExp;
+        readonly cidrv4: RegExp;
+        readonly cidrv6: RegExp;
+        readonly e164: RegExp;
+        readonly isoDate: RegExp;
+        readonly isoTime: RegExp;
+        readonly isoDateTime: RegExp;
+        readonly md5: RegExp;
+        readonly sha1: RegExp;
+        readonly sha256: RegExp;
+        readonly sha384: RegExp;
+        readonly sha512: RegExp;
+        readonly xid: RegExp;
+        readonly guid: RegExp;
+        readonly httpUrl: RegExp;
+        readonly ksuid: RegExp;
     };
-    templateLiteral: (...components: (VldBase<any, any> | string)[]) => import("./validators").VldTemplateLiteral;
+    templateLiteral: (...components: (VldBase<any, any> | string)[]) => VldTemplateLiteral;
     base64Bytes: () => VldBase64;
     hexBytes: () => VldHex;
     uint8Array: () => VldUint8Array;
@@ -686,13 +1234,60 @@ export declare const v: {
         decode: (value: TInput) => TOutput | Promise<TOutput>;
         encode: (value: TOutput) => TInput | Promise<TInput>;
     }) => VldCodec<TInput, TOutput>;
+    invertCodec: <TInput, TOutput>(codec: VldCodec<TInput, TOutput>) => VldCodec<TOutput, TInput>;
+    promise: <T>(inner: VldBase<unknown, T>) => VldPromise<T>;
+    parse: <T>(schema: VldBase<unknown, T>, value: unknown) => T;
+    safeParse: <T>(schema: VldBase<unknown, T>, value: unknown) => ParseResult<T>;
+    parseAsync: <T>(schema: VldBase<unknown, T>, value: unknown) => Promise<T>;
+    safeParseAsync: <T>(schema: VldBase<unknown, T>, value: unknown) => Promise<ParseResult<T>>;
+    decode: <T>(schema: VldBase<unknown, T>, value: unknown) => T;
+    safeDecode: <T>(schema: VldBase<unknown, T>, value: unknown) => ParseResult<T>;
+    decodeAsync: <T>(schema: VldBase<unknown, T>, value: unknown) => Promise<T>;
+    safeDecodeAsync: <T>(schema: VldBase<unknown, T>, value: unknown) => Promise<ParseResult<T>>;
+    encode: <TInput, TOutput>(schema: VldBase<TInput, TOutput>, value: unknown) => TInput | TOutput;
+    safeEncode: <TInput, TOutput>(schema: VldBase<TInput, TOutput>, value: unknown) => ParseResult<TInput | TOutput>;
+    encodeAsync: <TInput, TOutput>(schema: VldBase<TInput, TOutput>, value: unknown) => Promise<TInput | TOutput>;
+    safeEncodeAsync: <TInput, TOutput>(schema: VldBase<TInput, TOutput>, value: unknown) => Promise<ParseResult<TInput | TOutput>>;
+    formatError: (error: Error) => FormattedError;
+    treeifyError: typeof treeifyErrorFn;
+    prettifyError: typeof prettifyErrorFn;
+    flattenError: typeof flattenErrorFn;
+    toJSONSchema: typeof toJSONSchemaFn;
 };
-export type { Result, VldResult } from './compat/result';
-export { Ok, Err, success, failure, isOk, isErr, isResult, unwrap, unwrapOr, map, mapErr, flatMap, match, tryCatch, tryCatchAsync, all, fromNullable, ResultUtils } from './compat/result';
-export { type EventMap, type EventHandler, type ListenerOptions, type Emitter, createEmitter, createEventBus, withEmitter } from './compat/emitter';
-export type { VldEvents, VldEventPayload, ParseStartEvent, ParseSuccessEvent, ParseErrorEvent, FieldValidationEvent, TransformEvent, PluginRegisteredEvent, LocaleChangedEvent, DebugEvent, MetricsEvent } from './events';
-export { createVldKernel, getVldKernel, resetVldKernel, usePlugin, definePlugin, type VldContext, type VldPlugin, type VldKernelInstance, type VldKernelOptions, type ValidatorFactory, type TransformFactory, type CodecFactory, type HookContext, type PluginBuilder, type PluginMeta, type PluginHooks } from './kernel';
-export { createLogger, initLogger, getLogger, setLogLevel, enableDebug, disableLogging, createNoOpLogger, type Logger, type LoggerOptions, type LogLevel, type LogEntry, type LogHandler } from './logger';
-export { pigment, supportsColor, bold, dim, italic, underline, red, green, yellow, blue, magenta, cyan, white, gray, grey, strip, vldTheme, createTheme, type Theme } from './pigment';
+declare const zodStringFactory: typeof VldString;
+export { catchFactory as catch, defaultFactory as _default, enumFactory as enum, functionFactory as function, functionFactory as _function, instanceOfFactory as instanceof, mapFactory as mapSchema, neverFactory as never, nullFactory as null, undefinedFactory as undefined, voidFactory as void, zodStringFactory as _ZodString };
+export declare function map<K, V>(key: VldBase<unknown, K>, value: VldBase<unknown, V>): VldMap<K, V>;
+export declare function map<T, U, E>(result: Result<T, E>, fn: (value: T) => U): Result<U, E>;
+export declare const minLength: (value: number, message?: ErrorParam) => VldString;
+export declare const maxLength: (value: number, message?: ErrorParam) => VldString;
+export declare const length: (value: number, message?: ErrorParam) => VldString;
+export declare const regex: (pattern: RegExp, message?: ErrorParam) => VldString;
+export declare const startsWith: (value: string, message?: ErrorParam) => VldString;
+export declare const endsWith: (value: string, message?: ErrorParam) => VldString;
+export declare const includes: (value: string, message?: ErrorParam) => VldString;
+export declare const trim: () => VldString;
+export declare const toLowerCase: () => VldString;
+export declare const lowercase: () => VldString;
+export declare const toUpperCase: () => VldString;
+export declare const uppercase: () => VldString;
+export declare const gt: (value: number, message?: ErrorParam) => VldNumber;
+export declare const gte: (value: number, message?: ErrorParam) => VldNumber;
+export declare const lt: (value: number, message?: ErrorParam) => VldNumber;
+export declare const lte: (value: number, message?: ErrorParam) => VldNumber;
+export declare const positive: (message?: ErrorParam) => VldNumber;
+export declare const negative: (message?: ErrorParam) => VldNumber;
+export declare const nonnegative: (message?: ErrorParam) => VldNumber;
+export declare const nonpositive: (message?: ErrorParam) => VldNumber;
+export declare const multipleOf: (value: number, message?: ErrorParam) => VldNumber;
+export declare const minSize: (value: number, message?: ErrorParam) => VldString;
+export declare const maxSize: (value: number, message?: ErrorParam) => VldString;
+export declare const size: (value: number, message?: ErrorParam) => VldString;
+export type { Result, VldResult } from './compat/result.js';
+export { Ok, Err, success, failure, isOk, isErr, isResult, unwrap, unwrapOr, mapErr, flatMap, match, tryCatch, tryCatchAsync, all, fromNullable, ResultUtils } from './compat/result.js';
+export { type EventMap, type EventHandler, type ListenerOptions, type Emitter, createEmitter, createEventBus, withEmitter } from './compat/emitter.js';
+export type { VldEvents, VldEventPayload, ParseStartEvent, ParseSuccessEvent, ParseErrorEvent, FieldValidationEvent, TransformEvent, PluginRegisteredEvent, LocaleChangedEvent, DebugEvent, MetricsEvent } from './events.js';
+export { createVldKernel, getVldKernel, resetVldKernel, usePlugin, definePlugin, type VldContext, type VldPlugin, type VldKernelInstance, type VldKernelOptions, type ValidatorFactory, type TransformFactory, type CodecFactory, type HookContext, type PluginBuilder, type PluginMeta, type PluginHooks } from './kernel.js';
+export { createLogger, initLogger, getLogger, setLogLevel, enableDebug, disableLogging, createNoOpLogger, type Logger, type LoggerOptions, type LogLevel, type LogEntry, type LogHandler } from './logger.js';
+export { pigment, supportsColor, bold, dim, italic, underline, red, green, yellow, blue, magenta, cyan, white, gray, grey, strip, vldTheme, createTheme, type Theme } from './pigment.js';
+export { toJSONSchema, fromJSONSchema, type JSONSchemaDefinition, type ToJSONSchemaOptions } from './utils/json-schema.js';
 export default v;
-//# sourceMappingURL=index.d.ts.map