@oxog/vld 1.2.0 → 1.4.0

package/dist/index.d.ts

@@ -13,6 +13,7 @@ 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 +30,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,7 +52,7 @@ 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';
@@ -56,27 +66,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,8 +117,565 @@ 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>;