@oxog/vld 2.0.3 → 2.2.5

package/dist/index.d.ts

@@ -13,60 +13,222 @@
  * - 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 { VldExactOptional } 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 { VldMeta, type SchemaMetadata } from './validators/base';
-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, type LiteralValue } 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 { fromJSONSchema as fromJSONSchemaFn, 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<Record<"number" | "bigint" | "boolean" | "undefined" | "integer" | "null" | "date" | "hex" | "base64" | "email" | "base64url" | "jwt" | "nanoid" | "cuid" | "cuid2" | "ulid" | "cidrv4" | "cidrv6" | "e164" | "xid" | "guid" | "ksuid" | "duration" | "ipv4" | "ipv6" | "browserEmail" | "creditCard" | "domain" | "extendedDuration" | "hostname" | "html5Email" | "httpProtocol" | "httpUrl" | "idnEmail" | "lowercase" | "md5" | "md5_base64" | "md5_base64url" | "md5_hex" | "rfc5322Email" | "sha1" | "sha1_base64" | "sha1_base64url" | "sha1_hex" | "sha256" | "sha256_base64" | "sha256_base64url" | "sha256_hex" | "sha384" | "sha384_base64" | "sha384_base64url" | "sha384_hex" | "sha512" | "sha512_base64" | "sha512_base64url" | "sha512_hex" | "unicodeEmail" | "uppercase" | "uuid4" | "uuid6" | "uuid7", RegExp> & {
+        datetime: (options?: stringFormats.ISODateTimeOptions) => RegExp;
+        emoji: () => RegExp;
+        mac: (delimiter?: string) => RegExp;
+        string: (options?: {
+            minimum?: number;
+            maximum?: number;
+        }) => RegExp;
+        time: (options?: stringFormats.ISOTimeOptions) => RegExp;
+        uuid: (version?: number) => 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 ZodCreditCard, 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';
+type AnySchema = VldBase<any, any>;
+type EnumValue = string | number;
+type ShapeSchema = {
+    parse(value: unknown): any;
+};
+type SchemaOutput<T extends ShapeSchema> = ReturnType<T['parse']>;
+type ObjectOutput<T extends Record<string, ShapeSchema>> = {
+    [K in keyof T as undefined extends SchemaOutput<T[K]> ? never : K]: SchemaOutput<T[K]>;
+} & {
+    [K in keyof T as undefined extends SchemaOutput<T[K]> ? K : never]?: SchemaOutput<T[K]>;
+};
+declare function objectFactory<const T extends Record<string, ShapeSchema> = Record<never, never>>(shape?: T): VldObject<ObjectOutput<T>>;
+declare function strictObjectFactory<const T extends Record<string, ShapeSchema>>(shape: T): VldObject<ObjectOutput<T>>;
+declare function looseObjectFactory<const T extends Record<string, ShapeSchema>>(shape: T): VldObject<ObjectOutput<T>>;
+declare function tupleFactory<const T extends readonly AnySchema[], TRest extends AnySchema>(items: T, rest: TRest, params?: unknown): VldTuple<T, TRest>;
+declare function tupleFactory<const T extends readonly AnySchema[]>(items: T, params?: string | Record<string, unknown>): VldTuple<T>;
+declare function tupleFactory<const T extends readonly AnySchema[]>(...items: T): VldTuple<T>;
+declare function unionFactory<const T extends readonly AnySchema[]>(options: T, params?: unknown): VldUnion<T>;
+declare function unionFactory<const T extends readonly AnySchema[]>(...options: T): VldUnion<T>;
+declare function xorFactory<const T extends readonly AnySchema[]>(options: T, params?: unknown): VldXor<T>;
+declare function xorFactory<const T extends readonly AnySchema[]>(...options: T): VldXor<T>;
+declare function discriminatedUnionFactory<K extends string, const T extends readonly AnySchema[]>(discriminator: K, options: T, params?: unknown): VldDiscriminatedUnion<K, T>;
+declare function discriminatedUnionFactory<K extends string, const T extends readonly AnySchema[]>(discriminator: K, ...options: T): VldDiscriminatedUnion<K, T>;
+declare function recordFactory<V>(value: VldBase<unknown, V>): VldRecord<V>;
+declare function recordFactory<K extends PropertyKey, V>(key: VldBase<unknown, K>, value: VldBase<unknown, V>, params?: unknown): VldRecord<V, K>;
+declare function partialRecordFactory<V>(value: VldBase<unknown, V>): VldRecord<V | undefined>;
+declare function partialRecordFactory<K extends PropertyKey, V>(key: VldBase<unknown, K>, value: VldBase<unknown, V>, params?: unknown): VldRecord<V | undefined, K>;
+declare function looseRecordFactory<V>(value: VldBase<unknown, V>): VldBase<unknown, Record<string, V>>;
+declare function looseRecordFactory<K extends PropertyKey, V>(key: VldBase<unknown, K>, value: VldBase<unknown, V>, params?: unknown): VldBase<unknown, Record<K, V>>;
+declare function literalFactory<const T extends readonly LiteralValue[]>(values: T, params?: unknown): VldLiteral<T[number]>;
+declare function literalFactory<const T extends LiteralValue>(value: T, params?: unknown): VldLiteral<T>;
+declare function enumFactoryCompat<const T extends readonly [EnumValue, ...EnumValue[]]>(values: T, params?: unknown): VldEnum<T>;
+declare function enumFactoryCompat<const T extends readonly [EnumValue, ...EnumValue[]]>(...values: T): VldEnum<T>;
+declare function enumFactoryCompat<T extends NativeEnumLike>(entries: T, params?: unknown): VldEnum<any>;
+/** Returns a copy of the schema with every nested object's properties made optional. */
+export declare function deepPartial<T extends AnySchema>(schema: T): T;
+/** Returns a copy of the schema with every pipe replaced by its input side. */
+export declare function input<T extends AnySchema>(schema: T): T;
+/** Returns a copy of the schema with every pipe replaced by its output side. */
+export declare function output<T extends AnySchema>(schema: T): T;
 /**
  * Main API object with factory methods for all validators
  */
@@ -90,21 +252,26 @@ export declare const v: {
         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>>;
+    object: typeof objectFactory;
+    strictObject: typeof strictObjectFactory;
+    looseObject: typeof looseObjectFactory;
+    tuple: typeof tupleFactory;
+    record: typeof recordFactory;
+    partialRecord: typeof partialRecordFactory;
+    looseRecord: typeof looseRecordFactory;
     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]>;
+    union: typeof unionFactory;
     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>;
-    literal: <T extends string | number | boolean | null | undefined>(value: T) => VldLiteral<T>;
-    enum: <T extends readonly [string, ...string[]]>(...values: T) => VldEnum<any>;
+    discriminatedUnion: typeof discriminatedUnionFactory;
+    xor: typeof xorFactory;
+    keyof: <T extends Record<string, any>>(schema: VldObject<T>) => VldEnum<[string, ...string[]]>;
+    deepPartial: typeof deepPartial;
+    input: typeof input;
+    output: typeof output;
+    literal: typeof literalFactory;
+    enum: typeof enumFactoryCompat;
+    nativeEnum: <T extends NativeEnumLike>(enumObject: T) => VldEnum<any>;
     any: () => VldAny;
     unknown: () => VldUnknown;
     void: () => VldVoid;
@@ -113,15 +280,120 @@ 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: <TInput, TOutput>(validator: VldBase<TInput, TOutput>, defaultValue: TInput | (() => TInput)) => VldPrefault<TInput, TOutput>;
+    readonly: <T>(validator: VldBase<unknown, T>) => VldReadonly<unknown, T>;
+    pipe: <TInput, TIntermediate, TOutput>(first: VldBase<TInput, TIntermediate>, second: VldBase<any, 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<Record<"number" | "bigint" | "boolean" | "undefined" | "integer" | "null" | "date" | "hex" | "base64" | "email" | "base64url" | "jwt" | "nanoid" | "cuid" | "cuid2" | "ulid" | "cidrv4" | "cidrv6" | "e164" | "xid" | "guid" | "ksuid" | "duration" | "ipv4" | "ipv6" | "browserEmail" | "creditCard" | "domain" | "extendedDuration" | "hostname" | "html5Email" | "httpProtocol" | "httpUrl" | "idnEmail" | "lowercase" | "md5" | "md5_base64" | "md5_base64url" | "md5_hex" | "rfc5322Email" | "sha1" | "sha1_base64" | "sha1_base64url" | "sha1_hex" | "sha256" | "sha256_base64" | "sha256_base64url" | "sha256_hex" | "sha384" | "sha384_base64" | "sha384_base64url" | "sha384_hex" | "sha512" | "sha512_base64" | "sha512_base64url" | "sha512_hex" | "unicodeEmail" | "uppercase" | "uuid4" | "uuid6" | "uuid7", RegExp> & {
+            datetime: (options?: stringFormats.ISODateTimeOptions) => RegExp;
+            emoji: () => RegExp;
+            mac: (delimiter?: string) => RegExp;
+            string: (options?: {
+                minimum?: number;
+                maximum?: number;
+            }) => RegExp;
+            time: (options?: stringFormats.ISOTimeOptions) => RegExp;
+            uuid: (version?: number) => 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;
@@ -132,795 +404,719 @@ 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>;
-        exactOptional(): VldExactOptional<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>;
-        check<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
-        check(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
-        meta(): import("./validators/base").SchemaMetadata | undefined;
-        meta(data: Partial<import("./validators/base").SchemaMetadata>): import("./validators/base").VldMeta<unknown, string>;
-        describe(description: string): import("./validators/base").VldMeta<unknown, string>;
-    };
+    }) => stringFormats.VldStringFormat;
+    url: (options?: stringFormats.URLFormatOptions) => stringFormats.VldStringFormat;
     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>;
-        exactOptional(): VldExactOptional<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>;
-        check<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
-        check(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
-        meta(): import("./validators/base").SchemaMetadata | undefined;
-        meta(data: Partial<import("./validators/base").SchemaMetadata>): import("./validators/base").VldMeta<unknown, string>;
-        describe(description: string): import("./validators/base").VldMeta<unknown, string>;
-    };
-    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>;
-        exactOptional(): VldExactOptional<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>;
-        check<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
-        check(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
-        meta(): import("./validators/base").SchemaMetadata | undefined;
-        meta(data: Partial<import("./validators/base").SchemaMetadata>): import("./validators/base").VldMeta<unknown, string>;
-        describe(description: string): import("./validators/base").VldMeta<unknown, string>;
-    };
-    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>;
-        exactOptional(): VldExactOptional<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>;
-        check<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
-        check(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
-        meta(): import("./validators/base").SchemaMetadata | undefined;
-        meta(data: Partial<import("./validators/base").SchemaMetadata>): import("./validators/base").VldMeta<unknown, string>;
-        describe(description: string): import("./validators/base").VldMeta<unknown, string>;
-    };
-    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>;
-        exactOptional(): VldExactOptional<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>;
-        check<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
-        check(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
-        meta(): import("./validators/base").SchemaMetadata | undefined;
-        meta(data: Partial<import("./validators/base").SchemaMetadata>): import("./validators/base").VldMeta<unknown, string>;
-        describe(description: string): import("./validators/base").VldMeta<unknown, string>;
-    };
-    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>;
-        exactOptional(): VldExactOptional<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>;
-        check<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
-        check(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
-        meta(): import("./validators/base").SchemaMetadata | undefined;
-        meta(data: Partial<import("./validators/base").SchemaMetadata>): import("./validators/base").VldMeta<unknown, string>;
-        describe(description: string): import("./validators/base").VldMeta<unknown, string>;
-    };
-    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>;
-        exactOptional(): VldExactOptional<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>;
-        check<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
-        check(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
-        meta(): import("./validators/base").SchemaMetadata | undefined;
-        meta(data: Partial<import("./validators/base").SchemaMetadata>): import("./validators/base").VldMeta<unknown, string>;
-        describe(description: string): import("./validators/base").VldMeta<unknown, string>;
-    };
-    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>;
-        exactOptional(): VldExactOptional<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>;
-        check<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
-        check(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
-        meta(): import("./validators/base").SchemaMetadata | undefined;
-        meta(data: Partial<import("./validators/base").SchemaMetadata>): import("./validators/base").VldMeta<unknown, string>;
-        describe(description: string): import("./validators/base").VldMeta<unknown, string>;
-    };
-    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>;
-        exactOptional(): VldExactOptional<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>;
-        check<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
-        check(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
-        meta(): import("./validators/base").SchemaMetadata | undefined;
-        meta(data: Partial<import("./validators/base").SchemaMetadata>): import("./validators/base").VldMeta<unknown, string>;
-        describe(description: string): import("./validators/base").VldMeta<unknown, string>;
-    };
-    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>;
-        exactOptional(): VldExactOptional<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>;
-        check<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
-        check(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
-        meta(): import("./validators/base").SchemaMetadata | undefined;
-        meta(data: Partial<import("./validators/base").SchemaMetadata>): import("./validators/base").VldMeta<unknown, string>;
-        describe(description: string): import("./validators/base").VldMeta<unknown, string>;
-    };
-    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>;
-        exactOptional(): VldExactOptional<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>;
-        check<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
-        check(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
-        meta(): import("./validators/base").SchemaMetadata | undefined;
-        meta(data: Partial<import("./validators/base").SchemaMetadata>): import("./validators/base").VldMeta<unknown, string>;
-        describe(description: string): import("./validators/base").VldMeta<unknown, string>;
-    };
-    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>;
-        exactOptional(): VldExactOptional<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>;
-        check<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
-        check(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
-        meta(): import("./validators/base").SchemaMetadata | undefined;
-        meta(data: Partial<import("./validators/base").SchemaMetadata>): import("./validators/base").VldMeta<unknown, string>;
-        describe(description: string): import("./validators/base").VldMeta<unknown, string>;
+        version?: stringFormats.UUIDVersion;
+    }) => 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;
+    creditCard: (params?: {
+        message?: string;
+    }) => stringFormats.VldStringFormat;
+    e164: () => stringFormats.VldStringFormat;
+    hash: (algorithm: "md5" | "sha1" | "sha256" | "sha384" | "sha512") => stringFormats.VldStringFormat;
+    iso: {
+        ZodISODate: typeof stringFormats.VldStringFormat;
+        ZodISODateTime: typeof stringFormats.VldStringFormat;
+        ZodISODuration: typeof stringFormats.VldStringFormat;
+        ZodISOTime: typeof stringFormats.VldStringFormat;
+        date: () => stringFormats.VldStringFormat;
+        time: (options?: stringFormats.ISOTimeOptions) => stringFormats.VldStringFormat;
+        datetime: (options?: stringFormats.ISODateTimeOptions) => stringFormats.VldStringFormat;
+        dateTime: (options?: stringFormats.ISODateTimeOptions) => stringFormats.VldStringFormat;
+        duration: () => stringFormats.VldStringFormat;
     };
-    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>;
-        exactOptional(): VldExactOptional<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>;
-        check<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
-        check(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
-        meta(): import("./validators/base").SchemaMetadata | undefined;
-        meta(data: Partial<import("./validators/base").SchemaMetadata>): import("./validators/base").VldMeta<unknown, string>;
-        describe(description: string): import("./validators/base").VldMeta<unknown, string>;
+    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<Record<"number" | "bigint" | "boolean" | "undefined" | "integer" | "null" | "date" | "hex" | "base64" | "email" | "base64url" | "jwt" | "nanoid" | "cuid" | "cuid2" | "ulid" | "cidrv4" | "cidrv6" | "e164" | "xid" | "guid" | "ksuid" | "duration" | "ipv4" | "ipv6" | "browserEmail" | "creditCard" | "domain" | "extendedDuration" | "hostname" | "html5Email" | "httpProtocol" | "httpUrl" | "idnEmail" | "lowercase" | "md5" | "md5_base64" | "md5_base64url" | "md5_hex" | "rfc5322Email" | "sha1" | "sha1_base64" | "sha1_base64url" | "sha1_hex" | "sha256" | "sha256_base64" | "sha256_base64url" | "sha256_hex" | "sha384" | "sha384_base64" | "sha384_base64url" | "sha384_hex" | "sha512" | "sha512_base64" | "sha512_base64url" | "sha512_hex" | "unicodeEmail" | "uppercase" | "uuid4" | "uuid6" | "uuid7", RegExp> & {
+        datetime: (options?: stringFormats.ISODateTimeOptions) => RegExp;
+        emoji: () => RegExp;
+        mac: (delimiter?: string) => RegExp;
+        string: (options?: {
+            minimum?: number;
+            maximum?: number;
+        }) => RegExp;
+        time: (options?: stringFormats.ISOTimeOptions) => RegExp;
+        uuid: (version?: number) => 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>;
+    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: TOutput) => TInput;
+    safeEncode: <TInput, TOutput>(schema: VldBase<TInput, TOutput>, value: TOutput) => ParseResult<TInput>;
+    encodeAsync: <TInput, TOutput>(schema: VldBase<TInput, TOutput>, value: TOutput) => Promise<TInput>;
+    safeEncodeAsync: <TInput, TOutput>(schema: VldBase<TInput, TOutput>, value: TOutput) => Promise<ParseResult<TInput>>;
+    formatError: (error: Error) => FormattedError;
+    treeifyError: typeof treeifyErrorFn;
+    prettifyError: typeof prettifyErrorFn;
+    flattenError: typeof flattenErrorFn;
+    toJSONSchema: typeof toJSONSchemaFn;
+    fromJSONSchema: typeof fromJSONSchemaFn;
+};
+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: typeof objectFactory;
+    strictObject: typeof strictObjectFactory;
+    looseObject: typeof looseObjectFactory;
+    tuple: typeof tupleFactory;
+    record: typeof recordFactory;
+    partialRecord: typeof partialRecordFactory;
+    looseRecord: typeof looseRecordFactory;
+    set: <T>(item: VldBase<unknown, T>) => VldSet<T>;
+    map: <K, V>(key: VldBase<unknown, K>, value: VldBase<unknown, V>) => VldMap<K, V>;
+    union: typeof unionFactory;
+    intersection: <A, B>(first: VldBase<unknown, A>, second: VldBase<unknown, B>) => VldIntersection<A, B>;
+    discriminatedUnion: typeof discriminatedUnionFactory;
+    xor: typeof xorFactory;
+    keyof: <T extends Record<string, any>>(schema: VldObject<T>) => VldEnum<[string, ...string[]]>;
+    deepPartial: typeof deepPartial;
+    input: typeof input;
+    output: typeof output;
+    literal: typeof literalFactory;
+    enum: typeof enumFactoryCompat;
+    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;
     };
-    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>;
-        exactOptional(): VldExactOptional<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>;
-        check<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
-        check(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
-        meta(): import("./validators/base").SchemaMetadata | undefined;
-        meta(data: Partial<import("./validators/base").SchemaMetadata>): import("./validators/base").VldMeta<unknown, string>;
-        describe(description: string): import("./validators/base").VldMeta<unknown, string>;
+    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";
     };
-    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>;
-        exactOptional(): VldExactOptional<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>;
-        check<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
-        check(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
-        meta(): import("./validators/base").SchemaMetadata | undefined;
-        meta(data: Partial<import("./validators/base").SchemaMetadata>): import("./validators/base").VldMeta<unknown, string>;
-        describe(description: string): import("./validators/base").VldMeta<unknown, string>;
+    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: <TInput, TOutput>(validator: VldBase<TInput, TOutput>, defaultValue: TInput | (() => TInput)) => VldPrefault<TInput, TOutput>;
+    readonly: <T>(validator: VldBase<unknown, T>) => VldReadonly<unknown, T>;
+    pipe: <TInput, TIntermediate, TOutput>(first: VldBase<TInput, TIntermediate>, second: VldBase<any, 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<Record<"number" | "bigint" | "boolean" | "undefined" | "integer" | "null" | "date" | "hex" | "base64" | "email" | "base64url" | "jwt" | "nanoid" | "cuid" | "cuid2" | "ulid" | "cidrv4" | "cidrv6" | "e164" | "xid" | "guid" | "ksuid" | "duration" | "ipv4" | "ipv6" | "browserEmail" | "creditCard" | "domain" | "extendedDuration" | "hostname" | "html5Email" | "httpProtocol" | "httpUrl" | "idnEmail" | "lowercase" | "md5" | "md5_base64" | "md5_base64url" | "md5_hex" | "rfc5322Email" | "sha1" | "sha1_base64" | "sha1_base64url" | "sha1_hex" | "sha256" | "sha256_base64" | "sha256_base64url" | "sha256_hex" | "sha384" | "sha384_base64" | "sha384_base64url" | "sha384_hex" | "sha512" | "sha512_base64" | "sha512_base64url" | "sha512_hex" | "unicodeEmail" | "uppercase" | "uuid4" | "uuid6" | "uuid7", RegExp> & {
+            datetime: (options?: stringFormats.ISODateTimeOptions) => RegExp;
+            emoji: () => RegExp;
+            mac: (delimiter?: string) => RegExp;
+            string: (options?: {
+                minimum?: number;
+                maximum?: number;
+            }) => RegExp;
+            time: (options?: stringFormats.ISOTimeOptions) => RegExp;
+            uuid: (version?: number) => 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>>;
     };
-    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>;
-        exactOptional(): VldExactOptional<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>;
-        check<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
-        check(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
-        meta(): import("./validators/base").SchemaMetadata | undefined;
-        meta(data: Partial<import("./validators/base").SchemaMetadata>): import("./validators/base").VldMeta<unknown, string>;
-        describe(description: string): import("./validators/base").VldMeta<unknown, string>;
+    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);
     };
-    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>;
-        exactOptional(): VldExactOptional<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>;
-        check<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
-        check(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
-        meta(): import("./validators/base").SchemaMetadata | undefined;
-        meta(data: Partial<import("./validators/base").SchemaMetadata>): import("./validators/base").VldMeta<unknown, string>;
-        describe(description: string): import("./validators/base").VldMeta<unknown, string>;
+    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;
     };
-    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>;
-        exactOptional(): VldExactOptional<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>;
-        check<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
-        check(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
-        meta(): import("./validators/base").SchemaMetadata | undefined;
-        meta(data: Partial<import("./validators/base").SchemaMetadata>): import("./validators/base").VldMeta<unknown, string>;
-        describe(description: string): import("./validators/base").VldMeta<unknown, string>;
+    email: (options?: {
+        pattern?: RegExp;
+    }) => stringFormats.VldStringFormat;
+    url: (options?: stringFormats.URLFormatOptions) => stringFormats.VldStringFormat;
+    uuid: (options?: {
+        version?: stringFormats.UUIDVersion;
+    }) => 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;
+    creditCard: (params?: {
+        message?: string;
+    }) => stringFormats.VldStringFormat;
+    e164: () => stringFormats.VldStringFormat;
+    hash: (algorithm: "md5" | "sha1" | "sha256" | "sha384" | "sha512") => stringFormats.VldStringFormat;
+    iso: {
+        ZodISODate: typeof stringFormats.VldStringFormat;
+        ZodISODateTime: typeof stringFormats.VldStringFormat;
+        ZodISODuration: typeof stringFormats.VldStringFormat;
+        ZodISOTime: typeof stringFormats.VldStringFormat;
+        date: () => stringFormats.VldStringFormat;
+        time: (options?: stringFormats.ISOTimeOptions) => stringFormats.VldStringFormat;
+        datetime: (options?: stringFormats.ISODateTimeOptions) => stringFormats.VldStringFormat;
+        dateTime: (options?: stringFormats.ISODateTimeOptions) => stringFormats.VldStringFormat;
+        duration: () => stringFormats.VldStringFormat;
     };
-    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>;
-        exactOptional(): VldExactOptional<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>;
-        check<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
-        check(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
-        meta(): import("./validators/base").SchemaMetadata | undefined;
-        meta(data: Partial<import("./validators/base").SchemaMetadata>): import("./validators/base").VldMeta<unknown, string>;
-        describe(description: string): import("./validators/base").VldMeta<unknown, string>;
+    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<Record<"number" | "bigint" | "boolean" | "undefined" | "integer" | "null" | "date" | "hex" | "base64" | "email" | "base64url" | "jwt" | "nanoid" | "cuid" | "cuid2" | "ulid" | "cidrv4" | "cidrv6" | "e164" | "xid" | "guid" | "ksuid" | "duration" | "ipv4" | "ipv6" | "browserEmail" | "creditCard" | "domain" | "extendedDuration" | "hostname" | "html5Email" | "httpProtocol" | "httpUrl" | "idnEmail" | "lowercase" | "md5" | "md5_base64" | "md5_base64url" | "md5_hex" | "rfc5322Email" | "sha1" | "sha1_base64" | "sha1_base64url" | "sha1_hex" | "sha256" | "sha256_base64" | "sha256_base64url" | "sha256_hex" | "sha384" | "sha384_base64" | "sha384_base64url" | "sha384_hex" | "sha512" | "sha512_base64" | "sha512_base64url" | "sha512_hex" | "unicodeEmail" | "uppercase" | "uuid4" | "uuid6" | "uuid7", RegExp> & {
+        datetime: (options?: stringFormats.ISODateTimeOptions) => RegExp;
+        emoji: () => RegExp;
+        mac: (delimiter?: string) => RegExp;
+        string: (options?: {
+            minimum?: number;
+            maximum?: number;
+        }) => RegExp;
+        time: (options?: stringFormats.ISOTimeOptions) => RegExp;
+        uuid: (version?: number) => 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>;
+    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: TOutput) => TInput;
+    safeEncode: <TInput, TOutput>(schema: VldBase<TInput, TOutput>, value: TOutput) => ParseResult<TInput>;
+    encodeAsync: <TInput, TOutput>(schema: VldBase<TInput, TOutput>, value: TOutput) => Promise<TInput>;
+    safeEncodeAsync: <TInput, TOutput>(schema: VldBase<TInput, TOutput>, value: TOutput) => Promise<ParseResult<TInput>>;
+    formatError: (error: Error) => FormattedError;
+    treeifyError: typeof treeifyErrorFn;
+    prettifyError: typeof prettifyErrorFn;
+    flattenError: typeof flattenErrorFn;
+    toJSONSchema: typeof toJSONSchemaFn;
+    fromJSONSchema: typeof fromJSONSchemaFn;
+};
+/**
+ * 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: typeof objectFactory, strictObject: typeof strictObjectFactory, looseObject: typeof looseObjectFactory, tuple: typeof tupleFactory, record: typeof recordFactory, partialRecord: typeof partialRecordFactory, looseRecord: typeof looseRecordFactory, set: <T>(item: VldBase<unknown, T>) => VldSet<T>, union: typeof unionFactory, intersection: <A, B>(first: VldBase<unknown, A>, second: VldBase<unknown, B>) => VldIntersection<A, B>, discriminatedUnion: typeof discriminatedUnionFactory, xor: typeof xorFactory, keyof: <T extends Record<string, any>>(schema: VldObject<T>) => VldEnum<[string, ...string[]]>, literal: typeof literalFactory, 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<any, 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: (options?: stringFormats.URLFormatOptions) => stringFormats.VldStringFormat, uuid: (options?: {
+    version?: stringFormats.UUIDVersion;
+}) => 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, creditCard: (params?: {
+    message?: string;
+}) => stringFormats.VldStringFormat, e164: () => stringFormats.VldStringFormat, hash: (algorithm: "md5" | "sha1" | "sha256" | "sha384" | "sha512") => stringFormats.VldStringFormat, iso: {
+    ZodISODate: typeof stringFormats.VldStringFormat;
+    ZodISODateTime: typeof stringFormats.VldStringFormat;
+    ZodISODuration: typeof stringFormats.VldStringFormat;
+    ZodISOTime: typeof stringFormats.VldStringFormat;
+    date: () => stringFormats.VldStringFormat;
+    time: (options?: stringFormats.ISOTimeOptions) => stringFormats.VldStringFormat;
+    datetime: (options?: stringFormats.ISODateTimeOptions) => stringFormats.VldStringFormat;
+    dateTime: (options?: stringFormats.ISODateTimeOptions) => 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<Record<"number" | "bigint" | "boolean" | "undefined" | "integer" | "null" | "date" | "hex" | "base64" | "email" | "base64url" | "jwt" | "nanoid" | "cuid" | "cuid2" | "ulid" | "cidrv4" | "cidrv6" | "e164" | "xid" | "guid" | "ksuid" | "duration" | "ipv4" | "ipv6" | "browserEmail" | "creditCard" | "domain" | "extendedDuration" | "hostname" | "html5Email" | "httpProtocol" | "httpUrl" | "idnEmail" | "lowercase" | "md5" | "md5_base64" | "md5_base64url" | "md5_hex" | "rfc5322Email" | "sha1" | "sha1_base64" | "sha1_base64url" | "sha1_hex" | "sha256" | "sha256_base64" | "sha256_base64url" | "sha256_hex" | "sha384" | "sha384_base64" | "sha384_base64url" | "sha384_hex" | "sha512" | "sha512_base64" | "sha512_base64url" | "sha512_hex" | "unicodeEmail" | "uppercase" | "uuid4" | "uuid6" | "uuid7", RegExp> & {
+    datetime: (options?: stringFormats.ISODateTimeOptions) => RegExp;
+    emoji: () => RegExp;
+    mac: (delimiter?: string) => RegExp;
+    string: (options?: {
+        minimum?: number;
+        maximum?: number;
+    }) => RegExp;
+    time: (options?: stringFormats.ISOTimeOptions) => RegExp;
+    uuid: (version?: number) => 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: <TInput, TOutput>(validator: VldBase<TInput, TOutput>, defaultValue: TInput | (() => TInput)) => VldPrefault<TInput, TOutput>, 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: TOutput) => TInput, safeEncode: <TInput, TOutput>(schema: VldBase<TInput, TOutput>, value: TOutput) => ParseResult<TInput>, encodeAsync: <TInput, TOutput>(schema: VldBase<TInput, TOutput>, value: TOutput) => Promise<TInput>, safeEncodeAsync: <TInput, TOutput>(schema: VldBase<TInput, TOutput>, value: TOutput) => Promise<ParseResult<TInput>>, formatError: (error: Error) => FormattedError, NEVER: VldNever;
+declare const catchFactory: <T>(validator: VldBase<unknown, T>, fallbackValue: T) => VldCatch<unknown, T>;
+declare const enumFactory: typeof enumFactoryCompat;
+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: typeof objectFactory;
+    strictObject: typeof strictObjectFactory;
+    looseObject: typeof looseObjectFactory;
+    tuple: typeof tupleFactory;
+    record: typeof recordFactory;
+    partialRecord: typeof partialRecordFactory;
+    looseRecord: typeof looseRecordFactory;
+    set: <T>(item: VldBase<unknown, T>) => VldSet<T>;
+    map: <K, V>(key: VldBase<unknown, K>, value: VldBase<unknown, V>) => VldMap<K, V>;
+    union: typeof unionFactory;
+    intersection: <A, B>(first: VldBase<unknown, A>, second: VldBase<unknown, B>) => VldIntersection<A, B>;
+    discriminatedUnion: typeof discriminatedUnionFactory;
+    xor: typeof xorFactory;
+    keyof: <T extends Record<string, any>>(schema: VldObject<T>) => VldEnum<[string, ...string[]]>;
+    deepPartial: typeof deepPartial;
+    input: typeof input;
+    output: typeof output;
+    literal: typeof literalFactory;
+    enum: typeof enumFactoryCompat;
+    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>;
-        exactOptional(): VldExactOptional<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>;
-        check<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
-        check(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
-        meta(): import("./validators/base").SchemaMetadata | undefined;
-        meta(data: Partial<import("./validators/base").SchemaMetadata>): import("./validators/base").VldMeta<unknown, string>;
-        describe(description: string): import("./validators/base").VldMeta<unknown, string>;
+    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>;
-            exactOptional(): VldExactOptional<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>;
-            check<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
-            check(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
-            meta(): import("./validators/base").SchemaMetadata | undefined;
-            meta(data: Partial<import("./validators/base").SchemaMetadata>): import("./validators/base").VldMeta<unknown, string>;
-            describe(description: string): import("./validators/base").VldMeta<unknown, string>;
-        };
-        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>;
-            exactOptional(): VldExactOptional<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>;
-            check<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
-            check(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
-            meta(): import("./validators/base").SchemaMetadata | undefined;
-            meta(data: Partial<import("./validators/base").SchemaMetadata>): import("./validators/base").VldMeta<unknown, string>;
-            describe(description: string): import("./validators/base").VldMeta<unknown, string>;
+    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: <TInput, TOutput>(validator: VldBase<TInput, TOutput>, defaultValue: TInput | (() => TInput)) => VldPrefault<TInput, TOutput>;
+    readonly: <T>(validator: VldBase<unknown, T>) => VldReadonly<unknown, T>;
+    pipe: <TInput, TIntermediate, TOutput>(first: VldBase<TInput, TIntermediate>, second: VldBase<any, 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);
         };
-        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>;
-            exactOptional(): VldExactOptional<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>;
-            check<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
-            check(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
-            meta(): import("./validators/base").SchemaMetadata | undefined;
-            meta(data: Partial<import("./validators/base").SchemaMetadata>): import("./validators/base").VldMeta<unknown, string>;
-            describe(description: string): import("./validators/base").VldMeta<unknown, string>;
+        readonly regexes: Readonly<Record<"number" | "bigint" | "boolean" | "undefined" | "integer" | "null" | "date" | "hex" | "base64" | "email" | "base64url" | "jwt" | "nanoid" | "cuid" | "cuid2" | "ulid" | "cidrv4" | "cidrv6" | "e164" | "xid" | "guid" | "ksuid" | "duration" | "ipv4" | "ipv6" | "browserEmail" | "creditCard" | "domain" | "extendedDuration" | "hostname" | "html5Email" | "httpProtocol" | "httpUrl" | "idnEmail" | "lowercase" | "md5" | "md5_base64" | "md5_base64url" | "md5_hex" | "rfc5322Email" | "sha1" | "sha1_base64" | "sha1_base64url" | "sha1_hex" | "sha256" | "sha256_base64" | "sha256_base64url" | "sha256_hex" | "sha384" | "sha384_base64" | "sha384_base64url" | "sha384_hex" | "sha512" | "sha512_base64" | "sha512_base64url" | "sha512_hex" | "unicodeEmail" | "uppercase" | "uuid4" | "uuid6" | "uuid7", RegExp> & {
+            datetime: (options?: stringFormats.ISODateTimeOptions) => RegExp;
+            emoji: () => RegExp;
+            mac: (delimiter?: string) => RegExp;
+            string: (options?: {
+                minimum?: number;
+                maximum?: number;
+            }) => RegExp;
+            time: (options?: stringFormats.ISOTimeOptions) => RegExp;
+            uuid: (version?: number) => 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;
         };
-        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>;
-            exactOptional(): VldExactOptional<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>;
-            check<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
-            check(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
-            meta(): import("./validators/base").SchemaMetadata | undefined;
-            meta(data: Partial<import("./validators/base").SchemaMetadata>): import("./validators/base").VldMeta<unknown, string>;
-            describe(description: string): import("./validators/base").VldMeta<unknown, string>;
+        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>>;
     };
-    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>;
-        exactOptional(): VldExactOptional<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>;
-        check<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
-        check(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
-        meta(): import("./validators/base").SchemaMetadata | undefined;
-        meta(data: Partial<import("./validators/base").SchemaMetadata>): import("./validators/base").VldMeta<unknown, string>;
-        describe(description: string): import("./validators/base").VldMeta<unknown, string>;
-    };
-    xid: () => {
-        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>;
-        exactOptional(): VldExactOptional<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>;
-        check<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
-        check(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
-        meta(): import("./validators/base").SchemaMetadata | undefined;
-        meta(data: Partial<import("./validators/base").SchemaMetadata>): import("./validators/base").VldMeta<unknown, string>;
-        describe(description: string): import("./validators/base").VldMeta<unknown, string>;
+    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);
     };
-    guid: () => {
-        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>;
-        exactOptional(): VldExactOptional<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>;
-        check<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
-        check(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
-        meta(): import("./validators/base").SchemaMetadata | undefined;
-        meta(data: Partial<import("./validators/base").SchemaMetadata>): import("./validators/base").VldMeta<unknown, string>;
-        describe(description: string): import("./validators/base").VldMeta<unknown, string>;
+    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;
     };
-    httpUrl: () => {
-        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>;
-        exactOptional(): VldExactOptional<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>;
-        check<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
-        check(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
-        meta(): import("./validators/base").SchemaMetadata | undefined;
-        meta(data: Partial<import("./validators/base").SchemaMetadata>): import("./validators/base").VldMeta<unknown, string>;
-        describe(description: string): import("./validators/base").VldMeta<unknown, string>;
+    email: (options?: {
+        pattern?: RegExp;
+    }) => stringFormats.VldStringFormat;
+    url: (options?: stringFormats.URLFormatOptions) => stringFormats.VldStringFormat;
+    uuid: (options?: {
+        version?: stringFormats.UUIDVersion;
+    }) => 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;
+    creditCard: (params?: {
+        message?: string;
+    }) => stringFormats.VldStringFormat;
+    e164: () => stringFormats.VldStringFormat;
+    hash: (algorithm: "md5" | "sha1" | "sha256" | "sha384" | "sha512") => stringFormats.VldStringFormat;
+    iso: {
+        ZodISODate: typeof stringFormats.VldStringFormat;
+        ZodISODateTime: typeof stringFormats.VldStringFormat;
+        ZodISODuration: typeof stringFormats.VldStringFormat;
+        ZodISOTime: typeof stringFormats.VldStringFormat;
+        date: () => stringFormats.VldStringFormat;
+        time: (options?: stringFormats.ISOTimeOptions) => stringFormats.VldStringFormat;
+        datetime: (options?: stringFormats.ISODateTimeOptions) => stringFormats.VldStringFormat;
+        dateTime: (options?: stringFormats.ISODateTimeOptions) => stringFormats.VldStringFormat;
+        duration: () => stringFormats.VldStringFormat;
     };
-    templateLiteral: (...components: (VldBase<any, any> | string)[]) => import("./validators").VldTemplateLiteral;
+    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<Record<"number" | "bigint" | "boolean" | "undefined" | "integer" | "null" | "date" | "hex" | "base64" | "email" | "base64url" | "jwt" | "nanoid" | "cuid" | "cuid2" | "ulid" | "cidrv4" | "cidrv6" | "e164" | "xid" | "guid" | "ksuid" | "duration" | "ipv4" | "ipv6" | "browserEmail" | "creditCard" | "domain" | "extendedDuration" | "hostname" | "html5Email" | "httpProtocol" | "httpUrl" | "idnEmail" | "lowercase" | "md5" | "md5_base64" | "md5_base64url" | "md5_hex" | "rfc5322Email" | "sha1" | "sha1_base64" | "sha1_base64url" | "sha1_hex" | "sha256" | "sha256_base64" | "sha256_base64url" | "sha256_hex" | "sha384" | "sha384_base64" | "sha384_base64url" | "sha384_hex" | "sha512" | "sha512_base64" | "sha512_base64url" | "sha512_hex" | "unicodeEmail" | "uppercase" | "uuid4" | "uuid6" | "uuid7", RegExp> & {
+        datetime: (options?: stringFormats.ISODateTimeOptions) => RegExp;
+        emoji: () => RegExp;
+        mac: (delimiter?: string) => RegExp;
+        string: (options?: {
+            minimum?: number;
+            maximum?: number;
+        }) => RegExp;
+        time: (options?: stringFormats.ISOTimeOptions) => RegExp;
+        uuid: (version?: number) => RegExp;
+    }>;
+    templateLiteral: (...components: (VldBase<any, any> | string)[]) => VldTemplateLiteral;
     base64Bytes: () => VldBase64;
     hexBytes: () => VldHex;
     uint8Array: () => VldUint8Array;
@@ -928,15 +1124,61 @@ export declare const v: {
         decode: (value: TInput) => TOutput | Promise<TOutput>;
         encode: (value: TOutput) => TInput | Promise<TInput>;
     }) => VldCodec<TInput, TOutput>;
-    promise: <T>(inner: VldBase<unknown, T>) => import("./validators").VldPromise<T>;
+    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: TOutput) => TInput;
+    safeEncode: <TInput, TOutput>(schema: VldBase<TInput, TOutput>, value: TOutput) => ParseResult<TInput>;
+    encodeAsync: <TInput, TOutput>(schema: VldBase<TInput, TOutput>, value: TOutput) => Promise<TInput>;
+    safeEncodeAsync: <TInput, TOutput>(schema: VldBase<TInput, TOutput>, value: TOutput) => Promise<ParseResult<TInput>>;
+    formatError: (error: Error) => FormattedError;
+    treeifyError: typeof treeifyErrorFn;
+    prettifyError: typeof prettifyErrorFn;
+    flattenError: typeof flattenErrorFn;
+    toJSONSchema: typeof toJSONSchemaFn;
+    fromJSONSchema: typeof fromJSONSchemaFn;
 };
-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';
-export { toJSONSchema, fromJSONSchema, type JSONSchemaDefinition, type ToJSONSchemaOptions } from './utils/json-schema';
+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