//#region index.d.ts
interface Ctx {
  path: string;
  key: string | number | null;
  parent: any;
  root: any;
  __abortPipe?: boolean;
  __collectErrors?: boolean;
  __errors?: ValidationError[];
  [key: string]: any;
}
type Validator<Input = any, Output = Input> = (value: Input, ctx: Ctx) => Output;
interface ValidationError extends Error {
  expected?: string;
  actual?: any;
  path?: string;
  key?: string | number | null;
  parent?: any;
  root?: any;
}
type ValidatorFactory<Input = any, Output = Input, Args extends any[] = any[]> = (...args: Args) => Validator<Input, Output>;
declare function makeCtx(parentCtx: Ctx | null, key: string | number | null, value: any, root?: any): Ctx;
declare function formatValue(value: any): string;
declare function createValidator<I = unknown, O = I, Args extends any[] = any[]>(name: string, handler: (value: I, ctx: Ctx, args: Args) => O): (...args: Args) => Validator<I, O>;
interface ControlValidator {
  __control?: true;
}
type IsControl<V> = V extends ControlValidator ? true : false;
type InputOf<V> = V extends ((value: infer I, ctx: Ctx) => any) ? I : never;
type OutputOf<V> = V extends ((value: any, ctx: Ctx) => infer O) ? O : never;
type Simplify<T> = { [K in keyof T]: T[K] } & {};
type DeepSimplify<T> = T extends string | number | boolean | bigint | symbol | null | undefined ? T : T extends Function ? T : T extends (infer U)[] ? Array<DeepSimplify<U>> : T extends object ? Simplify<{ [K in keyof T]: DeepSimplify<T[K]> }> : T;
type InferOutput<V> = V extends ((value: any, ctx: Ctx) => infer O) ? DeepSimplify<O> : never;
type Last<T extends unknown[]> = T extends [...any[], infer L] ? L : never;
type ValidateChain<Vs extends unknown[]> = Vs extends [infer V1, infer V2, ...infer Rest] ? IsControl<V1> extends true ? [V1, ...ValidateChain<[V2, ...Rest]>] : OutputOf<V1> extends InputOf<V2> ? [V1, ...ValidateChain<[V2, ...Rest]>] : never : Vs;
declare function pipe<Vs extends [Validator<any, any>, ...(Validator<any, any>)[]]>(...validators: ValidateChain<Vs>): Validator<InputOf<Vs[0]>, OutputOf<Last<Vs>>>;
declare function transform<I = any, O = any>(fn: (value: I, ctx: Ctx) => O): Validator<I, O>;
declare function check<I = any>(fn: (value: I, ctx: Ctx) => boolean, msg?: string): Validator<I, I>;
type ValidateResult<O> = {
  valid: true;
  result: O;
  error?: undefined;
} | {
  valid: false;
  error: ValidationError;
  result: any;
};
declare function validate<I, O>(schema: Validator<I, O>, value: I, rootPath?: string): ValidateResult<O>;
type ValidateAllResult<O> = {
  valid: true;
  result: O;
  errors: [];
} | {
  valid: false;
  result: any;
  errors: ValidationError[];
};
declare function validateAll<I, O>(schema: Validator<I, O>, value: I, rootPath?: string): ValidateAllResult<O>;
declare const required: (args_0?: string | undefined) => Validator<any, any>;
declare const optional: () => (Validator<any, any> & ControlValidator);
declare const any: (...args: any[]) => Validator<any, any>;
declare const string: (args_0?: string | undefined) => Validator<string, string>;
declare const number: (args_0?: string | undefined) => Validator<number, number>;
declare const bigint: (args_0?: string | undefined) => Validator<bigint, bigint>;
declare const boolean: (args_0?: string | undefined) => Validator<boolean, boolean>;
declare const symbol: (args_0?: string | undefined) => Validator<symbol, symbol>;
type InferShape<S> = { [K in keyof S]: S[K] extends Validator<any, infer O> ? O : never };
declare function object<S extends Record<string, Validator<any, any>>>(shape?: S, msg?: string): Validator<unknown, InferShape<S>>;
declare function array<T>(validator?: Validator<any, T>, msg?: string): Validator<T[], T[]>;
//#endregion
export { ControlValidator, Ctx, InferOutput, InferShape, InputOf, OutputOf, ValidateAllResult, ValidateResult, ValidationError, Validator, ValidatorFactory, any, array, bigint, boolean, check, createValidator, formatValue, makeCtx, number, object, optional, pipe, required, string, symbol, transform, validate, validateAll };