@oxog/vld 1.3.1 → 1.5.0

package/dist/index.d.ts

@@ -7,12 +7,18 @@
  * - Secure deepMerge (no prototype pollution)
  * - TypeScript strict mode support
  * - Better performance through pooling and memoization
+ * - Plugin system for extensibility
+ * - Event system for validation lifecycle hooks
+ * - Result pattern for functional error handling
+ * - 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';
@@ -29,6 +35,15 @@ import { VldAny } from './validators/any';
 import { VldUnknown } from './validators/unknown';
 import { VldVoid } from './validators/void';
 import { VldNever } from './validators/never';
+import { VldNull } from './validators/null';
+import { VldUndefined } from './validators/undefined';
+import { VldNan } from './validators/nan';
+import { VldLazy } from './validators/lazy';
+import { VldDiscriminatedUnion } from './validators/discriminated-union';
+import { VldXor } from './validators/xor';
+import { VldJson } from './validators/json';
+import { type CustomValidatorOptions } from './validators/custom';
+import { VldPreprocess } from './validators/base';
 import { VldOptional } from './validators/base';
 import { VldNullable } from './validators/base';
 import { VldNullish } from './validators/base';
@@ -42,11 +57,11 @@ import { VldCoerceBoolean } from './coercion/boolean';
 import { VldCoerceDate } from './coercion/date';
 import { VldCoerceBigInt } from './coercion/bigint';
 export type { ParseResult } from './validators/base';
-export type { Infer } from './validators';
+export type { Infer, Input, Output } from './validators';
 export { VldBase } from './validators/base';
 export { VldIntersection } from './validators/intersection';
 export { setLocale, getLocale, getMessages, type Locale } from './locales';
-export { VldError, VldIssue, VldErrorCode, VldErrorTree, VldFlattenedError, treeifyError, prettifyError, flattenError } from './errors';
+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';
@@ -56,27 +71,50 @@ export { stringToNumber, stringToInt, stringToBigInt, numberToBigInt, stringToBo
 export declare const v: {
     string: () => VldString;
     number: () => VldNumber;
+    int: () => VldNumber;
+    int32: () => VldNumber;
     boolean: () => VldBoolean;
     date: () => VldDate;
     bigint: () => VldBigInt;
     symbol: () => VldSymbol;
+    stringbool: (options?: {
+        truthy?: readonly string[];
+        falsy?: readonly string[];
+        caseSensitive?: boolean;
+    }) => VldStringBool;
     array: <T>(item: VldBase<unknown, T>) => VldArray<T>;
     object: <T extends Record<string, any>>(shape: { [K in keyof T]: VldBase<unknown, T[K]>; }) => VldObject<T>;
+    strictObject: <T extends Record<string, any>>(shape: { [K in keyof T]: VldBase<unknown, T[K]>; }) => VldObject<T>;
+    looseObject: <T extends Record<string, any>>(shape: { [K in keyof T]: VldBase<unknown, T[K]>; }) => VldObject<T>;
     tuple: <T extends readonly VldBase<any, any>[]>(...items: T) => VldTuple<[...T]>;
     record: <T>(value: VldBase<unknown, T>) => VldRecord<T>;
+    partialRecord: <T>(value: VldBase<unknown, T>) => VldRecord<T | undefined>;
+    looseRecord: <T>(value: VldBase<unknown, T>) => VldBase<unknown, Record<string, T>>;
     set: <T>(item: VldBase<unknown, T>) => VldSet<T>;
     map: <K, V>(key: VldBase<unknown, K>, value: VldBase<unknown, V>) => VldMap<K, V>;
     union: <T extends readonly VldBase<any, any>[]>(...validators: T) => VldUnion<[...T]>;
     intersection: <A, B>(first: VldBase<unknown, A>, second: VldBase<unknown, B>) => VldIntersection<A, B>;
+    discriminatedUnion: <K extends string, T extends readonly VldBase<any, any>[]>(discriminator: K, ...options: T) => VldDiscriminatedUnion<K, any>;
+    xor: <T extends readonly VldBase<any, any>[]>(...options: T) => VldXor<any>;
     literal: <T extends string | number | boolean | null | undefined>(value: T) => VldLiteral<T>;
     enum: <T extends readonly [string, ...string[]]>(...values: T) => VldEnum<any>;
     any: () => VldAny;
     unknown: () => VldUnknown;
     void: () => VldVoid;
     never: () => VldNever;
+    null: () => VldNull;
+    undefined: () => VldUndefined;
+    nan: () => VldNan;
+    NEVER: VldNever;
     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>;
+    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;
+    preprocess: <TInput, TOutput>(preprocessor: (input: unknown) => unknown, schema: VldBase<TInput, TOutput>) => VldPreprocess<TInput, TOutput>;
     coerce: {
         string: () => VldCoerceString;
         number: () => VldCoerceNumber;
@@ -84,13 +122,577 @@ export declare const v: {
         date: () => VldCoerceDate;
         bigint: () => VldCoerceBigInt;
     };
-    base64: () => VldBase64;
-    hex: () => VldHex;
+    email: (options?: {
+        pattern?: RegExp;
+    }) => {
+        readonly _format: string;
+        readonly _validator: (val: string) => boolean;
+        readonly _errorMessage?: string | undefined;
+        parse(value: unknown): string;
+        safeParse(value: unknown): import("./validators").ParseResult<string>;
+        isValid(value: unknown): boolean;
+        parseOrDefault(value: unknown, defaultValue: string): string;
+        refine<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
+        refine(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
+        superRefine(refinement: (value: string, ctx: import("./validators").SuperRefineContext) => void | Promise<void>): import("./validators").VldSuperRefine<unknown, string>;
+        transform<TTransformed>(transformer: (value: string) => TTransformed): import("./validators").VldTransform<unknown, string, TTransformed>;
+        default(defaultValue: string): import("./validators").VldDefault<unknown, string>;
+        catch(fallbackValue: string): import("./validators").VldCatch<unknown, string>;
+        optional(): VldOptional<unknown, string>;
+        nullable(): VldNullable<unknown, string>;
+        nullish(): VldNullish<unknown, string>;
+        pipe<TNextOutput>(next: VldBase<string, TNextOutput>): import("./validators").VldPipe<unknown, string, TNextOutput>;
+        readonly(): import("./validators").VldReadonly<unknown, string>;
+        brand<TBrand extends string>(): import("./validators").VldBrand<unknown, string, TBrand>;
+        apply<TNewOutput>(fn: (schema: /*elided*/ any) => VldBase<unknown, TNewOutput>): VldBase<unknown, TNewOutput>;
+    };
+    uuid: (options?: {
+        version?: "v4" | "v6" | "v7";
+    }) => {
+        readonly _format: string;
+        readonly _validator: (val: string) => boolean;
+        readonly _errorMessage?: string | undefined;
+        parse(value: unknown): string;
+        safeParse(value: unknown): import("./validators").ParseResult<string>;
+        isValid(value: unknown): boolean;
+        parseOrDefault(value: unknown, defaultValue: string): string;
+        refine<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
+        refine(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
+        superRefine(refinement: (value: string, ctx: import("./validators").SuperRefineContext) => void | Promise<void>): import("./validators").VldSuperRefine<unknown, string>;
+        transform<TTransformed>(transformer: (value: string) => TTransformed): import("./validators").VldTransform<unknown, string, TTransformed>;
+        default(defaultValue: string): import("./validators").VldDefault<unknown, string>;
+        catch(fallbackValue: string): import("./validators").VldCatch<unknown, string>;
+        optional(): VldOptional<unknown, string>;
+        nullable(): VldNullable<unknown, string>;
+        nullish(): VldNullish<unknown, string>;
+        pipe<TNextOutput>(next: VldBase<string, TNextOutput>): import("./validators").VldPipe<unknown, string, TNextOutput>;
+        readonly(): import("./validators").VldReadonly<unknown, string>;
+        brand<TBrand extends string>(): import("./validators").VldBrand<unknown, string, TBrand>;
+        apply<TNewOutput>(fn: (schema: /*elided*/ any) => VldBase<unknown, TNewOutput>): VldBase<unknown, TNewOutput>;
+    };
+    uuidv4: () => {
+        readonly _format: string;
+        readonly _validator: (val: string) => boolean;
+        readonly _errorMessage?: string | undefined;
+        parse(value: unknown): string;
+        safeParse(value: unknown): import("./validators").ParseResult<string>;
+        isValid(value: unknown): boolean;
+        parseOrDefault(value: unknown, defaultValue: string): string;
+        refine<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
+        refine(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
+        superRefine(refinement: (value: string, ctx: import("./validators").SuperRefineContext) => void | Promise<void>): import("./validators").VldSuperRefine<unknown, string>;
+        transform<TTransformed>(transformer: (value: string) => TTransformed): import("./validators").VldTransform<unknown, string, TTransformed>;
+        default(defaultValue: string): import("./validators").VldDefault<unknown, string>;
+        catch(fallbackValue: string): import("./validators").VldCatch<unknown, string>;
+        optional(): VldOptional<unknown, string>;
+        nullable(): VldNullable<unknown, string>;
+        nullish(): VldNullish<unknown, string>;
+        pipe<TNextOutput>(next: VldBase<string, TNextOutput>): import("./validators").VldPipe<unknown, string, TNextOutput>;
+        readonly(): import("./validators").VldReadonly<unknown, string>;
+        brand<TBrand extends string>(): import("./validators").VldBrand<unknown, string, TBrand>;
+        apply<TNewOutput>(fn: (schema: /*elided*/ any) => VldBase<unknown, TNewOutput>): VldBase<unknown, TNewOutput>;
+    };
+    hostname: () => {
+        readonly _format: string;
+        readonly _validator: (val: string) => boolean;
+        readonly _errorMessage?: string | undefined;
+        parse(value: unknown): string;
+        safeParse(value: unknown): import("./validators").ParseResult<string>;
+        isValid(value: unknown): boolean;
+        parseOrDefault(value: unknown, defaultValue: string): string;
+        refine<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
+        refine(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
+        superRefine(refinement: (value: string, ctx: import("./validators").SuperRefineContext) => void | Promise<void>): import("./validators").VldSuperRefine<unknown, string>;
+        transform<TTransformed>(transformer: (value: string) => TTransformed): import("./validators").VldTransform<unknown, string, TTransformed>;
+        default(defaultValue: string): import("./validators").VldDefault<unknown, string>;
+        catch(fallbackValue: string): import("./validators").VldCatch<unknown, string>;
+        optional(): VldOptional<unknown, string>;
+        nullable(): VldNullable<unknown, string>;
+        nullish(): VldNullish<unknown, string>;
+        pipe<TNextOutput>(next: VldBase<string, TNextOutput>): import("./validators").VldPipe<unknown, string, TNextOutput>;
+        readonly(): import("./validators").VldReadonly<unknown, string>;
+        brand<TBrand extends string>(): import("./validators").VldBrand<unknown, string, TBrand>;
+        apply<TNewOutput>(fn: (schema: /*elided*/ any) => VldBase<unknown, TNewOutput>): VldBase<unknown, TNewOutput>;
+    };
+    emoji: () => {
+        readonly _format: string;
+        readonly _validator: (val: string) => boolean;
+        readonly _errorMessage?: string | undefined;
+        parse(value: unknown): string;
+        safeParse(value: unknown): import("./validators").ParseResult<string>;
+        isValid(value: unknown): boolean;
+        parseOrDefault(value: unknown, defaultValue: string): string;
+        refine<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
+        refine(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
+        superRefine(refinement: (value: string, ctx: import("./validators").SuperRefineContext) => void | Promise<void>): import("./validators").VldSuperRefine<unknown, string>;
+        transform<TTransformed>(transformer: (value: string) => TTransformed): import("./validators").VldTransform<unknown, string, TTransformed>;
+        default(defaultValue: string): import("./validators").VldDefault<unknown, string>;
+        catch(fallbackValue: string): import("./validators").VldCatch<unknown, string>;
+        optional(): VldOptional<unknown, string>;
+        nullable(): VldNullable<unknown, string>;
+        nullish(): VldNullish<unknown, string>;
+        pipe<TNextOutput>(next: VldBase<string, TNextOutput>): import("./validators").VldPipe<unknown, string, TNextOutput>;
+        readonly(): import("./validators").VldReadonly<unknown, string>;
+        brand<TBrand extends string>(): import("./validators").VldBrand<unknown, string, TBrand>;
+        apply<TNewOutput>(fn: (schema: /*elided*/ any) => VldBase<unknown, TNewOutput>): VldBase<unknown, TNewOutput>;
+    };
+    base64: () => {
+        readonly _format: string;
+        readonly _validator: (val: string) => boolean;
+        readonly _errorMessage?: string | undefined;
+        parse(value: unknown): string;
+        safeParse(value: unknown): import("./validators").ParseResult<string>;
+        isValid(value: unknown): boolean;
+        parseOrDefault(value: unknown, defaultValue: string): string;
+        refine<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
+        refine(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
+        superRefine(refinement: (value: string, ctx: import("./validators").SuperRefineContext) => void | Promise<void>): import("./validators").VldSuperRefine<unknown, string>;
+        transform<TTransformed>(transformer: (value: string) => TTransformed): import("./validators").VldTransform<unknown, string, TTransformed>;
+        default(defaultValue: string): import("./validators").VldDefault<unknown, string>;
+        catch(fallbackValue: string): import("./validators").VldCatch<unknown, string>;
+        optional(): VldOptional<unknown, string>;
+        nullable(): VldNullable<unknown, string>;
+        nullish(): VldNullish<unknown, string>;
+        pipe<TNextOutput>(next: VldBase<string, TNextOutput>): import("./validators").VldPipe<unknown, string, TNextOutput>;
+        readonly(): import("./validators").VldReadonly<unknown, string>;
+        brand<TBrand extends string>(): import("./validators").VldBrand<unknown, string, TBrand>;
+        apply<TNewOutput>(fn: (schema: /*elided*/ any) => VldBase<unknown, TNewOutput>): VldBase<unknown, TNewOutput>;
+    };
+    base64url: () => {
+        readonly _format: string;
+        readonly _validator: (val: string) => boolean;
+        readonly _errorMessage?: string | undefined;
+        parse(value: unknown): string;
+        safeParse(value: unknown): import("./validators").ParseResult<string>;
+        isValid(value: unknown): boolean;
+        parseOrDefault(value: unknown, defaultValue: string): string;
+        refine<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
+        refine(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
+        superRefine(refinement: (value: string, ctx: import("./validators").SuperRefineContext) => void | Promise<void>): import("./validators").VldSuperRefine<unknown, string>;
+        transform<TTransformed>(transformer: (value: string) => TTransformed): import("./validators").VldTransform<unknown, string, TTransformed>;
+        default(defaultValue: string): import("./validators").VldDefault<unknown, string>;
+        catch(fallbackValue: string): import("./validators").VldCatch<unknown, string>;
+        optional(): VldOptional<unknown, string>;
+        nullable(): VldNullable<unknown, string>;
+        nullish(): VldNullish<unknown, string>;
+        pipe<TNextOutput>(next: VldBase<string, TNextOutput>): import("./validators").VldPipe<unknown, string, TNextOutput>;
+        readonly(): import("./validators").VldReadonly<unknown, string>;
+        brand<TBrand extends string>(): import("./validators").VldBrand<unknown, string, TBrand>;
+        apply<TNewOutput>(fn: (schema: /*elided*/ any) => VldBase<unknown, TNewOutput>): VldBase<unknown, TNewOutput>;
+    };
+    hex: () => {
+        readonly _format: string;
+        readonly _validator: (val: string) => boolean;
+        readonly _errorMessage?: string | undefined;
+        parse(value: unknown): string;
+        safeParse(value: unknown): import("./validators").ParseResult<string>;
+        isValid(value: unknown): boolean;
+        parseOrDefault(value: unknown, defaultValue: string): string;
+        refine<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
+        refine(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
+        superRefine(refinement: (value: string, ctx: import("./validators").SuperRefineContext) => void | Promise<void>): import("./validators").VldSuperRefine<unknown, string>;
+        transform<TTransformed>(transformer: (value: string) => TTransformed): import("./validators").VldTransform<unknown, string, TTransformed>;
+        default(defaultValue: string): import("./validators").VldDefault<unknown, string>;
+        catch(fallbackValue: string): import("./validators").VldCatch<unknown, string>;
+        optional(): VldOptional<unknown, string>;
+        nullable(): VldNullable<unknown, string>;
+        nullish(): VldNullish<unknown, string>;
+        pipe<TNextOutput>(next: VldBase<string, TNextOutput>): import("./validators").VldPipe<unknown, string, TNextOutput>;
+        readonly(): import("./validators").VldReadonly<unknown, string>;
+        brand<TBrand extends string>(): import("./validators").VldBrand<unknown, string, TBrand>;
+        apply<TNewOutput>(fn: (schema: /*elided*/ any) => VldBase<unknown, TNewOutput>): VldBase<unknown, TNewOutput>;
+    };
+    jwt: () => {
+        readonly _format: string;
+        readonly _validator: (val: string) => boolean;
+        readonly _errorMessage?: string | undefined;
+        parse(value: unknown): string;
+        safeParse(value: unknown): import("./validators").ParseResult<string>;
+        isValid(value: unknown): boolean;
+        parseOrDefault(value: unknown, defaultValue: string): string;
+        refine<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
+        refine(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
+        superRefine(refinement: (value: string, ctx: import("./validators").SuperRefineContext) => void | Promise<void>): import("./validators").VldSuperRefine<unknown, string>;
+        transform<TTransformed>(transformer: (value: string) => TTransformed): import("./validators").VldTransform<unknown, string, TTransformed>;
+        default(defaultValue: string): import("./validators").VldDefault<unknown, string>;
+        catch(fallbackValue: string): import("./validators").VldCatch<unknown, string>;
+        optional(): VldOptional<unknown, string>;
+        nullable(): VldNullable<unknown, string>;
+        nullish(): VldNullish<unknown, string>;
+        pipe<TNextOutput>(next: VldBase<string, TNextOutput>): import("./validators").VldPipe<unknown, string, TNextOutput>;
+        readonly(): import("./validators").VldReadonly<unknown, string>;
+        brand<TBrand extends string>(): import("./validators").VldBrand<unknown, string, TBrand>;
+        apply<TNewOutput>(fn: (schema: /*elided*/ any) => VldBase<unknown, TNewOutput>): VldBase<unknown, TNewOutput>;
+    };
+    nanoid: () => {
+        readonly _format: string;
+        readonly _validator: (val: string) => boolean;
+        readonly _errorMessage?: string | undefined;
+        parse(value: unknown): string;
+        safeParse(value: unknown): import("./validators").ParseResult<string>;
+        isValid(value: unknown): boolean;
+        parseOrDefault(value: unknown, defaultValue: string): string;
+        refine<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
+        refine(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
+        superRefine(refinement: (value: string, ctx: import("./validators").SuperRefineContext) => void | Promise<void>): import("./validators").VldSuperRefine<unknown, string>;
+        transform<TTransformed>(transformer: (value: string) => TTransformed): import("./validators").VldTransform<unknown, string, TTransformed>;
+        default(defaultValue: string): import("./validators").VldDefault<unknown, string>;
+        catch(fallbackValue: string): import("./validators").VldCatch<unknown, string>;
+        optional(): VldOptional<unknown, string>;
+        nullable(): VldNullable<unknown, string>;
+        nullish(): VldNullish<unknown, string>;
+        pipe<TNextOutput>(next: VldBase<string, TNextOutput>): import("./validators").VldPipe<unknown, string, TNextOutput>;
+        readonly(): import("./validators").VldReadonly<unknown, string>;
+        brand<TBrand extends string>(): import("./validators").VldBrand<unknown, string, TBrand>;
+        apply<TNewOutput>(fn: (schema: /*elided*/ any) => VldBase<unknown, TNewOutput>): VldBase<unknown, TNewOutput>;
+    };
+    cuid: () => {
+        readonly _format: string;
+        readonly _validator: (val: string) => boolean;
+        readonly _errorMessage?: string | undefined;
+        parse(value: unknown): string;
+        safeParse(value: unknown): import("./validators").ParseResult<string>;
+        isValid(value: unknown): boolean;
+        parseOrDefault(value: unknown, defaultValue: string): string;
+        refine<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
+        refine(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
+        superRefine(refinement: (value: string, ctx: import("./validators").SuperRefineContext) => void | Promise<void>): import("./validators").VldSuperRefine<unknown, string>;
+        transform<TTransformed>(transformer: (value: string) => TTransformed): import("./validators").VldTransform<unknown, string, TTransformed>;
+        default(defaultValue: string): import("./validators").VldDefault<unknown, string>;
+        catch(fallbackValue: string): import("./validators").VldCatch<unknown, string>;
+        optional(): VldOptional<unknown, string>;
+        nullable(): VldNullable<unknown, string>;
+        nullish(): VldNullish<unknown, string>;
+        pipe<TNextOutput>(next: VldBase<string, TNextOutput>): import("./validators").VldPipe<unknown, string, TNextOutput>;
+        readonly(): import("./validators").VldReadonly<unknown, string>;
+        brand<TBrand extends string>(): import("./validators").VldBrand<unknown, string, TBrand>;
+        apply<TNewOutput>(fn: (schema: /*elided*/ any) => VldBase<unknown, TNewOutput>): VldBase<unknown, TNewOutput>;
+    };
+    cuid2: () => {
+        readonly _format: string;
+        readonly _validator: (val: string) => boolean;
+        readonly _errorMessage?: string | undefined;
+        parse(value: unknown): string;
+        safeParse(value: unknown): import("./validators").ParseResult<string>;
+        isValid(value: unknown): boolean;
+        parseOrDefault(value: unknown, defaultValue: string): string;
+        refine<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
+        refine(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
+        superRefine(refinement: (value: string, ctx: import("./validators").SuperRefineContext) => void | Promise<void>): import("./validators").VldSuperRefine<unknown, string>;
+        transform<TTransformed>(transformer: (value: string) => TTransformed): import("./validators").VldTransform<unknown, string, TTransformed>;
+        default(defaultValue: string): import("./validators").VldDefault<unknown, string>;
+        catch(fallbackValue: string): import("./validators").VldCatch<unknown, string>;
+        optional(): VldOptional<unknown, string>;
+        nullable(): VldNullable<unknown, string>;
+        nullish(): VldNullish<unknown, string>;
+        pipe<TNextOutput>(next: VldBase<string, TNextOutput>): import("./validators").VldPipe<unknown, string, TNextOutput>;
+        readonly(): import("./validators").VldReadonly<unknown, string>;
+        brand<TBrand extends string>(): import("./validators").VldBrand<unknown, string, TBrand>;
+        apply<TNewOutput>(fn: (schema: /*elided*/ any) => VldBase<unknown, TNewOutput>): VldBase<unknown, TNewOutput>;
+    };
+    ulid: () => {
+        readonly _format: string;
+        readonly _validator: (val: string) => boolean;
+        readonly _errorMessage?: string | undefined;
+        parse(value: unknown): string;
+        safeParse(value: unknown): import("./validators").ParseResult<string>;
+        isValid(value: unknown): boolean;
+        parseOrDefault(value: unknown, defaultValue: string): string;
+        refine<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
+        refine(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
+        superRefine(refinement: (value: string, ctx: import("./validators").SuperRefineContext) => void | Promise<void>): import("./validators").VldSuperRefine<unknown, string>;
+        transform<TTransformed>(transformer: (value: string) => TTransformed): import("./validators").VldTransform<unknown, string, TTransformed>;
+        default(defaultValue: string): import("./validators").VldDefault<unknown, string>;
+        catch(fallbackValue: string): import("./validators").VldCatch<unknown, string>;
+        optional(): VldOptional<unknown, string>;
+        nullable(): VldNullable<unknown, string>;
+        nullish(): VldNullish<unknown, string>;
+        pipe<TNextOutput>(next: VldBase<string, TNextOutput>): import("./validators").VldPipe<unknown, string, TNextOutput>;
+        readonly(): import("./validators").VldReadonly<unknown, string>;
+        brand<TBrand extends string>(): import("./validators").VldBrand<unknown, string, TBrand>;
+        apply<TNewOutput>(fn: (schema: /*elided*/ any) => VldBase<unknown, TNewOutput>): VldBase<unknown, TNewOutput>;
+    };
+    ipv4: () => {
+        readonly _format: string;
+        readonly _validator: (val: string) => boolean;
+        readonly _errorMessage?: string | undefined;
+        parse(value: unknown): string;
+        safeParse(value: unknown): import("./validators").ParseResult<string>;
+        isValid(value: unknown): boolean;
+        parseOrDefault(value: unknown, defaultValue: string): string;
+        refine<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
+        refine(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
+        superRefine(refinement: (value: string, ctx: import("./validators").SuperRefineContext) => void | Promise<void>): import("./validators").VldSuperRefine<unknown, string>;
+        transform<TTransformed>(transformer: (value: string) => TTransformed): import("./validators").VldTransform<unknown, string, TTransformed>;
+        default(defaultValue: string): import("./validators").VldDefault<unknown, string>;
+        catch(fallbackValue: string): import("./validators").VldCatch<unknown, string>;
+        optional(): VldOptional<unknown, string>;
+        nullable(): VldNullable<unknown, string>;
+        nullish(): VldNullish<unknown, string>;
+        pipe<TNextOutput>(next: VldBase<string, TNextOutput>): import("./validators").VldPipe<unknown, string, TNextOutput>;
+        readonly(): import("./validators").VldReadonly<unknown, string>;
+        brand<TBrand extends string>(): import("./validators").VldBrand<unknown, string, TBrand>;
+        apply<TNewOutput>(fn: (schema: /*elided*/ any) => VldBase<unknown, TNewOutput>): VldBase<unknown, TNewOutput>;
+    };
+    ipv6: () => {
+        readonly _format: string;
+        readonly _validator: (val: string) => boolean;
+        readonly _errorMessage?: string | undefined;
+        parse(value: unknown): string;
+        safeParse(value: unknown): import("./validators").ParseResult<string>;
+        isValid(value: unknown): boolean;
+        parseOrDefault(value: unknown, defaultValue: string): string;
+        refine<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
+        refine(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
+        superRefine(refinement: (value: string, ctx: import("./validators").SuperRefineContext) => void | Promise<void>): import("./validators").VldSuperRefine<unknown, string>;
+        transform<TTransformed>(transformer: (value: string) => TTransformed): import("./validators").VldTransform<unknown, string, TTransformed>;
+        default(defaultValue: string): import("./validators").VldDefault<unknown, string>;
+        catch(fallbackValue: string): import("./validators").VldCatch<unknown, string>;
+        optional(): VldOptional<unknown, string>;
+        nullable(): VldNullable<unknown, string>;
+        nullish(): VldNullish<unknown, string>;
+        pipe<TNextOutput>(next: VldBase<string, TNextOutput>): import("./validators").VldPipe<unknown, string, TNextOutput>;
+        readonly(): import("./validators").VldReadonly<unknown, string>;
+        brand<TBrand extends string>(): import("./validators").VldBrand<unknown, string, TBrand>;
+        apply<TNewOutput>(fn: (schema: /*elided*/ any) => VldBase<unknown, TNewOutput>): VldBase<unknown, TNewOutput>;
+    };
+    mac: () => {
+        readonly _format: string;
+        readonly _validator: (val: string) => boolean;
+        readonly _errorMessage?: string | undefined;
+        parse(value: unknown): string;
+        safeParse(value: unknown): import("./validators").ParseResult<string>;
+        isValid(value: unknown): boolean;
+        parseOrDefault(value: unknown, defaultValue: string): string;
+        refine<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
+        refine(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
+        superRefine(refinement: (value: string, ctx: import("./validators").SuperRefineContext) => void | Promise<void>): import("./validators").VldSuperRefine<unknown, string>;
+        transform<TTransformed>(transformer: (value: string) => TTransformed): import("./validators").VldTransform<unknown, string, TTransformed>;
+        default(defaultValue: string): import("./validators").VldDefault<unknown, string>;
+        catch(fallbackValue: string): import("./validators").VldCatch<unknown, string>;
+        optional(): VldOptional<unknown, string>;
+        nullable(): VldNullable<unknown, string>;
+        nullish(): VldNullish<unknown, string>;
+        pipe<TNextOutput>(next: VldBase<string, TNextOutput>): import("./validators").VldPipe<unknown, string, TNextOutput>;
+        readonly(): import("./validators").VldReadonly<unknown, string>;
+        brand<TBrand extends string>(): import("./validators").VldBrand<unknown, string, TBrand>;
+        apply<TNewOutput>(fn: (schema: /*elided*/ any) => VldBase<unknown, TNewOutput>): VldBase<unknown, TNewOutput>;
+    };
+    cidrv4: () => {
+        readonly _format: string;
+        readonly _validator: (val: string) => boolean;
+        readonly _errorMessage?: string | undefined;
+        parse(value: unknown): string;
+        safeParse(value: unknown): import("./validators").ParseResult<string>;
+        isValid(value: unknown): boolean;
+        parseOrDefault(value: unknown, defaultValue: string): string;
+        refine<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
+        refine(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
+        superRefine(refinement: (value: string, ctx: import("./validators").SuperRefineContext) => void | Promise<void>): import("./validators").VldSuperRefine<unknown, string>;
+        transform<TTransformed>(transformer: (value: string) => TTransformed): import("./validators").VldTransform<unknown, string, TTransformed>;
+        default(defaultValue: string): import("./validators").VldDefault<unknown, string>;
+        catch(fallbackValue: string): import("./validators").VldCatch<unknown, string>;
+        optional(): VldOptional<unknown, string>;
+        nullable(): VldNullable<unknown, string>;
+        nullish(): VldNullish<unknown, string>;
+        pipe<TNextOutput>(next: VldBase<string, TNextOutput>): import("./validators").VldPipe<unknown, string, TNextOutput>;
+        readonly(): import("./validators").VldReadonly<unknown, string>;
+        brand<TBrand extends string>(): import("./validators").VldBrand<unknown, string, TBrand>;
+        apply<TNewOutput>(fn: (schema: /*elided*/ any) => VldBase<unknown, TNewOutput>): VldBase<unknown, TNewOutput>;
+    };
+    cidrv6: () => {
+        readonly _format: string;
+        readonly _validator: (val: string) => boolean;
+        readonly _errorMessage?: string | undefined;
+        parse(value: unknown): string;
+        safeParse(value: unknown): import("./validators").ParseResult<string>;
+        isValid(value: unknown): boolean;
+        parseOrDefault(value: unknown, defaultValue: string): string;
+        refine<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
+        refine(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
+        superRefine(refinement: (value: string, ctx: import("./validators").SuperRefineContext) => void | Promise<void>): import("./validators").VldSuperRefine<unknown, string>;
+        transform<TTransformed>(transformer: (value: string) => TTransformed): import("./validators").VldTransform<unknown, string, TTransformed>;
+        default(defaultValue: string): import("./validators").VldDefault<unknown, string>;
+        catch(fallbackValue: string): import("./validators").VldCatch<unknown, string>;
+        optional(): VldOptional<unknown, string>;
+        nullable(): VldNullable<unknown, string>;
+        nullish(): VldNullish<unknown, string>;
+        pipe<TNextOutput>(next: VldBase<string, TNextOutput>): import("./validators").VldPipe<unknown, string, TNextOutput>;
+        readonly(): import("./validators").VldReadonly<unknown, string>;
+        brand<TBrand extends string>(): import("./validators").VldBrand<unknown, string, TBrand>;
+        apply<TNewOutput>(fn: (schema: /*elided*/ any) => VldBase<unknown, TNewOutput>): VldBase<unknown, TNewOutput>;
+    };
+    e164: () => {
+        readonly _format: string;
+        readonly _validator: (val: string) => boolean;
+        readonly _errorMessage?: string | undefined;
+        parse(value: unknown): string;
+        safeParse(value: unknown): import("./validators").ParseResult<string>;
+        isValid(value: unknown): boolean;
+        parseOrDefault(value: unknown, defaultValue: string): string;
+        refine<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
+        refine(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
+        superRefine(refinement: (value: string, ctx: import("./validators").SuperRefineContext) => void | Promise<void>): import("./validators").VldSuperRefine<unknown, string>;
+        transform<TTransformed>(transformer: (value: string) => TTransformed): import("./validators").VldTransform<unknown, string, TTransformed>;
+        default(defaultValue: string): import("./validators").VldDefault<unknown, string>;
+        catch(fallbackValue: string): import("./validators").VldCatch<unknown, string>;
+        optional(): VldOptional<unknown, string>;
+        nullable(): VldNullable<unknown, string>;
+        nullish(): VldNullish<unknown, string>;
+        pipe<TNextOutput>(next: VldBase<string, TNextOutput>): import("./validators").VldPipe<unknown, string, TNextOutput>;
+        readonly(): import("./validators").VldReadonly<unknown, string>;
+        brand<TBrand extends string>(): import("./validators").VldBrand<unknown, string, TBrand>;
+        apply<TNewOutput>(fn: (schema: /*elided*/ any) => VldBase<unknown, TNewOutput>): VldBase<unknown, TNewOutput>;
+    };
+    hash: (algorithm: "md5" | "sha1" | "sha256" | "sha384" | "sha512") => {
+        readonly _format: string;
+        readonly _validator: (val: string) => boolean;
+        readonly _errorMessage?: string | undefined;
+        parse(value: unknown): string;
+        safeParse(value: unknown): import("./validators").ParseResult<string>;
+        isValid(value: unknown): boolean;
+        parseOrDefault(value: unknown, defaultValue: string): string;
+        refine<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
+        refine(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
+        superRefine(refinement: (value: string, ctx: import("./validators").SuperRefineContext) => void | Promise<void>): import("./validators").VldSuperRefine<unknown, string>;
+        transform<TTransformed>(transformer: (value: string) => TTransformed): import("./validators").VldTransform<unknown, string, TTransformed>;
+        default(defaultValue: string): import("./validators").VldDefault<unknown, string>;
+        catch(fallbackValue: string): import("./validators").VldCatch<unknown, string>;
+        optional(): VldOptional<unknown, string>;
+        nullable(): VldNullable<unknown, string>;
+        nullish(): VldNullish<unknown, string>;
+        pipe<TNextOutput>(next: VldBase<string, TNextOutput>): import("./validators").VldPipe<unknown, string, TNextOutput>;
+        readonly(): import("./validators").VldReadonly<unknown, string>;
+        brand<TBrand extends string>(): import("./validators").VldBrand<unknown, string, TBrand>;
+        apply<TNewOutput>(fn: (schema: /*elided*/ any) => VldBase<unknown, TNewOutput>): VldBase<unknown, TNewOutput>;
+    };
+    iso: {
+        date: () => {
+            readonly _format: string;
+            readonly _validator: (val: string) => boolean;
+            readonly _errorMessage?: string | undefined;
+            parse(value: unknown): string;
+            safeParse(value: unknown): import("./validators").ParseResult<string>;
+            isValid(value: unknown): boolean;
+            parseOrDefault(value: unknown, defaultValue: string): string;
+            refine<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
+            refine(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
+            superRefine(refinement: (value: string, ctx: import("./validators").SuperRefineContext) => void | Promise<void>): import("./validators").VldSuperRefine<unknown, string>;
+            transform<TTransformed>(transformer: (value: string) => TTransformed): import("./validators").VldTransform<unknown, string, TTransformed>;
+            default(defaultValue: string): import("./validators").VldDefault<unknown, string>;
+            catch(fallbackValue: string): import("./validators").VldCatch<unknown, string>;
+            optional(): VldOptional<unknown, string>;
+            nullable(): VldNullable<unknown, string>;
+            nullish(): VldNullish<unknown, string>;
+            pipe<TNextOutput>(next: VldBase<string, TNextOutput>): import("./validators").VldPipe<unknown, string, TNextOutput>;
+            readonly(): import("./validators").VldReadonly<unknown, string>;
+            brand<TBrand extends string>(): import("./validators").VldBrand<unknown, string, TBrand>;
+            apply<TNewOutput>(fn: (schema: /*elided*/ any) => VldBase<unknown, TNewOutput>): VldBase<unknown, TNewOutput>;
+        };
+        time: () => {
+            readonly _format: string;
+            readonly _validator: (val: string) => boolean;
+            readonly _errorMessage?: string | undefined;
+            parse(value: unknown): string;
+            safeParse(value: unknown): import("./validators").ParseResult<string>;
+            isValid(value: unknown): boolean;
+            parseOrDefault(value: unknown, defaultValue: string): string;
+            refine<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
+            refine(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
+            superRefine(refinement: (value: string, ctx: import("./validators").SuperRefineContext) => void | Promise<void>): import("./validators").VldSuperRefine<unknown, string>;
+            transform<TTransformed>(transformer: (value: string) => TTransformed): import("./validators").VldTransform<unknown, string, TTransformed>;
+            default(defaultValue: string): import("./validators").VldDefault<unknown, string>;
+            catch(fallbackValue: string): import("./validators").VldCatch<unknown, string>;
+            optional(): VldOptional<unknown, string>;
+            nullable(): VldNullable<unknown, string>;
+            nullish(): VldNullish<unknown, string>;
+            pipe<TNextOutput>(next: VldBase<string, TNextOutput>): import("./validators").VldPipe<unknown, string, TNextOutput>;
+            readonly(): import("./validators").VldReadonly<unknown, string>;
+            brand<TBrand extends string>(): import("./validators").VldBrand<unknown, string, TBrand>;
+            apply<TNewOutput>(fn: (schema: /*elided*/ any) => VldBase<unknown, TNewOutput>): VldBase<unknown, TNewOutput>;
+        };
+        dateTime: () => {
+            readonly _format: string;
+            readonly _validator: (val: string) => boolean;
+            readonly _errorMessage?: string | undefined;
+            parse(value: unknown): string;
+            safeParse(value: unknown): import("./validators").ParseResult<string>;
+            isValid(value: unknown): boolean;
+            parseOrDefault(value: unknown, defaultValue: string): string;
+            refine<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
+            refine(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
+            superRefine(refinement: (value: string, ctx: import("./validators").SuperRefineContext) => void | Promise<void>): import("./validators").VldSuperRefine<unknown, string>;
+            transform<TTransformed>(transformer: (value: string) => TTransformed): import("./validators").VldTransform<unknown, string, TTransformed>;
+            default(defaultValue: string): import("./validators").VldDefault<unknown, string>;
+            catch(fallbackValue: string): import("./validators").VldCatch<unknown, string>;
+            optional(): VldOptional<unknown, string>;
+            nullable(): VldNullable<unknown, string>;
+            nullish(): VldNullish<unknown, string>;
+            pipe<TNextOutput>(next: VldBase<string, TNextOutput>): import("./validators").VldPipe<unknown, string, TNextOutput>;
+            readonly(): import("./validators").VldReadonly<unknown, string>;
+            brand<TBrand extends string>(): import("./validators").VldBrand<unknown, string, TBrand>;
+            apply<TNewOutput>(fn: (schema: /*elided*/ any) => VldBase<unknown, TNewOutput>): VldBase<unknown, TNewOutput>;
+        };
+        duration: () => {
+            readonly _format: string;
+            readonly _validator: (val: string) => boolean;
+            readonly _errorMessage?: string | undefined;
+            parse(value: unknown): string;
+            safeParse(value: unknown): import("./validators").ParseResult<string>;
+            isValid(value: unknown): boolean;
+            parseOrDefault(value: unknown, defaultValue: string): string;
+            refine<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
+            refine(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
+            superRefine(refinement: (value: string, ctx: import("./validators").SuperRefineContext) => void | Promise<void>): import("./validators").VldSuperRefine<unknown, string>;
+            transform<TTransformed>(transformer: (value: string) => TTransformed): import("./validators").VldTransform<unknown, string, TTransformed>;
+            default(defaultValue: string): import("./validators").VldDefault<unknown, string>;
+            catch(fallbackValue: string): import("./validators").VldCatch<unknown, string>;
+            optional(): VldOptional<unknown, string>;
+            nullable(): VldNullable<unknown, string>;
+            nullish(): VldNullish<unknown, string>;
+            pipe<TNextOutput>(next: VldBase<string, TNextOutput>): import("./validators").VldPipe<unknown, string, TNextOutput>;
+            readonly(): import("./validators").VldReadonly<unknown, string>;
+            brand<TBrand extends string>(): import("./validators").VldBrand<unknown, string, TBrand>;
+            apply<TNewOutput>(fn: (schema: /*elided*/ any) => VldBase<unknown, TNewOutput>): VldBase<unknown, TNewOutput>;
+        };
+    };
+    stringFormat: (name: string, validator: ((val: string) => boolean) | RegExp) => {
+        readonly _format: string;
+        readonly _validator: (val: string) => boolean;
+        readonly _errorMessage?: string | undefined;
+        parse(value: unknown): string;
+        safeParse(value: unknown): import("./validators").ParseResult<string>;
+        isValid(value: unknown): boolean;
+        parseOrDefault(value: unknown, defaultValue: string): string;
+        refine<TRefined extends string>(predicate: (value: string) => value is TRefined, message?: string): import("./validators").VldRefine<unknown, string, TRefined>;
+        refine(predicate: (value: string) => boolean, message?: string): import("./validators").VldRefine<unknown, string, string>;
+        superRefine(refinement: (value: string, ctx: import("./validators").SuperRefineContext) => void | Promise<void>): import("./validators").VldSuperRefine<unknown, string>;
+        transform<TTransformed>(transformer: (value: string) => TTransformed): import("./validators").VldTransform<unknown, string, TTransformed>;
+        default(defaultValue: string): import("./validators").VldDefault<unknown, string>;
+        catch(fallbackValue: string): import("./validators").VldCatch<unknown, string>;
+        optional(): VldOptional<unknown, string>;
+        nullable(): VldNullable<unknown, string>;
+        nullish(): VldNullish<unknown, string>;
+        pipe<TNextOutput>(next: VldBase<string, TNextOutput>): import("./validators").VldPipe<unknown, string, TNextOutput>;
+        readonly(): import("./validators").VldReadonly<unknown, string>;
+        brand<TBrand extends string>(): import("./validators").VldBrand<unknown, string, TBrand>;
+        apply<TNewOutput>(fn: (schema: /*elided*/ any) => VldBase<unknown, TNewOutput>): VldBase<unknown, TNewOutput>;
+    };
+    templateLiteral: (...components: (VldBase<any, any> | string)[]) => import("./validators").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>;
 };
+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 default v;
 //# sourceMappingURL=index.d.ts.map