import { type Err, type Result } from './utils.js';
export interface DecodeContext {
    coerceToString?: Coercer<string>;
    coerceToNumber?: Coercer<number>;
    coerceToBoolean?: Coercer<boolean>;
    coerceToDate?: Coercer<Date>;
    coerceToBigInt?: Coercer<bigint>;
    coerceToArray?: (value: unknown) => unknown;
    acceptNaN?: boolean;
    unknownFields?: 'reject' | 'drop' | 'discard';
}
export interface DecoderOpts extends DecodeContext {
    coerceNumberToString?: boolean;
    coerceNumberToBoolean?: boolean;
    coerceStringToNumber?: boolean;
    coerceScalar?: boolean;
    coerceStringToDate?: boolean;
    coerceNumberToDate?: boolean;
    coerceDate?: boolean;
    coerceAll?: boolean;
    coerceStringToBigInt?: boolean;
    coerceNumberToBigInt?: boolean;
    coerceBigInt?: boolean;
}
export type Coercer<T> = (value: unknown) => Result<T, RTError>;
export type Validator<T> = (value: T) => Result<T, RTError>;
export type AsyncValidator<T> = (value: T) => Result<T, RTError> | Promise<Result<T, RTError>>;
export declare function runCoercer<T>(coercer: Coercer<T>, u: unknown): Result<T, RTError>;
export declare abstract class Type<T> {
    abstract print(): string;
    abstract decode(u: unknown, opts: DecodeContext): Result<T, RTError>;
    abstract validate(v: T, opts: DecodeContext): Promise<Result<T, RTError>>;
    abstract validateSync(v: T, opts: DecodeContext): Result<T, RTError>;
    validators?: Validator<T>[];
    asyncValidators?: AsyncValidator<T>[];
    addValidator(validator: Validator<T>): this;
    addAsyncValidator(validator: AsyncValidator<T>): this;
    validateBase(v: T, _opts: DecodeContext): Promise<Result<T, RTError>>;
    protected checkSync(): void;
    validateBaseSync(v: T, _opts: DecodeContext): Result<T, RTError>;
    default(value: DefaultValue<T>): Type<T>;
    optional(): OptionalType<T>;
    nullable(): NullableType<T>;
    deepMap(_fn: (t: Type<unknown>) => Type<unknown>): Type<unknown>;
}
export declare function copyValidators<S, D extends Type<any>>(src: Type<S>, dst: D): D;
export declare class AsyncValidatorError extends Error {
    readonly type: Type<any>;
    constructor(type: Type<any>);
}
export type TypeOf<D> = D extends {
    decode: (u: unknown, opts: DecodeContext) => Result<infer T, RTError>;
} ? T : never;
export type RTError = {
    path: string[];
    error: string;
}[];
export declare function decode<T>(type: Type<T>, value: unknown, opts?: DecoderOpts): Result<T, RTError>;
export declare function validate<T>(type: Type<T>, value: unknown, opts?: DecoderOpts): Promise<Result<T, RTError>>;
export declare function validateSync<T>(type: Type<T>, value: unknown, opts?: DecoderOpts): Result<T, RTError>;
export declare function error(error: string, path?: string[]): Err<RTError>;
export declare function resolveContext(opts: DecoderOpts): DecodeContext;
export type DefaultValue<T> = T extends object ? () => T : T | (() => T);
export declare class DefaultType<T> extends Type<T> {
    type: Type<T>;
    defaultValue: T | (() => T);
    constructor(type: Type<T>, defaultValue: DefaultValue<T>);
    private getDefault;
    print(): string;
    decode(u: unknown, opts: DecodeContext): Result<T, RTError>;
    validate(v: T, opts: DecodeContext): Promise<Result<T, RTError>>;
    validateSync(v: T, opts: DecodeContext): Result<T, RTError>;
}
export declare class OptionalType<T> extends Type<T | undefined> {
    type: Type<T>;
    constructor(type: Type<T>);
    print(): string;
    decode(u: unknown, opts: DecodeContext): Result<T | undefined, RTError>;
    validate(v: T | undefined, opts: DecodeContext): Promise<Result<T | undefined, RTError>>;
    validateSync(v: T | undefined, opts: DecodeContext): Result<T | undefined, RTError>;
}
export declare class NullableType<T> extends Type<T | null | undefined> {
    type: Type<T>;
    constructor(type: Type<T>);
    print(): string;
    decode(u: unknown, opts: DecodeContext): Result<any, RTError>;
    validate(v: T | null | undefined, opts: DecodeContext): Promise<Result<T | null | undefined, RTError>>;
    validateSync(v: T | null | undefined, opts: DecodeContext): Result<T | null | undefined, RTError>;
}
export declare function acceptsUndefined(type: Type<unknown>): boolean;
export declare function withDefault<T>(type: Type<T>, defaultValue: DefaultValue<T>): DefaultType<T>;
export declare function optional<T>(type: Type<T>): OptionalType<T>;
export declare function nullable<T>(type: Type<T>): NullableType<T>;